internal string GetFieldValue(BaseTransformationInformation baseTransformationInformation, string fieldName)
{
if (baseTransformationInformation.SourcePage != null)
{
return(baseTransformationInformation.SourcePage[fieldName].ToString());
}
else
{
if (baseTransformationInformation.SourceFile != null)
{
var fileServerRelativeUrl = baseTransformationInformation.SourceFile.EnsureProperty(p => p.ServerRelativeUrl);
// come up with equivalent field values for the page without listitem (so page living in the root folder of the site)
if (fieldName.Equals(Constants.FileRefField))
{
// e.g. /sites/espctest2/SitePages/demo16.aspx
return(fileServerRelativeUrl);
}
else if (fieldName.Equals(Constants.FileDirRefField))
{
// e.g. /sites/espctest2/SitePages
return(fileServerRelativeUrl.Replace($"/{System.IO.Path.GetFileName(fileServerRelativeUrl)}", ""));
}
else if (fieldName.Equals(Constants.FileLeafRefField))
{
// e.g. demo16.aspx
return(System.IO.Path.GetFileName(fileServerRelativeUrl));
}
}
return("");
}
}
internal bool FieldExistsAndIsUsed(BaseTransformationInformation baseTransformationInformation, string fieldName)
{
if (baseTransformationInformation.SourcePage != null)
{
return(baseTransformationInformation.SourcePage.FieldExistsAndUsed(fieldName));
}
else
{
return(true);
}
}
public UrlTransformator(BaseTransformationInformation baseTransformationInformation, ClientContext sourceContext, ClientContext targetContext, IList <ILogObserver> logObservers = null)
{
// Hookup logging
if (logObservers != null)
{
foreach (var observer in logObservers)
{
base.RegisterObserver(observer);
}
}
// Ensure source and target context are set
if (sourceContext == null && targetContext != null)
{
sourceContext = targetContext;
}
if (targetContext == null && sourceContext != null)
{
targetContext = sourceContext;
}
// Grab the needed information to drive url rewrite
this.sourceContext = sourceContext;
this.targetContext = targetContext;
sourceContext.Site.EnsureProperties(p => p.ServerRelativeUrl, p => p.Url);
this.sourceSiteUrl = sourceContext.Site.Url;
this.sourceWebUrl = sourceContext.Web.GetUrl();
//TODO: Check Is this always pages and sitePages part of the URL NOT title?
if (sourceContext.Web.IsPublishingWeb())
{
this.pagesLibrary = CacheManager.Instance.GetPublishingPagesLibraryName(this.sourceContext);
}
else
{
this.pagesLibrary = "sitepages";
}
this.targetWebUrl = targetContext.Web.GetUrl();
// Load the URL mapping file
if (!string.IsNullOrEmpty(baseTransformationInformation?.UrlMappingFile))
{
this.urlMapping = CacheManager.Instance.GetUrlMapping(baseTransformationInformation.UrlMappingFile, logObservers);
}
this.skipDefaultUrlRewrite = baseTransformationInformation.SkipDefaultUrlRewrite;
}
/// <summary>
/// User Transformator constructor
/// </summary>
/// <param name="baseTransformationInformation">Transformation configuration settings</param>
/// <param name="sourceContext">Source Context</param>
/// <param name="targetContext">Target Context</param>
/// <param name="logObservers">Connected loggers</param>
public UserTransformator(BaseTransformationInformation baseTransformationInformation, ClientContext sourceContext, ClientContext targetContext, IList <ILogObserver> logObservers = null)
{
// Hookup logging
if (logObservers != null)
{
foreach (var observer in logObservers)
{
base.RegisterObserver(observer);
}
}
// Ensure source and target context are set
if (sourceContext == null && targetContext != null)
{
sourceContext = targetContext;
}
if (targetContext == null && sourceContext != null)
{
targetContext = sourceContext;
}
this._sourceContext = sourceContext;
this._targetContext = targetContext;
// Load the User mapping file
if (!string.IsNullOrEmpty(baseTransformationInformation?.UserMappingFile))
{
this._userMapping = CacheManager.Instance.GetUserMapping(baseTransformationInformation.UserMappingFile, logObservers);
}
else
{
this._userMapping = default; //Pass through if there is no mapping
}
if (!string.IsNullOrEmpty(baseTransformationInformation.LDAPConnectionString))
{
_ldapSpecifiedByUser = baseTransformationInformation?.LDAPConnectionString;
}
else
{
_ldapSpecifiedByUser = default;
}
_sourceVersion = baseTransformationInformation?.SourceVersion ?? SPVersion.SPO; // SPO Fall Back
_skipUserMapping = baseTransformationInformation.SkipUserMapping;
}
/// <summary>
/// Validates settings when doing a cross farm transformation
/// </summary>
/// <param name="baseTransformationInformation">Transformation Information</param>
/// <remarks>Will disable feature if not supported</remarks>
internal void CrossFarmTransformationValidation(BaseTransformationInformation baseTransformationInformation)
{
// Source only context - allow item level permissions
// Source to target same base address - allow item level permissions
// Source to target difference base address - disallow item level permissions
if (targetClientContext != null && sourceClientContext != null)
{
if (!sourceClientContext.Url.Equals(targetClientContext.Url, StringComparison.InvariantCultureIgnoreCase))
{
baseTransformationInformation.IsCrossSiteTransformation = true;
}
var sourceUrl = sourceClientContext.Url.GetBaseUrl();
var targetUrl = targetClientContext.Url.GetBaseUrl();
// Override the setting for keeping item level permissions
if (!sourceUrl.Equals(targetUrl, StringComparison.InvariantCultureIgnoreCase))
{
baseTransformationInformation.KeepPageSpecificPermissions = false;
LogWarning(LogStrings.Warning_ContextValidationFailWithKeepPermissionsEnabled, LogStrings.Heading_InputValidation);
// Set a global flag to indicate this is a cross farm transformation (on-prem to SPO tenant or SPO Tenant A to SPO Tenant B)
baseTransformationInformation.IsCrossFarmTransformation = true;
}
}
if (sourceClientContext != null)
{
baseTransformationInformation.SourceVersion = GetVersion(sourceClientContext);
baseTransformationInformation.SourceVersionNumber = GetExactVersion(sourceClientContext);
}
if (targetClientContext != null)
{
baseTransformationInformation.TargetVersion = GetVersion(targetClientContext);
baseTransformationInformation.TargetVersionNumber = GetExactVersion(targetClientContext);
}
if (sourceClientContext != null && targetClientContext == null)
{
baseTransformationInformation.TargetVersion = baseTransformationInformation.SourceVersion;
baseTransformationInformation.TargetVersionNumber = baseTransformationInformation.SourceVersionNumber;
}
}
/// <summary>
/// Ensures that the contexts are the same for the feature to be supported
/// </summary>
/// <param name="baseTransformationInformation">Transformation Information</param>
/// <remarks>Will disable feature if not supported</remarks>
internal void EnsureItemLevelPermissionsContextsSupported(BaseTransformationInformation baseTransformationInformation)
{
// Source only context - allow item level permissions
// Source to target same base address - allow item level permissions
// Source to target difference base address - disallow item level permissions
if (targetClientContext != null && sourceClientContext != null && baseTransformationInformation.KeepPageSpecificPermissions)
{
var sourceUrl = sourceClientContext.Url.GetBaseUrl();
var targetUrl = targetClientContext.Url.GetBaseUrl();
// Override the setting for keeping item level permissions
if (!sourceUrl.Equals(targetUrl, StringComparison.InvariantCultureIgnoreCase))
{
baseTransformationInformation.KeepPageSpecificPermissions = false;
LogWarning(LogStrings.Warning_ContextValidationFailWithKeepPermissionsEnabled, LogStrings.Heading_InputValidation);
}
}
}
/// <summary>
/// Instantiates the content transformator
/// </summary>
/// <param name="page">Client side page that will be updates</param>
/// <param name="pageTransformation">Transformation information</param>
public ContentTransformator(ClientContext sourceClientContext, ClientSidePage page, PageTransformation pageTransformation, BaseTransformationInformation transformationInformation, IList <ILogObserver> logObservers = null) : base()
{
//Register any existing observers
if (logObservers != null)
{
foreach (var observer in logObservers)
{
base.RegisterObserver(observer);
}
}
this.page = page ?? throw new ArgumentException("Page cannot be null");
this.pageTransformation = pageTransformation ?? throw new ArgumentException("pageTransformation cannot be null");
this.globalTokens = CreateGlobalTokenList(page.Context, transformationInformation.MappingProperties);
this.functionProcessor = new FunctionProcessor(sourceClientContext, this.page, this.pageTransformation, transformationInformation, base.RegisteredLogObservers);
this.transformationInformation = transformationInformation;
this.sourceClientContext = sourceClientContext;
this.isCrossSiteTransfer = IsCrossSiteTransfer();
}
/// <summary>
/// Constructor for the Term Transformator class
/// </summary>
/// <param name="baseTransformationInformation"></param>
/// <param name="sourceContext"></param>
/// <param name="targetContext"></param>
/// <param name="logObservers"></param>
public TermTransformator(BaseTransformationInformation baseTransformationInformation, ClientContext sourceContext, ClientContext targetContext, IList <ILogObserver> logObservers = null)
{
// Hookup logging
if (logObservers != null)
{
foreach (var observer in logObservers)
{
base.RegisterObserver(observer);
}
}
// Ensure source and target context are set
if (sourceContext == null && targetContext != null)
{
sourceContext = targetContext;
}
if (targetContext == null && sourceContext != null)
{
targetContext = sourceContext;
}
this._sourceContext = sourceContext;
this._targetContext = targetContext;
// Load the Term mapping file
if (!string.IsNullOrEmpty(baseTransformationInformation?.TermMappingFile))
{
this.termMappings = CacheManager.Instance.GetTermMapping(baseTransformationInformation.TermMappingFile, logObservers);
}
if (baseTransformationInformation != null)
{
this.skipTermStoreMapping = baseTransformationInformation.SkipTermStoreMapping;
this._baseTransformationInformation = baseTransformationInformation;
}
}
public UrlTransformator(BaseTransformationInformation baseTransformationInformation, ClientContext sourceContext, ClientContext targetContext, IList <ILogObserver> logObservers = null)
{
// Hookup logging
if (logObservers != null)
{
foreach (var observer in logObservers)
{
base.RegisterObserver(observer);
}
}
// Ensure source and target context are set
if (sourceContext == null && targetContext != null)
{
sourceContext = targetContext;
}
if (targetContext == null && sourceContext != null)
{
targetContext = sourceContext;
}
// Grab the needed information to drive url rewrite
this.sourceContext = sourceContext;
this.targetContext = targetContext;
this.sourceSiteUrl = sourceContext.Site.EnsureProperty(p => p.Url);
this.sourceWebUrl = sourceContext.Web.EnsureProperty(p => p.Url);
this.pagesLibrary = CacheManager.Instance.GetPublishingPagesLibraryName(this.sourceContext);
this.targetWebUrl = targetContext.Web.EnsureProperty(p => p.Url);
// Load the URL mapping file
if (!string.IsNullOrEmpty(baseTransformationInformation.UrlMappingFile))
{
this.urlMapping = CacheManager.Instance.GetUrlMapping(baseTransformationInformation.UrlMappingFile, logObservers);
}
}
/// <summary>
/// Default constructor
/// </summary>
public WikiHtmlTransformator(ClientContext sourceContext, ClientSidePage page, BaseTransformationInformation basePageTransformationInformation, IList <ILogObserver> logObservers = null)
{
//Register any existing observers
if (logObservers != null)
{
foreach (var observer in logObservers)
{
base.RegisterObserver(observer);
}
}
this.sourceContext = sourceContext;
this.page = page;
this.mappingProperties = basePageTransformationInformation.MappingProperties;
// Instantiate BuiltIn functions class
this.builtInFunctions = new BuiltIn(basePageTransformationInformation, this.page.Context, this.sourceContext, this.page, base.RegisteredLogObservers);
// Instantiate the AngleSharp Html parser
parser = new HtmlParser(new HtmlParserOptions()
{
IsEmbedded = true
});
}
internal void UpdateTargetPageWithSourcePageInformation(ListItem targetPage, BaseTransformationInformation baseTransformationInformation, string serverRelativePathForModernPage, bool crossSiteTransformation)
{
try
{
FieldUserValue pageAuthor = this.SourcePageAuthor;
FieldUserValue pageEditor = this.SourcePageEditor;
// Keeping page author information is only possible when staying in SPO...for cross site support we first do need user account mapping
var sourcePlatformVersion = baseTransformationInformation.SourceVersion;
if (crossSiteTransformation && baseTransformationInformation.KeepPageCreationModificationInformation && sourcePlatformVersion == SPVersion.SPO)
{
// If transformtion is cross site collection we'll need to lookup users again
// Using a cloned context to not mess up with the pending list item updates
using (var clonedTargetContext = targetClientContext.Clone(targetClientContext.Web.GetUrl()))
{
var pageAuthorUser = clonedTargetContext.Web.EnsureUser(this.SourcePageAuthor.LookupValue);
var pageEditorUser = clonedTargetContext.Web.EnsureUser(this.SourcePageEditor.LookupValue);
clonedTargetContext.Load(pageAuthorUser);
clonedTargetContext.Load(pageEditorUser);
clonedTargetContext.ExecuteQueryRetry();
// Prep a new FieldUserValue object instance and update the list item
pageAuthor = new FieldUserValue()
{
LookupId = pageAuthorUser.Id
};
pageEditor = new FieldUserValue()
{
LookupId = pageEditorUser.Id
};
}
}
if (baseTransformationInformation.KeepPageCreationModificationInformation || baseTransformationInformation.PostAsNews)
{
if (baseTransformationInformation.KeepPageCreationModificationInformation && sourcePlatformVersion == SPVersion.SPO)
{
// All 4 fields have to be set!
targetPage[Constants.CreatedByField] = pageAuthor;
targetPage[Constants.ModifiedByField] = pageEditor;
targetPage[Constants.CreatedField] = this.SourcePageCreated;
targetPage[Constants.ModifiedField] = this.SourcePageModified;
}
if (baseTransformationInformation.PostAsNews)
{
targetPage[Constants.PromotedStateField] = "2";
// Determine what will be the publishing date that will show up in the news rollup
if (baseTransformationInformation.KeepPageCreationModificationInformation && sourcePlatformVersion == SPVersion.SPO)
{
targetPage[Constants.FirstPublishedDateField] = this.SourcePageModified;
}
else
{
targetPage[Constants.FirstPublishedDateField] = targetPage[Constants.ModifiedField];
}
}
targetPage.UpdateOverwriteVersion();
if (baseTransformationInformation.PublishCreatedPage)
{
var targetPageFile = ((targetPage.Context) as ClientContext).Web.GetFileByServerRelativeUrl(serverRelativePathForModernPage);
targetPage.Context.Load(targetPageFile);
// Try to publish, if publish is not needed/possible (e.g. when no minor/major versioning set) then this will return an error that we'll be ignoring
targetPageFile.Publish(LogStrings.PublishMessage);
}
}
targetPage.Context.ExecuteQueryRetry();
}
catch (Exception ex)
{
// Eat exceptions as this is not critical for the generated page
LogWarning(LogStrings.Warning_NonCriticalErrorDuringPublish, LogStrings.Heading_ArticlePageHandling);
}
}