public override ProvisioningTemplate CreateEntities(Web web, ProvisioningTemplate template, ProvisioningTemplateCreationInformation creationInfo)
{
// if this is a sub site then we're not creating content type entities.
if (web.IsSubSite())
{
return template;
}
var cts = web.ContentTypes;
web.Context.Load(cts);
web.Context.ExecuteQuery();
foreach (var ct in cts)
{
if (!BuiltInContentTypeId.Contains(ct.StringId))
{
template.ContentTypes.Add(new Birchman.RemoteProvisioning.Domain.Model.ContentType() { SchemaXml = ct.SchemaXml });
}
}
// If a base template is specified then use that one to "cleanup" the generated template model
if (creationInfo.BaseTemplate != null)
{
template = CleanupEntities(template, creationInfo.BaseTemplate);
}
return template;
}
public override ProvisioningTemplate CreateEntities(Web web, ProvisioningTemplate template, ProvisioningTemplateCreationInformation creationInfo)
{
var context = web.Context as ClientContext;
bool isSubSite = web.IsSubSite();
var webCustomActions = web.GetCustomActions();
var siteCustomActions = context.Site.GetCustomActions();
var customActions = new CustomActions();
foreach (var customAction in webCustomActions)
{
customActions.WebCustomActions.Add(CopyUserCustomAction(customAction));
}
// if this is a sub site then we're not creating entities for site collection scoped custom actions
if (!isSubSite)
{
foreach (var customAction in siteCustomActions)
{
customActions.SiteCustomActions.Add(CopyUserCustomAction(customAction));
}
}
template.CustomActions = customActions;
// If a base template is specified then use that one to "cleanup" the generated template model
if (creationInfo.BaseTemplate != null)
{
template = CleanupEntities(template, creationInfo.BaseTemplate, isSubSite);
}
return template;
}
public override ProvisioningTemplate CreateEntities(Web web, ProvisioningTemplate template, ProvisioningTemplateCreationInformation creationInfo)
{
// if this is a sub site then we're not creating field entities.
if (web.IsSubSite())
{
return template;
}
var existingFields = web.Fields;
web.Context.Load(existingFields, fs => fs.Include(f => f.Id, f => f.SchemaXml));
web.Context.ExecuteQuery();
foreach (var field in existingFields)
{
if (!BuiltInFieldId.Contains(field.Id))
{
template.SiteFields.Add(new Field() { SchemaXml = field.SchemaXml });
}
}
// If a base template is specified then use that one to "cleanup" the generated template model
if (creationInfo.BaseTemplate != null)
{
template = CleanupEntities(template, creationInfo.BaseTemplate);
}
return template;
}
public override ProvisioningTemplate CreateEntities(Web web, ProvisioningTemplate template, ProvisioningTemplateCreationInformation creationInfo)
{
// If a base template is specified then use that one to "cleanup" the generated template model
if (creationInfo.BaseTemplate != null)
{
template = CleanupEntities(template, creationInfo.BaseTemplate);
}
return template;
}
public override ProvisioningTemplate CreateEntities(Web web, ProvisioningTemplate template, ProvisioningTemplateCreationInformation creationInfo)
{
var context = web.Context as ClientContext;
bool isSubSite = web.IsSubSite();
var webFeatures = web.Features;
var siteFeatures = context.Site.Features;
context.Load(webFeatures, fs => fs.Include(f => f.DefinitionId));
if (!isSubSite)
{
context.Load(siteFeatures, fs => fs.Include(f => f.DefinitionId));
}
context.ExecuteQuery();
var features = new Features();
foreach (var feature in webFeatures)
{
features.WebFeatures.Add(new Feature() { Deactivate = false, ID = feature.DefinitionId });
}
// if this is a sub site then we're not creating site collection scoped feature entities
if (!isSubSite)
{
foreach (var feature in siteFeatures)
{
features.SiteFeatures.Add(new Feature() { Deactivate = false, ID = feature.DefinitionId });
}
}
template.Features = features;
// If a base template is specified then use that one to "cleanup" the generated template model
if (creationInfo.BaseTemplate != null)
{
template = CleanupEntities(template, creationInfo.BaseTemplate, isSubSite);
}
return template;
}
/// <summary>
/// Can be used to extract custom provisioning template from existing site. The extracted template
/// will be compared with the default base template.
/// </summary>
/// <param name="web">Web to get template from</param>
/// <param name="connector">Connector that will be used to persist the files retrieved from the template "get"</param>
/// <returns>ProvisioningTemplate object with generated values from existing site</returns>
public static ProvisioningTemplate GetProvisioningTemplate(this Web web, ProvisioningTemplateCreationInformation creationInfo)
{
return new SiteToTemplateConversion().GetRemoteTemplate(web, creationInfo);
}
/// <summary>
/// Can be used to extract custom provisioning template from existing site. The extracted template
/// will be compared with the default base template.
/// </summary>
/// <param name="web">Web to get template from</param>
/// <returns>ProvisioningTemplate object with generated values from existing site</returns>
public static ProvisioningTemplate GetProvisioningTemplate(this Web web)
{
ProvisioningTemplateCreationInformation creationInfo = new ProvisioningTemplateCreationInformation(web);
// Load the base template which will be used for the comparison work
creationInfo.BaseTemplate = web.GetBaseTemplate();
return new SiteToTemplateConversion().GetRemoteTemplate(web, creationInfo);
}
/// <summary>
/// Actual implementation of extracting configuration from existing site.
/// </summary>
/// <param name="web"></param>
/// <param name="baseTemplate"></param>
/// <returns></returns>
internal ProvisioningTemplate GetRemoteTemplate(Web web, ProvisioningTemplateCreationInformation creationInfo)
{
// Create empty object
ProvisioningTemplate template = new ProvisioningTemplate();
// Hookup connector, is handy when the generated template object is used to apply to another site
template.Connector = creationInfo.FileConnector;
// Get Security
template = new ObjectSiteSecurity().CreateEntities(web, template, creationInfo);
// Site Fields
template = new ObjectField().CreateEntities(web, template, creationInfo);
// Content Types
template = new ObjectContentType().CreateEntities(web, template, creationInfo);
// Get Lists
template = new ObjectListInstance().CreateEntities(web, template, creationInfo);
// Get custom actions
template = new ObjectCustomActions().CreateEntities(web, template, creationInfo);
// Get features
template = new ObjectFeatures().CreateEntities(web, template, creationInfo);
// Get composite look
//template = new ObjectComposedLook().CreateEntities(web, template, creationInfo);
// Get files
template = new ObjectFiles().CreateEntities(web, template, creationInfo);
// Get Property Bag Entries
template = new ObjectPropertyBagEntry().CreateEntities(web, template, creationInfo);
// In future we could just instantiate all objects which are inherited from object handler base dynamically
// Set default values for Template ID and Version
template.ID = String.Format("TEMPLATE-{0:N}", Guid.NewGuid()).ToUpper();
template.Version = 1;
// Retrieve original Template ID and remove it from Property Bag Entries
int provisioningTemplateIdIndex = template.PropertyBagEntries.FindIndex(f => f.Key.Equals("_PnP_ProvisioningTemplateId"));
if (provisioningTemplateIdIndex > -1)
{
var templateId = template.PropertyBagEntries[provisioningTemplateIdIndex].Value;
if (!String.IsNullOrEmpty(templateId))
{
template.ID = templateId;
}
template.PropertyBagEntries.RemoveAt(provisioningTemplateIdIndex);
}
// Retrieve original Template Info and remove it from Property Bag Entries
int provisioningTemplateInfoIndex = template.PropertyBagEntries.FindIndex(f => f.Key.Equals("_PnP_ProvisioningTemplateInfo"));
if (provisioningTemplateInfoIndex > -1)
{
var jsonInfo = template.PropertyBagEntries[provisioningTemplateInfoIndex].Value;
var s = new JavaScriptSerializer();
ProvisioningTemplateInfo info = s.Deserialize<ProvisioningTemplateInfo>(jsonInfo);
// Override any previously defined Template ID, Version, and SitePolicy
// with the one stored in the Template Info, if any
if (!String.IsNullOrEmpty(info.TemplateID))
{
template.ID = info.TemplateID;
}
if (!String.IsNullOrEmpty(info.TemplateSitePolicy))
{
template.SitePolicy = info.TemplateSitePolicy;
}
if (info.TemplateVersion > 0)
{
template.Version = info.TemplateVersion;
}
template.PropertyBagEntries.RemoveAt(provisioningTemplateInfoIndex);
}
return template;
}
public override ProvisioningTemplate CreateEntities(Web web, ProvisioningTemplate template, ProvisioningTemplateCreationInformation creationInfo)
{
if (!web.IsPropertyAvailable("ServerRelativeUrl"))
{
web.Context.Load(web, w => w.ServerRelativeUrl);
web.Context.ExecuteQuery();
}
var serverRelativeUrl = web.ServerRelativeUrl;
// For each list in the site
ListCollection lists = web.Lists;
web.Context.Load(lists, lc => lc.IncludeWithDefaultProperties(l => l.ContentTypes, l => l.Views, l => l.RootFolder.ServerRelativeUrl, l => l.Fields));
web.Context.ExecuteQuery();
foreach (var item in lists)
{
// Do not export system lists
if (!item.Hidden)
{
int index = -1;
if (creationInfo.BaseTemplate != null)
{
// Check if we need to skip this list...if so let's do it before we gather all the other information for this list...improves perf
index = creationInfo.BaseTemplate.Lists.FindIndex(f => f.Url.Equals(item.RootFolder.ServerRelativeUrl.Substring(serverRelativeUrl.Length)) &&
f.TemplateType.Equals(item.BaseTemplate));
}
if (index == -1)
{
var contentTypeFields = new List<FieldRef>();
ListInstance list = new ListInstance();
list.Description = item.Description;
list.EnableVersioning = item.EnableVersioning;
list.TemplateType = item.BaseTemplate;
list.Title = item.Title;
list.Hidden = item.Hidden;
list.DocumentTemplate = Tokenize(item.DocumentTemplateUrl, web.Url);
list.ContentTypesEnabled = item.ContentTypesEnabled;
list.Url = item.RootFolder.ServerRelativeUrl.Substring(serverRelativeUrl.Length).TrimStart('/');
int count = 0;
foreach (var ct in item.ContentTypes)
{
web.Context.Load(ct, c => c.Parent);
web.Context.ExecuteQuery();
if (ct.Parent != null)
{
// Add the parent to the list of content types
if (!BuiltInContentTypeId.Contains(ct.Parent.StringId))
{
list.ContentTypeBindings.Add(new ContentTypeBinding() {ContentTypeID = ct.Parent.StringId, Default = count == 0 ? true : false});
}
}
else
{
list.ContentTypeBindings.Add(new ContentTypeBinding() {ContentTypeID = ct.StringId, Default = count == 0});
}
web.Context.Load(ct.FieldLinks);
web.Context.ExecuteQuery();
foreach (var fieldLink in ct.FieldLinks)
{
if (!fieldLink.Hidden)
{
contentTypeFields.Add(new FieldRef() { ID = fieldLink.Id });
}
}
count++;
}
foreach (var view in item.Views)
{
if (!view.Hidden)
{
list.Views.Add(new View() { SchemaXml = view.ListViewXml });
}
}
var siteColumns = web.Fields;
web.Context.Load(siteColumns, scs => scs.Include(sc => sc.Id));
web.Context.ExecuteQuery();
foreach (var field in item.Fields)
{
if (!field.Hidden)
{
if (siteColumns.FirstOrDefault(sc => sc.Id == field.Id) != null)
{
if (contentTypeFields.FirstOrDefault(c => c.ID == field.Id) == null)
{
list.FieldRefs.Add(new FieldRef() { ID = field.Id });
}
}
else
{
list.Fields.Add((new Model.Field() { SchemaXml = field.SchemaXml }));
}
}
}
template.Lists.Add(list);
}
}
}
return template;
}
public abstract ProvisioningTemplate CreateEntities(Web web, ProvisioningTemplate template, ProvisioningTemplateCreationInformation creationInfo);
