public object Resolve(object source, Dictionary <String, IResolver> resolvers = null, Boolean recursive = false)
{
var result = new List <Model.Folder>();
var folders = source.GetPublicInstancePropertyValue("Folders");
if (null == folders)
{
folders = source.GetPublicInstancePropertyValue("Folder1");
}
resolvers = new Dictionary <string, IResolver>();
resolvers.Add($"{typeof(Model.Folder).FullName}.Folders", new FoldersFromSchemaToModelTypeResolver());
resolvers.Add($"{typeof(Model.Folder).FullName}.Security", new SecurityFromSchemaToModelTypeResolver());
// DefaultColumnValues
var defaultColumnValueTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.StringDictionaryItem, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var defaultColumnValueType = Type.GetType(defaultColumnValueTypeName, true);
var defaultColumnValueKeySelector = CreateSelectorLambda(defaultColumnValueType, "Key");
var defaultColumnValueValueSelector = CreateSelectorLambda(defaultColumnValueType, "Value");
resolvers.Add($"{typeof(Model.Folder).FullName}.DefaultColumnValues", new FromArrayToDictionaryValueResolver <string, string>(defaultColumnValueType, defaultColumnValueKeySelector, defaultColumnValueValueSelector));
if (null != folders)
{
foreach (var f in ((IEnumerable)folders))
{
var targetItem = new Model.Folder();
PnPObjectsMapper.MapProperties(f, targetItem, resolvers, recursive);
result.Add(targetItem);
}
}
return(result);
}
public override void Serialize(ProvisioningTemplate template, object persistence)
{
if (template.ApplicationLifecycleManagement != null &&
(template.ApplicationLifecycleManagement.AppCatalog != null ||
(template.ApplicationLifecycleManagement.Apps != null &&
template.ApplicationLifecycleManagement.Apps.Count > 0)))
{
var almTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.ApplicationLifecycleManagement, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var almType = Type.GetType(almTypeName, false);
if (almType != null)
{
var target = Activator.CreateInstance(almType, true);
var resolvers = new Dictionary <String, IResolver>
{
{
$"{almType}.AppCatalog",
new AppCatalogFromModelToSchemaTypeResolver()
}
};
PnPObjectsMapper.MapProperties(template.ApplicationLifecycleManagement, target,
resolvers, recursive: true);
if (target != null &&
(target.GetPublicInstancePropertyValue("AppCatalog") != null ||
target.GetPublicInstancePropertyValue("Apps") != null))
{
persistence.GetPublicInstanceProperty("ApplicationLifecycleManagement")
.SetValue(persistence, target);
}
}
}
}
public override void Deserialize(object persistence, ProvisioningTemplate template)
{
var workflows = persistence.GetPublicInstancePropertyValue("Workflows");
if (workflows != null)
{
template.Workflows = new Workflows();
var expressions = new Dictionary <Expression <Func <Workflows, Object> >, IResolver>
{
{ w => w.WorkflowDefinitions[0].Id, new FromStringToGuidValueResolver() },
{ w => w.WorkflowDefinitions[0].FormField, new ExpressionValueResolver((s, v) => v != null ? ((XmlElement)v).OuterXml : null) },
{ w => w.WorkflowSubscriptions[0].DefinitionId, new FromStringToGuidValueResolver() }
};
var dictionaryItemType = Type.GetType($"{PnPSerializationScope.Current?.BaseSchemaNamespace}.StringDictionaryItem, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}", true);
var dictionaryItemKeySelector = CreateSelectorLambda(dictionaryItemType, "Key");
var dictionaryItemValueSelector = CreateSelectorLambda(dictionaryItemType, "Value");
expressions.Add(w => w.WorkflowDefinitions[0].Properties, new FromArrayToDictionaryValueResolver <string, string>(dictionaryItemType, dictionaryItemKeySelector, dictionaryItemValueSelector));
expressions.Add(w => w.WorkflowSubscriptions[0].EventTypes, new ExpressionValueResolver((s, v) =>
{
return((new string[] {
(bool)s.GetPublicInstancePropertyValue("ItemAddedEvent") ? "ItemAdded" : null,
(bool)s.GetPublicInstancePropertyValue("ItemUpdatedEvent") ? "ItemUpdated" : null,
(bool)s.GetPublicInstancePropertyValue("WorkflowStartEvent") ? "WorkflowStart" : null
}).Where(e => e != null).ToList());
}));
expressions.Add(w => w.WorkflowSubscriptions[0].PropertyDefinitions, new FromArrayToDictionaryValueResolver <string, string>(dictionaryItemType, dictionaryItemKeySelector, dictionaryItemValueSelector));
PnPObjectsMapper.MapProperties(workflows, template.Workflows, expressions, true);
}
}
public override void Deserialize(object persistence, ProvisioningTemplate template)
{
var clientSidePages = persistence.GetPublicInstancePropertyValue("ClientSidePages");
if (clientSidePages != null)
{
var expressions = new Dictionary <Expression <Func <ClientSidePage, Object> >, IResolver>();
// Manage CanvasControlProperties for CanvasControl
var stringDictionaryTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.StringDictionaryItem, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var stringDictionaryType = Type.GetType(stringDictionaryTypeName, true);
var stringDictionaryKeySelector = CreateSelectorLambda(stringDictionaryType, "Key");
var stringDictionaryValueSelector = CreateSelectorLambda(stringDictionaryType, "Value");
expressions.Add(cp => cp.Sections[0].Controls[0].ControlProperties,
new FromArrayToDictionaryValueResolver <String, String>(
stringDictionaryType, stringDictionaryKeySelector, stringDictionaryValueSelector));
// Manage WebPartType for CanvasControl
expressions.Add(cp => cp.Sections[0].Controls[0].Type,
new ExpressionValueResolver(
(s, p) => (Model.WebPartType)Enum.Parse(typeof(Model.WebPartType), s.GetPublicInstancePropertyValue("WebPartType").ToString())
));
// Manage ControlId for CanvasControl
expressions.Add(cp => cp.Sections[0].Controls[0].ControlId,
new FromStringToGuidValueResolver());
template.ClientSidePages.AddRange(
PnPObjectsMapper.MapObjects(clientSidePages,
new CollectionFromSchemaToModelTypeResolver(typeof(ClientSidePage)),
expressions,
recursive: true)
as IEnumerable <ClientSidePage>);
}
}
public override void Serialize(ProvisioningTemplate template, object persistence)
{
var customActionsTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.CustomActions, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var customActionsType = Type.GetType(customActionsTypeName, true);
var customActionTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.CustomAction, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var customActionType = Type.GetType(customActionTypeName, true);
var registrationTypeTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.RegistrationType";
var registrationTypeType = Type.GetType(registrationTypeTypeName, true);
var commandUIExtensionTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.CustomActionCommandUIExtension";
var commandUIExtensionType = Type.GetType(commandUIExtensionTypeName, true);
var target = Activator.CreateInstance(customActionsType, true);
var expressions = new Dictionary <string, IResolver>();
expressions.Add($"{customActionType}.Rights", new FromBasePermissionsToStringValueResolver());
expressions.Add($"{customActionType}.RegistrationType", new FromStringToEnumValueResolver(registrationTypeType));
expressions.Add($"{customActionType}.RegistrationTypeSpecified", new ExpressionValueResolver(() => true));
expressions.Add($"{customActionType}.SequenceSpecified", new ExpressionValueResolver(() => true));
expressions.Add($"{customActionType}.CommandUIExtension", new XmlAnyFromModeToSchemalValueResolver(commandUIExtensionType));
PnPObjectsMapper.MapProperties(template.CustomActions, target, expressions, recursive: true);
persistence.GetPublicInstanceProperty("CustomActions").SetValue(persistence, target);
}
public override void Serialize(ProvisioningTemplate template, object persistence)
{
if (template.Security != null)
{
var securityTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.Security, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var securityType = Type.GetType(securityTypeName, true);
var expressions = new Dictionary <string, IResolver>
{
{ $"{securityType}.BreakRoleInheritanceSpecified", new ExpressionValueResolver(() => true) },
{ $"{securityType}.ResetRoleInheritanceSpecified", new ExpressionValueResolver(() => true) },
{ $"{securityType}.CopyRoleAssignmentsSpecified", new ExpressionValueResolver(() => true) },
{ $"{securityType}.RemoveExistingUniqueRoleAssignmentsSpecified", new ExpressionValueResolver(() => true) },
{ $"{securityType}.ClearSubscopesSpecified", new ExpressionValueResolver(() => true) }
};
var securityPermissionsType = Type.GetType($"{PnPSerializationScope.Current?.BaseSchemaNamespace}.SecurityPermissions, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}");
var roleDefinitionType = Type.GetType($"{PnPSerializationScope.Current?.BaseSchemaNamespace}.RoleDefinition, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}");
var roleDefinitionPermissionType = Type.GetType($"{PnPSerializationScope.Current?.BaseSchemaNamespace}.RoleDefinitionPermission, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}");
var siteGroupType = Type.GetType($"{PnPSerializationScope.Current?.BaseSchemaNamespace}.SiteGroup, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}");
var target = Activator.CreateInstance(securityType, true);
expressions.Add($"{securityType}.Permissions", new PropertyObjectTypeResolver(securityPermissionsType, "SiteSecurityPermissions"));
expressions.Add($"{roleDefinitionType}.Permissions", new ExpressionCollectionValueResolver((i) => Enum.Parse(roleDefinitionPermissionType, i.ToString()), roleDefinitionPermissionType));
expressions.Add($"{siteGroupType}.AllowMembersEditMembershipSpecified", new ExpressionValueResolver(() => true));
expressions.Add($"{siteGroupType}.AllowRequestToJoinLeaveSpecified", new ExpressionValueResolver(() => true));
expressions.Add($"{siteGroupType}.AutoAcceptRequestToJoinLeaveSpecified", new ExpressionValueResolver(() => true));
expressions.Add($"{siteGroupType}.OnlyAllowMembersViewMembershipSpecified", new ExpressionValueResolver(() => true));
expressions.Add($"{securityType}.AdditionalAdministrators",
new TemplateSecurityUsersFromModelToSchemaTypeResolver("AdditionalAdministrators", "ClearExistingAdministrators"));
expressions.Add($"{securityType}.AdditionalOwners",
new TemplateSecurityUsersFromModelToSchemaTypeResolver("AdditionalOwners", "ClearExistingOwners"));
expressions.Add($"{securityType}.AdditionalMembers",
new TemplateSecurityUsersFromModelToSchemaTypeResolver("AdditionalMembers", "ClearExistingMembers"));
expressions.Add($"{securityType}.AdditionalVisitors",
new TemplateSecurityUsersFromModelToSchemaTypeResolver("AdditionalVisitors", "ClearExistingVisitors"));
expressions.Add($"{siteGroupType}.Members",
new TemplateSecurityUsersFromModelToSchemaTypeResolver("Members", "ClearExistingMembers"));
PnPObjectsMapper.MapProperties(template.Security, target, expressions, recursive: true);
if (target != null &&
(target.GetPublicInstancePropertyValue("AdditionalAdministrators") != null ||
target.GetPublicInstancePropertyValue("AdditionalMembers") != null ||
target.GetPublicInstancePropertyValue("AdditionalOwners") != null ||
target.GetPublicInstancePropertyValue("AdditionalVisitors") != null ||
target.GetPublicInstancePropertyValue("SiteGroups") != null ||
(target.GetPublicInstancePropertyValue("Permissions") != null &&
(
target.GetPublicInstancePropertyValue("Permissions").GetPublicInstancePropertyValue("RoleDefinitions") != null && (((Array)target.GetPublicInstancePropertyValue("Permissions").GetPublicInstancePropertyValue("RoleDefinitions")).Length > 0) ||
target.GetPublicInstancePropertyValue("Permissions").GetPublicInstancePropertyValue("RoleAssignments") != null && (((Array)target.GetPublicInstancePropertyValue("Permissions").GetPublicInstancePropertyValue("RoleAssignments")).Length > 0)
))))
{
persistence.GetPublicInstanceProperty("Security").SetValue(persistence, target);
}
}
}
public override void Serialize(ProvisioningTemplate template, object persistence)
{
if (template.CustomActions != null && (template.CustomActions.WebCustomActions.Count > 0 || template.CustomActions.SiteCustomActions.Count > 0))
{
var customActionsTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.CustomActions, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var customActionsType = Type.GetType(customActionsTypeName, true);
var customActionTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.CustomAction, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var customActionType = Type.GetType(customActionTypeName, true);
var registrationTypeTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.RegistrationType";
var registrationTypeType = Type.GetType(registrationTypeTypeName, true);
var commandUIExtensionTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.CustomActionCommandUIExtension";
var commandUIExtensionType = Type.GetType(commandUIExtensionTypeName, true);
var target = Activator.CreateInstance(customActionsType, true);
var expressions = new Dictionary <string, IResolver>
{
{ $"{customActionType}.Rights", new FromBasePermissionsToStringValueResolver() },
{ $"{customActionType}.RegistrationType", new FromStringToEnumValueResolver(registrationTypeType) },
{ $"{customActionType}.RegistrationTypeSpecified", new ExpressionValueResolver(() => true) },
{ $"{customActionType}.SequenceSpecified", new ExpressionValueResolver(() => true) },
{ $"{customActionType}.CommandUIExtension", new XmlAnyFromModelToSchemalValueResolver(commandUIExtensionType) },
{ $"{customActionType}.ClientSideComponentId", new ExpressionValueResolver((s, v) => v != null ? v.ToString() : s?.ToString()) }
};
PnPObjectsMapper.MapProperties(template.CustomActions, target, expressions, recursive: true);
if (target != null &&
((target.GetPublicInstancePropertyValue("SiteCustomActions") != null && ((Array)target.GetPublicInstancePropertyValue("SiteCustomActions")).Length > 0) ||
(target.GetPublicInstancePropertyValue("WebCustomActions") != null && ((Array)target.GetPublicInstancePropertyValue("WebCustomActions")).Length > 0)))
{
persistence.GetPublicInstanceProperty("CustomActions").SetValue(persistence, target);
}
}
}
public object Resolve(object source, Dictionary <String, IResolver> resolvers = null, Boolean recursive = false)
{
Object result = null;
// Try with the tenant-wide AppCatalog
BaseClientSidePage page;
if (source is ClientSidePage)
{
page = source as ClientSidePage;
}
else
{
page = source as TranslatedClientSidePage;
}
//var page = source as Model.ClientSidePage;
var header = page?.Header;
if (null != header)
{
var headerTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.BaseClientSidePageHeader, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var headerType = Type.GetType(headerTypeName, true);
result = Activator.CreateInstance(headerType);
PnPObjectsMapper.MapProperties(header, result, resolvers, recursive);
}
return(result);
}
public override void Deserialize(object persistence, ProvisioningTemplate template)
{
var handlers = persistence.GetPublicInstancePropertyValue("Providers");
if (handlers != null)
{
var expressions = new Dictionary <Expression <Func <ExtensibilityHandler, Object> >, IResolver>();
expressions.Add(h => h.Configuration, new ExpressionValueResolver((s, v) => (v as XmlElement)?.ToProviderConfiguration()));
expressions.Add(h => h.Type, new ExpressionValueResolver <ExtensibilityHandler>((s, v, d) =>
{
string res = null;
var typeName = s.GetPublicInstancePropertyValue("HandlerType");
if (typeName != null)
{
var type = Type.GetType(typeName.ToString(), false);
if (type != null)
{
d.Assembly = type.Assembly.FullName;
res = type.FullName;
}
}
return(res);
}));
var result = PnPObjectsMapper.MapObjects <ExtensibilityHandler>(handlers,
new CollectionFromSchemaToModelTypeResolver(typeof(ExtensibilityHandler)),
expressions,
recursive: true)
as IEnumerable <ExtensibilityHandler>;
template.ExtensibilityHandlers.AddRange(result.Where(h => !string.IsNullOrEmpty(h.Type)));
}
}
public override void Deserialize(object persistence, ProvisioningTemplate template)
{
var aad = persistence.GetPublicInstancePropertyValue("AzureActiveDirectory");
if (aad != null)
{
var expressions = new Dictionary <Expression <Func <ProvisioningAzureActiveDirectory, Object> >, IResolver>
{
// Manage the Users and their Password Profile
{ a => a.Users, new AADUsersFromSchemaToModelTypeResolver() },
{ a => a.Users[0].PasswordProfile, new AADUsersPasswordProfileFromSchemaToModelTypeResolver() },
{
a => a.Users[0].PasswordProfile.Password,
new ExpressionValueResolver((s, p) => EncryptionUtility.ToSecureString((String)p))
},
// Manage licenses for users
{
a => a.Users[0].Licenses[0].DisabledPlans,
new ExpressionValueResolver((s, p) => s.GetPublicInstancePropertyValue("DisabledPlans"))
}
};
PnPObjectsMapper.MapProperties(aad, template.ParentHierarchy.AzureActiveDirectory, expressions, recursive: true);
}
}
public override void Serialize(ProvisioningTemplate template, object persistence)
{
if (template.Security != null)
{
var securityTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.Security, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var securityType = Type.GetType(securityTypeName, true);
var securityPermissionsType = Type.GetType($"{PnPSerializationScope.Current?.BaseSchemaNamespace}.SecurityPermissions, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}");
var roleDefinitionType = Type.GetType($"{PnPSerializationScope.Current?.BaseSchemaNamespace}.RoleDefinition, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}");
var roleDefinitionPermissionType = Type.GetType($"{PnPSerializationScope.Current?.BaseSchemaNamespace}.RoleDefinitionPermission, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}");
var siteGroupType = Type.GetType($"{PnPSerializationScope.Current?.BaseSchemaNamespace}.SiteGroup, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}");
var target = Activator.CreateInstance(securityType, true);
var expressions = new Dictionary <string, IResolver>();
expressions.Add($"{securityType}.Permissions", new PropertyObjectTypeResolver(securityPermissionsType, "SiteSecurityPermissions"));
expressions.Add($"{roleDefinitionType}.Permissions", new ExpressionCollectionValueResolver((i) => Enum.Parse(roleDefinitionPermissionType, i.ToString()), roleDefinitionPermissionType));
expressions.Add($"{siteGroupType}.AllowMembersEditMembershipSpecified", new ExpressionValueResolver(() => true));
expressions.Add($"{siteGroupType}.AllowRequestToJoinLeaveSpecified", new ExpressionValueResolver(() => true));
expressions.Add($"{siteGroupType}.AutoAcceptRequestToJoinLeaveSpecified", new ExpressionValueResolver(() => true));
expressions.Add($"{siteGroupType}.OnlyAllowMembersViewMembershipSpecified", new ExpressionValueResolver(() => true));
PnPObjectsMapper.MapProperties(template.Security, target, expressions, recursive: true);
persistence.GetPublicInstanceProperty("Security").SetValue(persistence, target);
}
}
public override void Deserialize(object persistence, ProvisioningTemplate template)
{
var filesCollection = persistence.GetPublicInstancePropertyValue("Files");
if (filesCollection != null)
{
var files = filesCollection.GetPublicInstancePropertyValue("File");
var expressions = new Dictionary <Expression <Func <File, Object> >, IResolver>
{
{ c => c.Level, new FromStringToEnumValueResolver(typeof(FileLevel)) }
};
var dictionaryItemTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.StringDictionaryItem, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var dictionaryItemType = Type.GetType(dictionaryItemTypeName, true);
var dictionaryItemKeySelector = CreateSelectorLambda(dictionaryItemType, "Key");
var dictionaryItemValueSelector = CreateSelectorLambda(dictionaryItemType, "Value");
expressions.Add(f => f.Properties, new FromArrayToDictionaryValueResolver <string, string>(dictionaryItemType, dictionaryItemKeySelector, dictionaryItemValueSelector));
expressions.Add(f => f.Security, new PropertyObjectTypeResolver <File>(fl => fl.Security,
fl => fl.GetPublicInstancePropertyValue("Security")?.GetPublicInstancePropertyValue("BreakRoleInheritance")));
expressions.Add(f => f.Security.RoleAssignments, new RoleAssigmentsFromSchemaToModelTypeResolver());
expressions.Add(f => f.WebParts[0].Order, new ExpressionValueResolver <int>((v) => (uint)v));
expressions.Add(f => f.WebParts[0].Contents, new ExpressionValueResolver((s, v) => v != null ? ((XmlElement)v).OuterXml : null));
template.Files.AddRange(
PnPObjectsMapper.MapObjects <File>(files,
new CollectionFromSchemaToModelTypeResolver(typeof(File)),
expressions,
recursive: true)
as IEnumerable <File>);
}
}
public override void Serialize(ProvisioningTemplate template, object persistence)
{
var baseNamespace = PnPSerializationScope.Current?.BaseSchemaNamespace;
var contentTypeTypeName = $"{baseNamespace}.ContentType, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var contentTypeType = Type.GetType(contentTypeTypeName, true);
var documentSetTemplateTypeName = $"{baseNamespace}.DocumentSetTemplate, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var documentSetTemplateType = Type.GetType(documentSetTemplateTypeName, true);
var documentTemplateTypeName = $"{baseNamespace}.ContentTypeDocumentTemplate, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var documentTemplateType = Type.GetType(documentTemplateTypeName, true);
var expressions = new Dictionary <string, IResolver>();
//document set template
expressions.Add($"{contentTypeType.FullName}.DocumentSetTemplate", new PropertyObjectTypeResolver(documentSetTemplateType, "DocumentSetTemplate"));
//document set template - allowed content types
expressions.Add($"{contentTypeType.Namespace}.DocumentSetTemplate.AllowedContentTypes",
new DocumentSetTemplateAllowedContentTypesFromModelToSchemaTypeResolver());
//document set template - shared fields and welcome page fields (this expression also used to resolve fieldref collection ids because of same type name)
expressions.Add($"{contentTypeType.Namespace}.FieldRefBase.ID", new ExpressionValueResolver((s, v) => v != null ? v.ToString() : s?.ToString()));
//document template
expressions.Add($"{contentTypeType.FullName}.DocumentTemplate", new DocumentTemplateFromModelToSchemaTypeResolver(documentTemplateType));
persistence.GetPublicInstanceProperty("ContentTypes")
.SetValue(
persistence,
PnPObjectsMapper.MapObjects(template.ContentTypes,
new CollectionFromModelToSchemaTypeResolver(contentTypeType), expressions, true));
}
public override void Deserialize(object persistence, ProvisioningTemplate template)
{
var contentTypes = persistence.GetPublicInstancePropertyValue("ContentTypes");
if (contentTypes != null)
{
var expressions = new Dictionary <Expression <Func <ContentType, Object> >, IResolver>();
// Define custom resolver for FieldRef.ID because needs conversion from String to GUID
expressions.Add(c => c.FieldRefs[0].Id, new FromStringToGuidValueResolver());
//document template
expressions.Add(c => c.DocumentTemplate, new ExpressionValueResolver((s, v) => v.GetPublicInstancePropertyValue("TargetName")));
//document set template
expressions.Add(c => c.DocumentSetTemplate, new PropertyObjectTypeResolver <ContentType>(ct => ct.DocumentSetTemplate));
//document set template - allowed content types
expressions.Add(c => c.DocumentSetTemplate.AllowedContentTypes,
new DocumentSetTemplateAllowedContentTypesFromSchemaToModelTypeResolver());
//document set template - remove existing content types
expressions.Add(c => c.DocumentSetTemplate.RemoveExistingContentTypes,
new RemoveExistingContentTypesFromSchemaToModelValueResolver());
//document set template - shared fields
expressions.Add(c => c.DocumentSetTemplate.SharedFields, new ExpressionCollectionValueResolver <Guid>((s) => Guid.Parse(s.GetPublicInstancePropertyValue("ID").ToString())));
//document set template - welcome page fields
expressions.Add(c => c.DocumentSetTemplate.WelcomePageFields, new ExpressionCollectionValueResolver <Guid>((s) => Guid.Parse(s.GetPublicInstancePropertyValue("ID").ToString())));
template.ContentTypes.AddRange(
PnPObjectsMapper.MapObjects <ContentType>(contentTypes,
new CollectionFromSchemaToModelTypeResolver(typeof(ContentType)),
expressions,
recursive: true)
as IEnumerable <ContentType>);
}
}
public object Resolve(object source, Dictionary <string, IResolver> resolvers = null, bool recursive = false)
{
var result = new List <Model.SiteFooterLink>();
var links = source.GetPublicInstancePropertyValue("FooterLinks");
if (null == links)
{
links = source.GetPublicInstancePropertyValue("FooterLink1");
}
resolvers = new Dictionary <string, IResolver>();
resolvers.Add($"{typeof(Model.SiteFooterLink).FullName}.FooterLinks", new SiteFooterLinkFromSchemaToModelTypeResolver());
if (null != links)
{
foreach (var f in ((IEnumerable)links))
{
var targetItem = new Model.SiteFooterLink();
PnPObjectsMapper.MapProperties(f, targetItem, resolvers, recursive);
result.Add(targetItem);
}
}
return(result);
}
public override void Deserialize(object persistence, ProvisioningTemplate template)
{
var pages = persistence.GetPublicInstancePropertyValue("Pages");
if (pages != null)
{
var expressions = new Dictionary <Expression <Func <Page, Object> >, IResolver>();
expressions.Add(p => p.Layout, new FromStringToEnumValueResolver(typeof(WikiPageLayout)));
var dictionaryItemTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.BaseFieldValue, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var dictionaryItemType = Type.GetType(dictionaryItemTypeName, true);
var dictionaryItemKeySelector = CreateSelectorLambda(dictionaryItemType, "FieldName");
var dictionaryItemValueSelector = CreateSelectorLambda(dictionaryItemType, "Value");
expressions.Add(f => f.Fields, new FromArrayToDictionaryValueResolver <string, string>(dictionaryItemType, dictionaryItemKeySelector, dictionaryItemValueSelector));
expressions.Add(f => f.Security, new PropertyObjectTypeResolver <File>(fl => fl.Security,
fl => fl.GetPublicInstancePropertyValue("Security")?.GetPublicInstancePropertyValue("BreakRoleInheritance")));
expressions.Add(f => f.Security.RoleAssignments, new RoleAssigmentsFromSchemaToModelTypeResolver());
expressions.Add(f => f.WebParts[0].Row, new ExpressionValueResolver((s, v) => (uint)(int)v));
expressions.Add(f => f.WebParts[0].Column, new ExpressionValueResolver((s, v) => (uint)(int)v));
expressions.Add(f => f.WebParts[0].Contents, new ExpressionValueResolver((s, v) => v != null ? XElement.Parse(((XmlElement)v).InnerXml)?.Element("webPart")?.ToString() : null));
template.Pages.AddRange(
PnPObjectsMapper.MapObjects <Page>(pages,
new CollectionFromSchemaToModelTypeResolver(typeof(Page)),
expressions,
recursive: true)
as IEnumerable <Page>);
}
}
public override void Serialize(ProvisioningTemplate template, object persistence)
{
if (template.ParentHierarchy?.Drive?.DriveRoots != null)
{
var driveRootTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.DriveRoot, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var driveRootType = Type.GetType(driveRootTypeName, false);
var driveFolderTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.DriveFolder, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var driveFolderType = Type.GetType(driveFolderTypeName, false);
if (driveRootType != null)
{
var resolvers = new Dictionary <String, IResolver>();
//// Handle DriveRoot objects
//resolvers.Add($"{PnPSerializationScope.Current?.BaseSchemaNamespace}.DriveRoot",
// new DriveRootFolderFromModelToSchemaTypeResolver());
resolvers.Add($"{driveRootType}.DriveItems",
new DriveItemsFromModelToSchemaTypeResolver()); // DriveRootsFromModelToSchemaTypeResolver());
resolvers.Add($"{driveFolderType}.Items",
new DriveItemsFromModelToSchemaTypeResolver());
persistence.GetPublicInstanceProperty("Drive")
.SetValue(
persistence,
PnPObjectsMapper.MapObjects(template.ParentHierarchy?.Drive?.DriveRoots,
new CollectionFromModelToSchemaTypeResolver(driveRootType),
resolvers,
recursive: true));
}
}
}
public object Resolve(object source, Dictionary <String, IResolver> resolvers = null, Boolean recursive = false)
{
Object result = null;
var tenant = source as Model.ProvisioningTenant;
var cdn = tenant?.ContentDeliveryNetwork;
if (null != cdn)
{
var cdnTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.ContentDeliveryNetwork, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var cdnType = Type.GetType(cdnTypeName, true);
var cdnSettingsTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.CdnSetting, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var cdnSettingsType = Type.GetType(cdnSettingsTypeName, true);
result = Activator.CreateInstance(cdnType);
if (cdn.PublicCdn != null)
{
Object publicCdn = Activator.CreateInstance(cdnSettingsType);
PnPObjectsMapper.MapProperties(cdn.PublicCdn, publicCdn, null, true);
result.SetPublicInstancePropertyValue("Public", publicCdn);
}
if (cdn.PrivateCdn != null)
{
Object privateCdn = Activator.CreateInstance(cdnSettingsType);
PnPObjectsMapper.MapProperties(cdn.PrivateCdn, privateCdn, null, true);
result.SetPublicInstancePropertyValue("Private", privateCdn);
}
}
return(result);
}
public object Resolve(object source, Dictionary <string, IResolver> resolvers = null, bool recursive = false)
{
Object result = null;
// Declare supporting types
var sharingSettingsTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.SharingSettings, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var sharingSettingsType = Type.GetType(sharingSettingsTypeName, true);
var settings = ((Model.ProvisioningTenant)source).SharingSettings;
if (null != settings)
{
result = Activator.CreateInstance(sharingSettingsType);
PnPObjectsMapper.MapProperties(settings, result, resolvers, recursive);
if (settings.AllowedDomainList.Count > 0)
{
var allowedDomainList = settings.AllowedDomainList.Aggregate(string.Empty, (acc, next) => acc += $",{next}");
allowedDomainList = allowedDomainList.Substring(1, allowedDomainList.Length - 1);
result.SetPublicInstancePropertyValue("AllowedDomainList", allowedDomainList);
}
if (settings.BlockedDomainList.Count > 0)
{
var blockedDomainList = settings.BlockedDomainList.Aggregate(string.Empty, (acc, next) => acc += $",{next}");
blockedDomainList = blockedDomainList.Substring(1, blockedDomainList.Length - 1);
result.SetPublicInstancePropertyValue("BlockedDomainList", blockedDomainList);
}
}
return(result);
}
public override void Deserialize(object persistence, ProvisioningTemplate template)
{
var tenantSettings = persistence.GetPublicInstancePropertyValue("Tenant");
if (tenantSettings != null)
{
var expressions = new Dictionary <Expression <Func <ProvisioningTenant, Object> >, IResolver>
{
// Manage the AppCatalog
{ t => t.AppCatalog, new AppCatalogFromSchemaToModelTypeResolver() },
// Manage the CDN
{ t => t.ContentDeliveryNetwork, new CdnFromSchemaToModelTypeResolver() },
// Manage the Site Designs mapping with Site Scripts
{ t => t.SiteDesigns[0].SiteScripts, new SiteScriptRefFromSchemaToModelTypeResolver() },
// Manage Palette of Theme
{
t => t.Themes[0].Palette,
new ExpressionValueResolver((s, v) =>
{
String result = null;
if (s != null)
{
String[] text = s.GetPublicInstancePropertyValue("Text") as String[];
if (text != null && text.Length > 0)
{
result = text.Aggregate(String.Empty, (acc, next) => acc += (next != null ? next : String.Empty));
}
}
return(result.Trim());
})
}
};
// Define the dynamic type for the SP User Profile Properties
var propertiesTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.StringDictionaryItem, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var propertiesType = Type.GetType(propertiesTypeName, true);
var propertiesKeySelector = CreateSelectorLambda(propertiesType, "Key");
var propertiesValueSelector = CreateSelectorLambda(propertiesType, "Value");
// Manage SP User Profile Properties
expressions.Add(t => t.SPUsersProfiles[0].Properties,
new FromArrayToDictionaryValueResolver <String, String>(
propertiesType, propertiesKeySelector, propertiesValueSelector));
// Manage Office 365 Groups Settings
expressions.Add(t => t.Office365GroupsSettings,
new Office365GroupsSettingsFromSchemaToModel());
// Manage Sharing Settings
expressions.Add(t => t.SharingSettings,
new SharingSettingsFromSchemaToModel());
PnPObjectsMapper.MapProperties(tenantSettings, template.Tenant, expressions, true);
}
}
public object Resolve(object source, Dictionary <String, IResolver> resolvers = null, Boolean recursive = false)
{
object result = null;
if (null != source)
{
var sourceList = (IList)source;
if (sourceList.Count > 0)
{
var resultArray = Array.CreateInstance(this._targetItemType, sourceList.Count);
var index = 0;
foreach (var i in sourceList)
{
var targetItem = Activator.CreateInstance(this._targetItemType, true);
PnPObjectsMapper.MapProperties(i, targetItem, resolvers, recursive);
resultArray.SetValue(targetItem, index);
index++;
}
result = resultArray;
}
}
return(result);
}
public override void Deserialize(object persistence, ProvisioningTemplate template)
{
var groups = persistence.GetPublicInstancePropertyValue("TermGroups");
if (groups != null)
{
var expressions = new Dictionary <Expression <Func <TermGroup, Object> >, IResolver>();
expressions.Add(g => g.Id, new FromStringToGuidValueResolver());
expressions.Add(g => g.TermSets[0].Id, new FromStringToGuidValueResolver());
expressions.Add(g => g.TermSets[0].Terms[0].Id, new FromStringToGuidValueResolver());
expressions.Add(g => g.TermSets[0].Terms[0].SourceTermId, new FromStringToGuidValueResolver());
var dictionaryItemTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.StringDictionaryItem, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var dictionaryItemType = Type.GetType(dictionaryItemTypeName, true);
var dictionaryItemKeySelector = CreateSelectorLambda(dictionaryItemType, "Key");
var dictionaryItemValueSelector = CreateSelectorLambda(dictionaryItemType, "Value");
expressions.Add(g => g.TermSets[0].Properties, new FromArrayToDictionaryValueResolver <string, string>(dictionaryItemType, dictionaryItemKeySelector, dictionaryItemValueSelector));
expressions.Add(g => g.TermSets[0].Terms[0].LocalProperties, new FromArrayToDictionaryValueResolver <string, string>(dictionaryItemType, dictionaryItemKeySelector, dictionaryItemValueSelector, "LocalCustomProperties"));
expressions.Add(g => g.TermSets[0].Terms[0].Properties, new FromArrayToDictionaryValueResolver <string, string>(dictionaryItemType, dictionaryItemKeySelector, dictionaryItemValueSelector, "CustomProperties"));
expressions.Add(g => g.TermSets[0].Terms[0].Terms,
new PropertyObjectTypeResolver <Term>(t => t.Terms,
v => v.GetPublicInstancePropertyValue("Terms")?.GetPublicInstancePropertyValue("Items"),
new CollectionFromSchemaToModelTypeResolver(typeof(Term))));
template.TermGroups.AddRange(
PnPObjectsMapper.MapObjects <TermGroup>(groups,
new CollectionFromSchemaToModelTypeResolver(typeof(TermGroup)),
expressions,
recursive: true)
as IEnumerable <TermGroup>);
}
}
public object Resolve(object source, Dictionary <string, IResolver> resolvers = null, bool recursive = false)
{
var settings = source.GetPublicInstancePropertyValue("SharingSettings");
if (null != settings)
{
Model.SharingSettings result = new Model.SharingSettings();
PnPObjectsMapper.MapProperties(settings, result, resolvers, recursive);
var allowedDomainList = (String)settings.GetPublicInstancePropertyValue("AllowedDomainList");
if (!String.IsNullOrEmpty(allowedDomainList))
{
result.AllowedDomainList.AddRange(allowedDomainList.Split(','));
}
var blockedDomainList = (String)settings.GetPublicInstancePropertyValue("BlockedDomainList");
if (!String.IsNullOrEmpty(blockedDomainList))
{
result.BlockedDomainList.AddRange(blockedDomainList.Split(','));
}
return(result);
}
return(null);
}
public override void Serialize(ProvisioningTemplate template, object persistence)
{
if (template.Tenant != null &&
(template.Tenant.AppCatalog != null || template.Tenant.ContentDeliveryNetwork != null))
{
var tenantTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.Tenant, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var tenantType = Type.GetType(tenantTypeName, false);
var siteDesignsTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.SiteDesignsSiteDesign, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var siteDesignsType = Type.GetType(siteDesignsTypeName, false);
if (tenantType != null)
{
var target = Activator.CreateInstance(tenantType, true);
var resolvers = new Dictionary <String, IResolver>();
resolvers.Add($"{tenantType}.AppCatalog",
new AppCatalogFromModelToSchemaTypeResolver());
resolvers.Add($"{tenantType}.ContentDeliveryNetwork",
new CdnFromModelToSchemaTypeResolver());
resolvers.Add($"{siteDesignsType}.SiteScripts",
new SiteScriptRefFromModelToSchemaTypeResolver());
PnPObjectsMapper.MapProperties(template.Tenant, target, resolvers, recursive: true);
if (target != null &&
(target.GetPublicInstancePropertyValue("AppCatalog") != null ||
target.GetPublicInstancePropertyValue("ContentDeliveryNetwork") != null))
{
persistence.GetPublicInstanceProperty("Tenant").SetValue(persistence, target);
}
}
}
}
public object Resolve(object source, Dictionary <String, IResolver> resolvers = null, Boolean recursive = false)
{
ContentDeliveryNetwork result = null;
var cdnSettings = source.GetPublicInstancePropertyValue("ContentDeliveryNetwork");
if (null != cdnSettings)
{
var publicCdn = cdnSettings.GetPublicInstancePropertyValue("Public");
CdnSettings publicCdnSettings = null;
if (null != publicCdn)
{
publicCdnSettings = new Model.CdnSettings();
PnPObjectsMapper.MapProperties(publicCdn, publicCdnSettings, resolvers, recursive);
}
var privateCdn = cdnSettings.GetPublicInstancePropertyValue("Private");
CdnSettings privateCdnSettings = null;
if (null != privateCdn)
{
privateCdnSettings = new Model.CdnSettings();
PnPObjectsMapper.MapProperties(privateCdn, privateCdnSettings, resolvers, recursive);
}
result = new ContentDeliveryNetwork(publicCdnSettings, privateCdnSettings);
}
return(result);
}
public object Resolve(object source, Dictionary<String, IResolver> resolvers = null, Boolean recursive = false)
{
var result = new List<Model.Folder>();
var folders = source.GetPublicInstancePropertyValue("Folders");
if (null == folders)
{
folders = source.GetPublicInstancePropertyValue("Folder1");
}
resolvers = new Dictionary<string, IResolver>();
resolvers.Add($"{typeof(Model.Folder).FullName}.Folders", new FoldersFromSchemaToModelTypeResolver());
resolvers.Add($"{typeof(Model.Folder).FullName}.Security", new SecurityFromSchemaToModelTypeResolver());
if (null != folders)
{
foreach (var f in ((IEnumerable)folders))
{
var targetItem = new Model.Folder();
PnPObjectsMapper.MapProperties(f, targetItem, resolvers, recursive);
result.Add(targetItem);
}
}
return (result);
}
public override void Deserialize(object persistence, ProvisioningTemplate template)
{
var theme = persistence.GetPublicInstancePropertyValue("Theme");
if (theme != null)
{
var expressions = new Dictionary <Expression <Func <Theme, Object> >, IResolver>
{
// Manage Palette of Theme
{
t => t.Palette,
new ExpressionValueResolver((s, v) =>
{
String result = null;
if (s != null)
{
String[] text = s.GetPublicInstancePropertyValue("Text") as String[];
if (text != null && text.Length > 0)
{
result = text.Aggregate(String.Empty, (acc, next) => acc += (next != null ? next : String.Empty));
}
}
return(result?.Trim());
})
}
};
template.Theme = new Theme();
PnPObjectsMapper.MapProperties(theme, template.Theme, expressions, true);
}
}
public override void Serialize(ProvisioningTemplate template, object persistence)
{
if (template.Parameters != null && template.Parameters.Count > 0)
{
var preferences = persistence.GetPublicInstancePropertyValue("Preferences");
if (preferences != null)
{
var parametersTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.PreferencesParameter, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var parametersType = Type.GetType(parametersTypeName, true);
preferences.GetPublicInstanceProperty("Parameters")
.SetValue(
preferences,
PnPObjectsMapper.MapObjects(template.Parameters,
new TemplateParameterFromModelToSchemaTypeResolver(parametersType)));
var parameters = preferences.GetPublicInstancePropertyValue("Parameters");
if (parameters != null && ((Array)parameters).Length == 0)
{
preferences.GetPublicInstanceProperty("Parameters").SetValue(preferences, null);
}
}
}
}
public override void Serialize(ProvisioningTemplate template, object persistence)
{
if (template.ProvisioningTemplateWebhooks != null && template.ProvisioningTemplateWebhooks.Count > 0)
{
var provisioningTemplateWebhookTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.ProvisioningWebhook, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var provisioningTemplateWebhookType = Type.GetType(provisioningTemplateWebhookTypeName, true);
var expressions = new Dictionary <string, IResolver>();
// Parameters
var dictionaryItemTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.StringDictionaryItem, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var dictionaryItemType = Type.GetType(dictionaryItemTypeName, true);
var dictionaryItemKeySelector = CreateSelectorLambda(dictionaryItemType, "Key");
var dictionaryItemValueSelector = CreateSelectorLambda(dictionaryItemType, "Value");
expressions.Add($"{provisioningTemplateWebhookType}.Parameters",
new FromDictionaryToArrayValueResolver <string, string>(
dictionaryItemType, dictionaryItemKeySelector, dictionaryItemValueSelector));
persistence.GetPublicInstanceProperty("ProvisioningTemplateWebhooks")
.SetValue(
persistence,
PnPObjectsMapper.MapObjects(template.ProvisioningTemplateWebhooks,
new CollectionFromModelToSchemaTypeResolver(provisioningTemplateWebhookType),
expressions,
recursive: true));
}
}
public override void Serialize(ProvisioningTemplate template, object persistence)
{
var propertiesTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.StringDictionaryItem, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}";
var propertiesType = Type.GetType(propertiesTypeName, true);
var templateType = Type.GetType($"{PnPSerializationScope.Current?.BaseSchemaNamespace}.ProvisioningTemplate, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}", true);
var keySelector = CreateSelectorLambda(propertiesType, "Key");
var valueSelector = CreateSelectorLambda(propertiesType, "Value");
var expressions = new Dictionary <string, IResolver>();
expressions.Add($"{templateType}.Version", new FromDoubleToDecimalValueResolver());
expressions.Add($"{templateType}.VersionSpecified", new ExpressionValueResolver(() => true));
expressions.Add($"{templateType}.Properties",
new FromDictionaryToArrayValueResolver <String, String>(
propertiesType, keySelector, valueSelector));
PnPObjectsMapper.MapProperties(template, persistence, expressions, true);
// Search settings
if (!string.IsNullOrEmpty(template.SiteSearchSettings) || !string.IsNullOrEmpty(template.WebSearchSettings))
{
var searchSettingType = Type.GetType($"{PnPSerializationScope.Current?.BaseSchemaNamespace}.ProvisioningTemplateSearchSettings, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}", true);
var searchSettings = Activator.CreateInstance(searchSettingType, true);
if (!string.IsNullOrEmpty(template.SiteSearchSettings))
{
searchSettings.GetPublicInstanceProperty("SiteSearchSettings").SetValue(searchSettings, XElement.Parse(template.SiteSearchSettings).ToXmlElement());
}
if (!string.IsNullOrEmpty(template.WebSearchSettings))
{
searchSettings.GetPublicInstanceProperty("WebSearchSettings").SetValue(searchSettings, XElement.Parse(template.WebSearchSettings).ToXmlElement());
}
persistence.GetPublicInstanceProperty("SearchSettings").SetValue(persistence, searchSettings);
}
}
