/// <summary>
/// Instantiates the function processor. Also loads the defined add-ons
/// </summary>
/// <param name="sourceClientContext"></param>
/// <param name="targetClientContext"></param>
/// <param name="page">Client side page for which we're executing the functions/selectors as part of the mapping</param>
/// <param name="pageTransformation">Webpart mapping information</param>
/// <param name="baseTransformationInformation">Page transformation information</param>
/// <param name="logObservers"></param>
public FunctionProcessor(ClientContext sourceClientContext, ClientContext targetClientContext, PnPCore.IPage page, PageTransformation pageTransformation, BaseTransformationInformation baseTransformationInformation, IList <ILogObserver> logObservers = null)
{
this.page = page;
this.pageTransformation = pageTransformation;
//Register any existing observers
if (logObservers != null)
{
foreach (var observer in logObservers)
{
base.RegisterObserver(observer);
}
}
// instantiate default built in functions class
this.addOnTypes = new List <AddOnType>();
this.builtInFunctions = Activator.CreateInstance(typeof(BuiltIn), baseTransformationInformation, targetClientContext, sourceClientContext, this.page, base.RegisteredLogObservers);
// instantiate the custom function classes (if there are)
foreach (var addOn in this.pageTransformation.AddOns)
{
try
{
string path = "";
if (addOn.Assembly.Contains("\\") && System.IO.File.Exists(addOn.Assembly))
{
path = addOn.Assembly;
}
else
{
path = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, addOn.Assembly);
}
var assembly = Assembly.LoadFile(path);
var customType = assembly.GetType(addOn.Type);
var instance = Activator.CreateInstance(customType, baseTransformationInformation, targetClientContext, sourceClientContext, this.page, base.RegisteredLogObservers);
this.addOnTypes.Add(new AddOnType()
{
Name = addOn.Name,
Assembly = assembly,
Instance = instance,
Type = customType,
});
}
catch (Exception ex)
{
LogError(LogStrings.Error_FailedToInitiateCustomFunctionClasses, LogStrings.Heading_FunctionProcessor, ex);
throw;
}
}
}
/// <summary>
/// Creates a layout transformator instance
/// </summary>
/// <param name="page">Client side page that will be receive the created layout</param>
/// <param name="pageLayoutMappingModel"></param>
/// <param name="logObservers"></param>
public PublishingLayoutTransformator(PnPCore.IPage page, PageLayout pageLayoutMappingModel, IList <ILogObserver> logObservers = null)
{
// Register observers
if (logObservers != null)
{
foreach (var observer in logObservers)
{
base.RegisterObserver(observer);
}
}
this.page = page;
this.pageLayoutMappingModel = pageLayoutMappingModel;
}
/// <summary>
/// Instantiates the content transformator
/// </summary>
/// <param name="sourceClientContext"></param>
/// <param name="targetClientContext"></param>
/// <param name="page">Client side page that will be updates</param>
/// <param name="pageTransformation">Transformation information</param>
/// <param name="transformationInformation"></param>
/// <param name="logObservers"></param>
public ContentTransformator(ClientContext sourceClientContext, ClientContext targetClientContext, PnPCore.IPage 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(targetClientContext, transformationInformation.MappingProperties);
this.functionProcessor = new FunctionProcessor(sourceClientContext, targetClientContext, this.page, this.pageTransformation, transformationInformation, base.RegisteredLogObservers);
this.transformationInformation = transformationInformation;
this.sourceClientContext = sourceClientContext;
this.targetClientContext = targetClientContext;
this.isCrossSiteTransfer = IsCrossSiteTransfer();
}
internal PnPCore.IPageComponent GetComponent(PnPCore.IPage page)
{
if (_component != null)
{
return(_component);
}
else if (!string.IsNullOrEmpty(_name))
{
PnPCore.IPageComponent com = page.AvailablePageComponents(_name).FirstOrDefault();
return(com);
}
else if (_id != Guid.Empty)
{
string idAsString = _id.ToString();
var comQuery = from c in page.AvailablePageComponents(_name)
where c.Id == idAsString
select c;
return(comQuery.FirstOrDefault());
}
else
{
return(null);
}
}
/// <summary>
/// Default constructor
/// </summary>
public WikiHtmlTransformator(ClientContext sourceContext, ClientContext targetContext, PnPCore.IPage 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, targetContext, this.sourceContext, this.page, base.RegisteredLogObservers);
// Instantiate the AngleSharp Html parser
parser = new HtmlParser(new HtmlParserOptions()
{
IsEmbedded = true
});
}
private void SetPageTitle(PublishingPageTransformationInformation publishingPageTransformationInformation, PnPCore.IPage targetPage)
{
string titleValue = "";
if (publishingPageTransformationInformation.SourcePage.FieldExistsAndUsed(Constants.TitleField))
{
titleValue = publishingPageTransformationInformation.SourcePage[Constants.TitleField].ToString();
}
else if (publishingPageTransformationInformation.SourcePage.FieldExistsAndUsed(Constants.FileLeafRefField))
{
titleValue = Path.GetFileNameWithoutExtension((publishingPageTransformationInformation.SourcePage[Constants.FileLeafRefField].ToString()));
}
if (!string.IsNullOrEmpty(titleValue))
{
titleValue = titleValue.First().ToString().ToUpper() + titleValue.Substring(1);
targetPage.PageTitle = titleValue;
LogInfo($"{LogStrings.TransformPageModernTitle} {titleValue}", LogStrings.Heading_SetPageTitle);
}
}
/// <summary>
/// Transform the publishing page
/// </summary>
/// <param name="publishingPageTransformationInformation">Information about the publishing page to transform</param>
/// <returns>The path to the created modern page</returns>
public string Transform(PublishingPageTransformationInformation publishingPageTransformationInformation)
{
SetPageId(Guid.NewGuid().ToString());
var logsForSettings = this.DetailSettingsAsLogEntries(publishingPageTransformationInformation);
logsForSettings?.ForEach(o => Log(o, LogLevel.Information));
#region Input validation
if (publishingPageTransformationInformation.SourcePage == null)
{
LogError(LogStrings.Error_SourcePageNotFound, LogStrings.Heading_InputValidation);
throw new ArgumentNullException(LogStrings.Error_SourcePageNotFound);
}
// Validate page and it's eligibility for transformation
if (!publishingPageTransformationInformation.SourcePage.FieldExistsAndUsed(Constants.FileRefField) || !publishingPageTransformationInformation.SourcePage.FieldExistsAndUsed(Constants.FileLeafRefField))
{
LogError(LogStrings.Error_PageNotValidMissingFileRef, LogStrings.Heading_InputValidation);
throw new ArgumentException(LogStrings.Error_PageNotValidMissingFileRef);
}
string pageType = publishingPageTransformationInformation.SourcePage.PageType();
if (pageType.Equals("ClientSidePage", StringComparison.InvariantCultureIgnoreCase))
{
LogError(LogStrings.Error_SourcePageIsModern, LogStrings.Heading_InputValidation);
throw new ArgumentException(LogStrings.Error_SourcePageIsModern);
}
if (pageType.Equals("AspxPage", StringComparison.InvariantCultureIgnoreCase))
{
LogError(LogStrings.Error_BasicASPXPageCannotTransform, LogStrings.Heading_InputValidation);
throw new ArgumentException(LogStrings.Error_BasicASPXPageCannotTransform);
}
if (pageType.Equals("WikiPage", StringComparison.InvariantCultureIgnoreCase) || pageType.Equals("WebPartPage", StringComparison.InvariantCultureIgnoreCase))
{
LogError(LogStrings.Error_PageIsNotAPublishingPage, LogStrings.Heading_InputValidation);
throw new ArgumentException(LogStrings.Error_PageIsNotAPublishingPage);
}
if (IsDelveBlogPage(pageType))
{
LogError(LogStrings.Error_DelveBlogPagesNotSupported, LogStrings.Heading_InputValidation);
throw new ArgumentException(LogStrings.Error_DelveBlogPagesNotSupported);
}
// Disable cross-farm item level permissions from copying
CrossFarmTransformationValidation(publishingPageTransformationInformation);
LogDebug(LogStrings.ValidationChecksComplete, LogStrings.Heading_InputValidation);
#endregion
try
{
#region Telemetry
#if DEBUG && MEASURE
Start();
#endif
DateTime transformationStartDateTime = DateTime.Now;
LogDebug(LogStrings.LoadingClientContextObjects, LogStrings.Heading_SharePointConnection);
LoadClientObject(sourceClientContext, false);
LogInfo($"{sourceClientContext.Web.GetUrl()}", LogStrings.Heading_Summary, LogEntrySignificance.SourceSiteUrl);
LogDebug(LogStrings.LoadingTargetClientContext, LogStrings.Heading_SharePointConnection);
LoadClientObject(targetClientContext, true);
PopulateGlobalProperties(sourceClientContext, targetClientContext);
if (sourceClientContext.Site.Id.Equals(targetClientContext.Site.Id))
{
// Oops, seems source and target point to the same site collection...that's a no go for publishing portal page transformation!
LogError(LogStrings.Error_SameSiteTransferNoAllowedForPublishingPages, LogStrings.Heading_SharePointConnection);
throw new ArgumentNullException(LogStrings.Error_SameSiteTransferNoAllowedForPublishingPages);
}
LogInfo($"{targetClientContext.Web.GetUrl()}", LogStrings.Heading_Summary, LogEntrySignificance.TargetSiteUrl);
// Need to add further validation for target template
if (targetClientContext.Web.WebTemplate != "SITEPAGEPUBLISHING" && targetClientContext.Web.WebTemplate != "STS" &&
targetClientContext.Web.WebTemplate != "GROUP" && targetClientContext.Web.WebTemplate != "BDR" && targetClientContext.Web.WebTemplate != "DEV")
{
LogError(LogStrings.Error_CrossSiteTransferTargetsNonModernSite);
throw new ArgumentException(LogStrings.Error_CrossSiteTransferTargetsNonModernSite, LogStrings.Heading_SharePointConnection);
}
// Ensure PostAsNews is used together with PagePublishing
if (publishingPageTransformationInformation.PostAsNews && !publishingPageTransformationInformation.PublishCreatedPage)
{
publishingPageTransformationInformation.PublishCreatedPage = true;
LogWarning(LogStrings.Warning_PostingAPageAsNewsRequiresPagePublishing, LogStrings.Heading_Summary);
}
// Mark this web as publishing web
CacheManager.Instance.SetPublishingWeb(this.sourceClientContext.Web.GetUrl());
// Store the information of the source page we do want to retain
if (publishingPageTransformationInformation.KeepPageCreationModificationInformation)
{
StoreSourcePageInformationToKeep(publishingPageTransformationInformation.SourcePage);
}
LogInfo($"{publishingPageTransformationInformation.SourcePage[Constants.FileRefField].ToString()}", LogStrings.Heading_Summary, LogEntrySignificance.SourcePage);
var spVersion = publishingPageTransformationInformation.SourceVersion;
var exactSpVersion = publishingPageTransformationInformation.SourceVersionNumber;
LogInfo($"{spVersion.DisplaySharePointVersion()} ({exactSpVersion})", LogStrings.Heading_Summary, LogEntrySignificance.SharePointVersion);
LogInfo(LogStrings.TransformationModePublishing, LogStrings.Heading_Summary, LogEntrySignificance.TransformMode);
//Load User Mapping File
InitializeUserMapping(publishingPageTransformationInformation);
#if DEBUG && MEASURE
Stop("Telemetry");
#endif
#endregion
#region Page creation
// Detect if the page is living inside a folder
LogDebug(LogStrings.DetectIfPageIsInFolder, LogStrings.Heading_PageCreation);
string pageFolder = "";
// Get the publishing pages library name
this.publishingPagesLibraryName = CacheManager.Instance.GetPublishingPagesLibraryName(this.sourceClientContext);
if (publishingPageTransformationInformation.SourcePage.FieldExistsAndUsed(Constants.FileDirRefField))
{
var fileRefFieldValue = publishingPageTransformationInformation.SourcePage[Constants.FileDirRefField].ToString();
if (fileRefFieldValue.ContainsIgnoringCasing($"/{this.publishingPagesLibraryName}"))
{
string pagesLibraryRelativeUrl = $"{sourceClientContext.Web.ServerRelativeUrl.TrimEnd(new[] { '/' })}/{this.publishingPagesLibraryName}";
pageFolder = fileRefFieldValue.Replace(pagesLibraryRelativeUrl, "", StringComparison.InvariantCultureIgnoreCase).Trim();
}
else
{
// Page was living in another list, leave the list name as that will be the folder hosting the modern file in SitePages.
// This convention is used to avoid naming conflicts
pageFolder = fileRefFieldValue.Replace($"{sourceClientContext.Web.ServerRelativeUrl}", "").Trim();
}
if (pageFolder.Length > 0 || !string.IsNullOrEmpty(publishingPageTransformationInformation.TargetPageFolder))
{
if (pageFolder.StartsWith("/"))
{
if (pageFolder == "/")
{
pageFolder = "";
}
else
{
pageFolder = pageFolder.Substring(1);
}
}
// Add a trailing slash
pageFolder = pageFolder + "/";
if (!string.IsNullOrEmpty(publishingPageTransformationInformation.TargetPageFolder))
{
// Handle special case <root> to indicate page should be created in the root folder
if (publishingPageTransformationInformation.TargetPageFolder.Equals("<root>", StringComparison.InvariantCultureIgnoreCase))
{
publishingPageTransformationInformation.TargetPageFolder = "";
}
if (publishingPageTransformationInformation.TargetPageFolderOverridesDefaultFolder)
{
pageFolder = publishingPageTransformationInformation.TargetPageFolder;
}
else
{
pageFolder = Path.Combine(pageFolder, publishingPageTransformationInformation.TargetPageFolder);
}
if (!pageFolder.EndsWith("/"))
{
// Add a trailing slash
pageFolder = pageFolder + "/";
}
}
LogInfo(LogStrings.PageIsLocatedInFolder, LogStrings.Heading_PageCreation);
}
}
publishingPageTransformationInformation.Folder = pageFolder;
// If no targetname specified then we'll come up with one
if (string.IsNullOrEmpty(publishingPageTransformationInformation.TargetPageName))
{
LogInfo(LogStrings.CrossSiteInUseUsingOriginalFileName, LogStrings.Heading_PageCreation);
publishingPageTransformationInformation.TargetPageName = $"{publishingPageTransformationInformation.SourcePage[Constants.FileLeafRefField].ToString()}";
}
// Check if page name is free to use
#if DEBUG && MEASURE
Start();
#endif
bool pageExists = false;
PnPCore.IPage targetPage = null;
List pagesLibrary = null;
Microsoft.SharePoint.Client.File existingFile = null;
//The determines of the target client context has been specified and use that to generate the target page
var context = targetClientContext;
try
{
LogDebug(LogStrings.LoadingExistingPageIfExists, LogStrings.Heading_PageCreation);
// Just try to load the page in the fastest possible manner, we only want to see if the page exists or not
existingFile = Load(sourceClientContext, targetClientContext, publishingPageTransformationInformation, out pagesLibrary);
pageExists = true;
}
catch (Exception ex)
{
if (ex is ArgumentException)
{
//Non-critical error generated
LogInfo(LogStrings.CheckPageExistsError, LogStrings.Heading_PageCreation);
}
else
{
//Something else occurred
LogError(LogStrings.CheckPageExistsError, LogStrings.Heading_PageCreation, ex);
}
}
#if DEBUG && MEASURE
Stop("Load Page");
#endif
if (pageExists)
{
LogInfo(LogStrings.PageAlreadyExistsInTargetLocation, LogStrings.Heading_PageCreation);
if (!publishingPageTransformationInformation.Overwrite)
{
var message = $"{LogStrings.PageNotOverwriteIfExists} {publishingPageTransformationInformation.TargetPageName}.";
LogError(message, LogStrings.Heading_PageCreation);
throw new ArgumentException(message);
}
}
// Create the client side page
targetPage = context.Web.AddClientSidePage($"{publishingPageTransformationInformation.Folder}{publishingPageTransformationInformation.TargetPageName}");
LogInfo($"{LogStrings.ModernPageCreated} ", LogStrings.Heading_PageCreation);
#endregion
LogInfo(LogStrings.TransformSourcePageAsArticlePage, LogStrings.Heading_ArticlePageHandling);
#region Analysis of the source page
#if DEBUG && MEASURE
Start();
#endif
// Analyze the source page
Tuple <Pages.PageLayout, List <WebPartEntity> > pageData = null;
LogInfo($"{LogStrings.TransformSourcePageIsPublishingPage} - {LogStrings.TransformSourcePageAnalysing}", LogStrings.Heading_ArticlePageHandling);
// Grab the pagelayout mapping to use:
var pageLayoutMappingModel = new PageLayoutManager(this.RegisteredLogObservers).GetPageLayoutMappingModel(this.publishingPageTransformation, publishingPageTransformationInformation.SourcePage);
if (spVersion == SPVersion.SP2010 || spVersion == SPVersion.SP2013Legacy || spVersion == SPVersion.SP2016Legacy)
{
pageData = new PublishingPageOnPremises(publishingPageTransformationInformation.SourcePage, pageTransformation, this.publishingPageTransformation, publishingPageTransformationInformation as BaseTransformationInformation, targetContext: targetClientContext, logObservers: base.RegisteredLogObservers).Analyze(pageLayoutMappingModel);
}
else
{
pageData = new PublishingPage(publishingPageTransformationInformation.SourcePage, pageTransformation, this.publishingPageTransformation, publishingPageTransformationInformation as BaseTransformationInformation, targetContext: targetClientContext, logObservers: base.RegisteredLogObservers).Analyze(pageLayoutMappingModel);
}
// Wiki content can contain embedded images and videos, which is not supported by the target RTE...split wiki text blocks so the transformator can handle the images and videos as separate web parts
LogInfo(LogStrings.WikiTextContainsImagesVideosReferences, LogStrings.Heading_ArticlePageHandling);
pageData = new Tuple <Pages.PageLayout, List <WebPartEntity> >(pageData.Item1, new WikiHtmlTransformator(this.sourceClientContext, this.targetClientContext, targetPage, publishingPageTransformationInformation as BaseTransformationInformation, base.RegisteredLogObservers).TransformPlusSplit(pageData.Item2, publishingPageTransformationInformation.HandleWikiImagesAndVideos, publishingPageTransformationInformation.AddTableListImageAsImageWebPart));
#if DEBUG && MEASURE
Stop("Analyze page");
#endif
#endregion
#region Page title configuration
#if DEBUG && MEASURE
Start();
#endif
// Set page title
SetPageTitle(publishingPageTransformationInformation, targetPage);
if (publishingPageTransformationInformation.PageTitleOverride != null)
{
var title = publishingPageTransformationInformation.PageTitleOverride(targetPage.PageTitle);
targetPage.PageTitle = title;
LogInfo($"{LogStrings.TransformPageTitleOverride} - page title: {title}", LogStrings.Heading_ArticlePageHandling);
}
#if DEBUG && MEASURE
Stop("Set page title");
#endif
#endregion
#region Page layout configuration
#if DEBUG && MEASURE
Start();
#endif
// Use the default layout transformator
ILayoutTransformator layoutTransformator = new LayoutTransformator(targetPage);
// Do we have an override?
bool useCustomLayoutTransformator = false;
if (publishingPageTransformationInformation.LayoutTransformatorOverride != null)
{
LogInfo(LogStrings.TransformLayoutTransformatorOverride, LogStrings.Heading_ArticlePageHandling);
layoutTransformator = publishingPageTransformationInformation.LayoutTransformatorOverride(targetPage);
useCustomLayoutTransformator = true;
}
// Apply the layout to the page
layoutTransformator.Transform(pageData);
// If needed call the specific publishing page layout transformator
if ((pageData.Item1 == Pages.PageLayout.PublishingPage_AutoDetect || pageData.Item1 == Pages.PageLayout.PublishingPage_AutoDetectWithVerticalColumn || pageData.Item1 == Pages.PageLayout.PublishingPage_TwoColumnRightVerticalSection || pageData.Item1 == Pages.PageLayout.PublishingPage_TwoColumnLeftVerticalSection) && !useCustomLayoutTransformator)
{
// Call out the specific publishing layout transformator implementation
PublishingLayoutTransformator publishingLayoutTransformator = new PublishingLayoutTransformator(targetPage, pageLayoutMappingModel, base.RegisteredLogObservers);
publishingLayoutTransformator.Transform(pageData);
}
#if DEBUG && MEASURE
Stop("Page layout");
#endif
#endregion
#region Content transformation
LogDebug(LogStrings.PreparingContentTransformation, LogStrings.Heading_ArticlePageHandling);
#if DEBUG && MEASURE
Start();
#endif
// Use the default content transformator
IContentTransformator contentTransformator = new ContentTransformator(sourceClientContext, targetClientContext, targetPage, pageTransformation, publishingPageTransformationInformation as BaseTransformationInformation, base.RegisteredLogObservers);
// Do we have an override?
if (publishingPageTransformationInformation.ContentTransformatorOverride != null)
{
LogInfo(LogStrings.TransformUsingContentTransformerOverride, LogStrings.Heading_ArticlePageHandling);
contentTransformator = publishingPageTransformationInformation.ContentTransformatorOverride(targetPage, pageTransformation);
}
LogInfo(LogStrings.TransformingContentStart, LogStrings.Heading_ArticlePageHandling);
// Run the content transformator
contentTransformator.Transform(pageData.Item2.Where(c => !c.IsClosed).ToList());
LogInfo(LogStrings.TransformingContentEnd, LogStrings.Heading_ArticlePageHandling);
#if DEBUG && MEASURE
Stop("Content transformation");
#endif
#endregion
#region Configure header for target page
#if DEBUG && MEASURE
Start();
#endif
PublishingPageHeaderTransformator headerTransformator = new PublishingPageHeaderTransformator(publishingPageTransformationInformation, sourceClientContext, targetClientContext, this.publishingPageTransformation, base.RegisteredLogObservers);
headerTransformator.TransformHeader(ref targetPage);
#if DEBUG && MEASURE
Stop("Target page header");
#endif
#endregion
#region Text/Section/Column cleanup
// Drop "empty" text parts. Wiki pages tend to have a lot of text parts just containing div's and BR's...no point in keep those as they generate to much whitespace
RemoveEmptyTextParts(targetPage);
// Remove empty sections and columns to optimize screen real estate
if (publishingPageTransformationInformation.RemoveEmptySectionsAndColumns)
{
RemoveEmptySectionsAndColumns(targetPage);
}
#endregion
#region Page persisting + permissions
#region Save the page
#if DEBUG && MEASURE
Start();
#endif
// Persist the client side page
var pageName = $"{publishingPageTransformationInformation.Folder}{publishingPageTransformationInformation.TargetPageName}";
targetPage.Save(pageName);
LogInfo($"{LogStrings.TransformSavedPageInCrossSiteCollection}: {pageName}", LogStrings.Heading_ArticlePageHandling);
// Load the page list item
string pageNameToLoad = pageName;
if (pageNameToLoad.StartsWith("/"))
{
pageNameToLoad = pageNameToLoad.Substring(1);
}
var savedTargetPage = targetClientContext.Web.GetFileByServerRelativePath(ResourcePath.FromDecodedUrl($"{targetPage.PagesLibrary.RootFolder.ServerRelativeUrl}/{pageNameToLoad}"));
targetClientContext.Web.Context.Load(savedTargetPage, p => p.ListItemAllFields);
targetClientContext.Web.Context.ExecuteQueryRetry();
#if DEBUG && MEASURE
Stop("Persist page");
#endif
#endregion
#region Page metadata handling
PublishingMetadataTransformator publishingMetadataTransformator =
new PublishingMetadataTransformator(publishingPageTransformationInformation, sourceClientContext, targetClientContext, savedTargetPage, targetPage,
pageLayoutMappingModel, this.publishingPageTransformation, this.userTransformator, base.RegisteredLogObservers);
publishingMetadataTransformator.Transform();
#endregion
#region Permission handling
ListItemPermission listItemPermissionsToKeep = null;
if (publishingPageTransformationInformation.KeepPageSpecificPermissions)
{
#if DEBUG && MEASURE
Start();
#endif
// Check if we do have item level permissions we want to take over
listItemPermissionsToKeep = GetItemLevelPermissions(true, pagesLibrary, publishingPageTransformationInformation.SourcePage, savedTargetPage.ListItemAllFields);
// When creating the page in another site collection we'll always want to copy item level permissions if specified
ApplyItemLevelPermissions(true, savedTargetPage.ListItemAllFields, listItemPermissionsToKeep);
#if DEBUG && MEASURE
Stop("Permission handling");
#endif
}
#endregion
#region Page Publishing
// Tag the file with a page modernization version stamp
string serverRelativePathForModernPage = savedTargetPage.ListItemAllFields[Constants.FileRefField].ToString();
bool pageListItemWasReloaded = false;
try
{
var targetPageFile = context.Web.GetFileByServerRelativeUrl(serverRelativePathForModernPage);
context.Load(targetPageFile, p => p.Properties);
targetPageFile.Properties["sharepointpnp_pagemodernization"] = this.version;
targetPageFile.Update();
// In case of KeepPageCreationModificationInformation and PostAsNews the publishing is handled at the very end of the flow, so skip it right here
if (!publishingPageTransformationInformation.KeepPageCreationModificationInformation &&
!publishingPageTransformationInformation.PostAsNews &&
publishingPageTransformationInformation.PublishCreatedPage)
{
// 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);
}
// Ensure we've the most recent page list item loaded, must be last statement before calling ExecuteQuery
context.Load(savedTargetPage.ListItemAllFields);
// Send both the property update and publish as a single operation to SharePoint
context.ExecuteQueryRetry();
pageListItemWasReloaded = true;
}
catch (Exception)
{
// Eat exceptions as this is not critical for the generated page
LogWarning(LogStrings.Warning_NonCriticalErrorDuringVersionStampAndPublish, LogStrings.Heading_ArticlePageHandling);
}
// Update flags field to indicate this is a "migrated" page
try
{
// If for some reason the reload batched with the previous request did not finish then do it again
if (!pageListItemWasReloaded)
{
context.Load(savedTargetPage.ListItemAllFields);
context.ExecuteQueryRetry();
}
// Only perform the update when the field was not yet set
bool skipSettingMigratedFromServerRendered = false;
if (savedTargetPage.ListItemAllFields[Constants.SPSitePageFlagsField] != null)
{
skipSettingMigratedFromServerRendered = (savedTargetPage.ListItemAllFields[Constants.SPSitePageFlagsField] as string[]).Contains("MigratedFromServerRendered");
}
if (!skipSettingMigratedFromServerRendered)
{
savedTargetPage.ListItemAllFields[Constants.SPSitePageFlagsField] = ";#MigratedFromServerRendered;#";
// Don't use UpdateOverWriteVersion as the listitem already exists
// resulting in an "Additions to this Web site have been blocked" error
savedTargetPage.ListItemAllFields.SystemUpdate();
context.Load(savedTargetPage.ListItemAllFields);
context.ExecuteQueryRetry();
}
}
catch (Exception)
{
// Eat any exception
}
// Disable page comments on the create page, if needed
if (publishingPageTransformationInformation.DisablePageComments)
{
targetPage.DisableComments();
LogInfo(LogStrings.TransformDisablePageComments, LogStrings.Heading_ArticlePageHandling);
}
#endregion
#region Restore page author/editor/created/modified
if ((publishingPageTransformationInformation.KeepPageCreationModificationInformation && this.SourcePageAuthor != null && this.SourcePageEditor != null) ||
publishingPageTransformationInformation.PostAsNews)
{
UpdateTargetPageWithSourcePageInformation(savedTargetPage.ListItemAllFields, publishingPageTransformationInformation, serverRelativePathForModernPage, true);
}
#endregion
// NO page updates are allowed anymore past this point as otherwise the set page usage information and published/posted state will be impacted!
#region Telemetry
if (!publishingPageTransformationInformation.SkipTelemetry && this.pageTelemetry != null)
{
TimeSpan duration = DateTime.Now.Subtract(transformationStartDateTime);
this.pageTelemetry.LogTransformationDone(duration, pageType, publishingPageTransformationInformation);
this.pageTelemetry.Flush();
}
LogInfo(LogStrings.TransformComplete, LogStrings.Heading_PageCreation);
#endregion
#region Closing
CacheManager.Instance.SetLastUsedTransformator(this);
LogInfo($"{serverRelativePathForModernPage}", LogStrings.Heading_Summary, LogEntrySignificance.TargetPage);
return(Uri.EscapeUriString(serverRelativePathForModernPage));
#endregion
#endregion
}
catch (Exception ex)
{
LogError(LogStrings.CriticalError_ErrorOccurred, LogStrings.Heading_Summary, ex, isCriticalException: true);
// Throw exception if there's no registered log observers
if (base.RegisteredLogObservers.Count == 0)
{
throw;
}
}
return(string.Empty);
}
/// <summary>
/// Creates a layout transformator instance
/// </summary>
/// <param name="page">Client side page that will be receive the created layout</param>
public LayoutTransformator(PnPCore.IPage page)
{
this.page = page;
}
/// <summary>
/// Builds the header for the modern page
/// </summary>
/// <param name="targetPage">Modern page instance</param>
public void TransformHeader(ref PnPCore.IPage targetPage)
{
// Get the mapping model to use as it describes how the page header needs to be generated
var publishingPageTransformationModel = new PageLayoutManager(this.RegisteredLogObservers).GetPageLayoutMappingModel(this.publishingPageTransformation, publishingPageTransformationInformation.SourcePage);
// Configure the page header
if (publishingPageTransformationModel.PageHeader == PageLayoutPageHeader.None)
{
targetPage.RemovePageHeader();
}
else if (publishingPageTransformationModel.PageHeader == PageLayoutPageHeader.Default)
{
targetPage.SetDefaultPageHeader();
}
else
{
// Custom page header
// ImageServerRelativeUrl
string imageServerRelativeUrl = "";
HeaderField imageServerRelativeUrlField = GetHeaderField(publishingPageTransformationModel, HeaderFieldHeaderProperty.ImageServerRelativeUrl);
if (imageServerRelativeUrlField != null)
{
imageServerRelativeUrl = GetFieldValue(imageServerRelativeUrlField);
}
bool headerCreated = false;
// Did we get a header image url?
if (!string.IsNullOrEmpty(imageServerRelativeUrl))
{
string newHeaderImageServerRelativeUrl = "";
try
{
// Integrate asset transformator
AssetTransfer assetTransfer = new AssetTransfer(this.sourceClientContext, this.targetClientContext, base.RegisteredLogObservers);
newHeaderImageServerRelativeUrl = assetTransfer.TransferAsset(imageServerRelativeUrl, System.IO.Path.GetFileNameWithoutExtension(publishingPageTransformationInformation.SourcePage[Constants.FileLeafRefField].ToString()));
}
catch (Exception ex)
{
LogError(LogStrings.Error_HeaderImageAssetTransferFailed, LogStrings.Heading_PublishingPageHeader, ex);
}
if (!string.IsNullOrEmpty(newHeaderImageServerRelativeUrl))
{
LogInfo(string.Format(LogStrings.SettingHeaderImage, newHeaderImageServerRelativeUrl), LogStrings.Heading_PublishingPageHeader);
targetPage.SetCustomPageHeader(newHeaderImageServerRelativeUrl);
headerCreated = true;
}
}
if (!headerCreated)
{
// let's fall back to the default header
targetPage.SetDefaultPageHeader();
}
// Header type handling
switch (publishingPageTransformationModel.Header.Type)
{
case HeaderType.ColorBlock: targetPage.PageHeader.LayoutType = PnPCore.PageHeaderLayoutType.ColorBlock; break;
case HeaderType.CutInShape: targetPage.PageHeader.LayoutType = PnPCore.PageHeaderLayoutType.CutInShape; break;
case HeaderType.NoImage: targetPage.PageHeader.LayoutType = PnPCore.PageHeaderLayoutType.NoImage; break;
case HeaderType.FullWidthImage: targetPage.PageHeader.LayoutType = PnPCore.PageHeaderLayoutType.FullWidthImage; break;
}
// Alignment handling
switch (publishingPageTransformationModel.Header.Alignment)
{
case HeaderAlignment.Left: targetPage.PageHeader.TextAlignment = PnPCore.PageHeaderTitleAlignment.Left; break;
case HeaderAlignment.Center: targetPage.PageHeader.TextAlignment = PnPCore.PageHeaderTitleAlignment.Center; break;
}
// Show published date
targetPage.PageHeader.ShowPublishDate = publishingPageTransformationModel.Header.ShowPublishedDate;
// Topic header handling
HeaderField topicHeaderField = GetHeaderField(publishingPageTransformationModel, HeaderFieldHeaderProperty.TopicHeader);
if (topicHeaderField != null)
{
if (publishingPageTransformationInformation.SourcePage.FieldExistsAndUsed(topicHeaderField.Name))
{
targetPage.PageHeader.TopicHeader = publishingPageTransformationInformation.SourcePage[topicHeaderField.Name].ToString();
targetPage.PageHeader.ShowTopicHeader = true;
}
}
// AlternativeText handling
HeaderField alternativeTextHeaderField = GetHeaderField(publishingPageTransformationModel, HeaderFieldHeaderProperty.AlternativeText);
if (alternativeTextHeaderField != null)
{
var alternativeTextHeader = GetFieldValue(alternativeTextHeaderField);
if (!string.IsNullOrEmpty(alternativeTextHeader))
{
targetPage.PageHeader.AlternativeText = alternativeTextHeader;
}
}
// Authors handling
HeaderField authorsHeaderField = GetHeaderField(publishingPageTransformationModel, HeaderFieldHeaderProperty.Authors);
if (authorsHeaderField != null)
{
var authorsHeader = GetFieldValue(authorsHeaderField, PublishingFunctionProcessor.FieldType.User);
if (!string.IsNullOrEmpty(authorsHeader))
{
targetPage.PageHeader.Authors = authorsHeader;
}
}
}
}
