/// <summary>
/// Generate a portable JSON object from the List Template
/// </summary>
/// <param name="context">Client Context web</param>
/// <param name="hostWeb">Client Context web</param>
/// <param name="list">Hydrated SharePoint list Object</param>
/// <param name="ExpandObjects">true - enumerate fields, views, content types</param>
/// <param name="logger">Logger implementation for Verbose/Exception handling</param>
/// <param name="skiptypes">Collection of field types to be used as a filter statement</param>
/// <param name="siteGroups">Collection of hostWeb groups</param>
/// <returns></returns>
public static SPListDefinition GetListDefinition(this ClientContext context, Web hostWeb, List list, bool ExpandObjects, ITraceLogger logger, IEnumerable <FieldType> skiptypes, IEnumerable <Microsoft.SharePoint.Client.Group> siteGroups = null)
{
logger.LogInformation("Processing Web list {0}", list.Title);
if (!hostWeb.IsPropertyAvailable(ctx => ctx.ServerRelativeUrl))
{
hostWeb.Context.Load(hostWeb, ctx => ctx.ServerRelativeUrl);
hostWeb.Context.ExecuteQueryRetry();
}
list.EnsureProperties(
lctx => lctx.Id,
lctx => lctx.Title,
lctx => lctx.Description,
lctx => lctx.DefaultViewUrl,
lctx => lctx.OnQuickLaunch,
lctx => lctx.BaseTemplate,
lctx => lctx.BaseType,
lctx => lctx.CrawlNonDefaultViews,
lctx => lctx.Created,
lctx => lctx.ContentTypesEnabled,
lctx => lctx.CreatablesInfo,
lctx => lctx.EnableFolderCreation,
lctx => lctx.EnableModeration,
lctx => lctx.EnableVersioning,
lctx => lctx.Hidden,
lctx => lctx.IsApplicationList,
lctx => lctx.IsCatalog,
lctx => lctx.IsSiteAssetsLibrary,
lctx => lctx.IsPrivate,
lctx => lctx.IsSystemList,
lctx => lctx.RootFolder.ServerRelativeUrl,
lctx => lctx.SchemaXml,
lctx => lctx.LastItemModifiedDate,
lctx => lctx.LastItemUserModifiedDate,
lctx => lctx.ListExperienceOptions,
lctx => lctx.TemplateFeatureId);
var weburl = hostWeb.ServerRelativeUrl.EnsureTrailingSlashLowered();
var listTemplateType = list.GetListTemplateType();
var listdefinition = new SPListDefinition()
{
Id = list.Id,
ListName = list.Title,
ListDescription = list.Description,
ServerRelativeUrl = list.DefaultViewUrl,
BaseTemplate = list.BaseTemplate,
ListTemplate = listTemplateType,
Created = list.Created,
LastItemModifiedDate = list.LastItemModifiedDate,
LastItemUserModifiedDate = list.LastItemUserModifiedDate,
QuickLaunch = list.OnQuickLaunch ? QuickLaunchOptions.On : QuickLaunchOptions.Off,
ContentTypeEnabled = list.ContentTypesEnabled,
EnableFolderCreation = list.EnableFolderCreation,
Hidden = list.Hidden,
IsApplicationList = list.IsApplicationList,
IsCatalog = list.IsCatalog,
IsSiteAssetsLibrary = list.IsSiteAssetsLibrary,
IsPrivate = list.IsPrivate,
IsSystemList = list.IsSystemList
};
if (ExpandObjects)
{
var contentTypesFieldset = new List <dynamic>();
var definitionListFields = new List <SPFieldDefinitionModel>();
var listurl = TokenHelper.EnsureTrailingSlash(list.RootFolder.ServerRelativeUrl);
// content types
var listContentType = list.Context.LoadQuery(list.ContentTypes
.Include(
ict => ict.Id,
ict => ict.Group,
ict => ict.Description,
ict => ict.Name,
ict => ict.Hidden,
ict => ict.JSLink,
ict => ict.FieldLinks,
ict => ict.Fields));
// list fields
var listFields = list.Context.LoadQuery(list.Fields.Where(wf => wf.ReadOnlyField == false && wf.Hidden == false)
.Include(
fctx => fctx.Id,
fctx => fctx.AutoIndexed,
fctx => fctx.CanBeDeleted,
fctx => fctx.DefaultFormula,
fctx => fctx.DefaultValue,
fctx => fctx.Group,
fctx => fctx.Description,
fctx => fctx.EnforceUniqueValues,
fctx => fctx.FieldTypeKind,
fctx => fctx.Filterable,
fctx => fctx.FromBaseType,
fctx => fctx.Hidden,
fctx => fctx.Indexed,
fctx => fctx.InternalName,
fctx => fctx.JSLink,
fctx => fctx.NoCrawl,
fctx => fctx.ReadOnlyField,
fctx => fctx.Required,
fctx => fctx.SchemaXml,
fctx => fctx.Scope,
fctx => fctx.Title
));
// list views
var listViews = list.Context.LoadQuery(list.Views
.Include(
lvt => lvt.Title,
lvt => lvt.DefaultView,
lvt => lvt.ServerRelativeUrl,
lvt => lvt.Id,
lvt => lvt.Aggregations,
lvt => lvt.AggregationsStatus,
lvt => lvt.BaseViewId,
lvt => lvt.Hidden,
lvt => lvt.ImageUrl,
lvt => lvt.JSLink,
lvt => lvt.HtmlSchemaXml,
lvt => lvt.ListViewXml,
lvt => lvt.MobileDefaultView,
lvt => lvt.ModerationType,
lvt => lvt.OrderedView,
lvt => lvt.Paged,
lvt => lvt.PageRenderType,
lvt => lvt.PersonalView,
lvt => lvt.ReadOnlyView,
lvt => lvt.Scope,
lvt => lvt.RowLimit,
lvt => lvt.StyleId,
lvt => lvt.TabularView,
lvt => lvt.Threaded,
lvt => lvt.Toolbar,
lvt => lvt.ToolbarTemplateName,
lvt => lvt.ViewFields,
lvt => lvt.ViewJoins,
lvt => lvt.ViewQuery,
lvt => lvt.ViewType,
lvt => lvt.ViewProjectedFields,
lvt => lvt.Method
));
list.Context.ExecuteQueryRetry();
if (listContentType != null && listContentType.Any())
{
listdefinition.ContentTypes = new List <SPContentTypeDefinition>();
foreach (var contenttype in listContentType)
{
logger.LogInformation("Processing list {0} content type {1}", list.Title, contenttype.Name);
var ctypemodel = new SPContentTypeDefinition()
{
Inherits = true,
ContentTypeId = contenttype.Id.StringValue,
ContentTypeGroup = contenttype.Group,
Description = contenttype.Description,
Name = contenttype.Name,
Hidden = contenttype.Hidden,
JSLink = contenttype.JSLink
};
if (contenttype.FieldLinks.Any())
{
ctypemodel.FieldLinks = new List <SPFieldLinkDefinitionModel>();
foreach (var cfieldlink in contenttype.FieldLinks)
{
ctypemodel.FieldLinks.Add(new SPFieldLinkDefinitionModel()
{
Id = cfieldlink.Id,
Name = cfieldlink.Name,
Hidden = cfieldlink.Hidden,
Required = cfieldlink.Required
});
contentTypesFieldset.Add(new { ctypeid = contenttype.Id.StringValue, name = cfieldlink.Name });
}
}
if (contenttype.Fields.Any())
{
foreach (var cfield in contenttype.Fields.Where(cf => !ctypemodel.FieldLinks.Any(fl => fl.Name == cf.InternalName)))
{
ctypemodel.FieldLinks.Add(new SPFieldLinkDefinitionModel()
{
Id = cfield.Id,
Name = cfield.InternalName,
Hidden = cfield.Hidden,
Required = cfield.Required
});
}
}
listdefinition.ContentTypes.Add(ctypemodel);
}
}
if (listFields != null && listFields.Any())
{
var filteredListFields = listFields.Where(lf => !skiptypes.Any(st => lf.FieldTypeKind == st)).ToList();
logger.LogWarning("Processing list {0} found {1} fields to be processed", list.Title, filteredListFields.Count());
foreach (Field listField in listFields)
{
logger.LogInformation("Processing list {0} field {1}", list.Title, listField.InternalName);
try
{
var fieldXml = listField.SchemaXml;
if (!string.IsNullOrEmpty(fieldXml))
{
var xdoc = XDocument.Parse(fieldXml, LoadOptions.PreserveWhitespace);
var xField = xdoc.Element("Field");
var xSourceID = xField.Attribute("SourceID");
//if (xSourceID != null && xSourceID.Value.IndexOf(ConstantsXmlNamespaces.SharePointNS.NamespaceName, StringComparison.CurrentCultureIgnoreCase) < 0)
//{
// continue; // skip processing an OOTB field
//}
var customField = context.RetrieveField(listField, logger, siteGroups, xField);
if (xSourceID != null)
{
customField.SourceID = xSourceID.Value;
}
definitionListFields.Add(customField);
if (customField.FieldTypeKind == FieldType.Lookup)
{
listdefinition.ListDependency.Add(customField.LookupListName);
}
}
}
catch (Exception ex)
{
logger.LogError(ex, "Failed to parse field {0} MSG:{1}", listField.InternalName, ex.Message);
}
}
listdefinition.FieldDefinitions = definitionListFields;
}
if (listViews != null && listViews.Any())
{
listdefinition.InternalViews = new List <SPViewDefinitionModel>();
listdefinition.Views = new List <SPViewDefinitionModel>();
foreach (var view in listViews)
{
logger.LogInformation("Processing list {0} view {1}", list.Title, view.Title);
var vinternal = (view.ServerRelativeUrl.IndexOf(listurl, StringComparison.CurrentCultureIgnoreCase) == -1);
ViewType viewCamlType = InfrastructureAsCode.Core.Extensions.ListExtensions.TryGetViewType(view.ViewType);
var viewmodel = new SPViewDefinitionModel()
{
Id = view.Id,
Title = view.Title,
DefaultView = view.DefaultView,
FieldRefName = new List <string>(),
Aggregations = view.Aggregations,
AggregationsStatus = view.AggregationsStatus,
BaseViewId = view.BaseViewId,
Hidden = view.Hidden,
ImageUrl = view.ImageUrl,
Toolbar = view.Toolbar,
ListViewXml = view.ListViewXml,
MobileDefaultView = view.MobileDefaultView,
ModerationType = view.ModerationType,
OrderedView = view.OrderedView,
Paged = view.Paged,
PageRenderType = view.PageRenderType,
PersonalView = view.PersonalView,
ReadOnlyView = view.ReadOnlyView,
Scope = view.Scope,
RowLimit = view.RowLimit,
StyleId = view.StyleId,
TabularView = view.TabularView,
Threaded = view.Threaded,
ViewJoins = view.ViewJoins,
ViewQuery = view.ViewQuery,
ViewCamlType = viewCamlType
};
if (vinternal)
{
viewmodel.SitePage = view.ServerRelativeUrl.Replace(weburl, "");
viewmodel.InternalView = true;
}
else
{
viewmodel.InternalName = view.ServerRelativeUrl.Replace(listurl, "").Replace(".aspx", "");
}
if (view.ViewFields != null && view.ViewFields.Any())
{
foreach (var vfields in view.ViewFields)
{
viewmodel.FieldRefName.Add(vfields);
}
}
if (view.JSLink != null && view.JSLink.Any())
{
var vjslinks = view.JSLink.Split(new string[] { "|" }, StringSplitOptions.RemoveEmptyEntries);
if (vjslinks != null && !vjslinks.Any(jl => jl == "clienttemplates.js"))
{
viewmodel.JsLinkFiles = new List <string>();
foreach (var vjslink in vjslinks)
{
viewmodel.JsLinkFiles.Add(vjslink);
}
}
}
if (view.Hidden)
{
listdefinition.InternalViews.Add(viewmodel);
}
else
{
listdefinition.Views.Add(viewmodel);
}
}
}
}
return(listdefinition);
}
private SPSiteModel ProcessSite(Web _web)
{
var hasListFound = false;
var model = new SPSiteModel();
_web.EnsureProperties(wssp => wssp.Id,
wspp => wspp.ServerRelativeUrl,
wspp => wspp.Title,
wssp => wssp.HasUniqueRoleAssignments,
wssp => wssp.SiteUsers,
wssp => wssp.Url,
wssp => wssp.Lists,
wssp => wssp.ContentTypes.Include(
lcnt => lcnt.Id,
lcnt => lcnt.Name,
lcnt => lcnt.StringId,
lcnt => lcnt.Description,
lcnt => lcnt.DocumentTemplate,
lcnt => lcnt.Group,
lcnt => lcnt.Hidden,
lcnt => lcnt.JSLink,
lcnt => lcnt.SchemaXml,
lcnt => lcnt.Scope,
lcnt => lcnt.FieldLinks.Include(
lcntlnk => lcntlnk.Id,
lcntlnk => lcntlnk.Name,
lcntlnk => lcntlnk.Hidden,
lcntlnk => lcntlnk.Required
),
lcnt => lcnt.Fields.Include(
lcntfld => lcntfld.FieldTypeKind,
lcntfld => lcntfld.InternalName,
lcntfld => lcntfld.Id,
lcntfld => lcntfld.Group,
lcntfld => lcntfld.Title,
lcntfld => lcntfld.Hidden,
lcntfld => lcntfld.Description,
lcntfld => lcntfld.JSLink,
lcntfld => lcntfld.Indexed,
lcntfld => lcntfld.Required,
lcntfld => lcntfld.SchemaXml)),
wssp => wssp.Fields.Include(
lcntfld => lcntfld.FieldTypeKind,
lcntfld => lcntfld.InternalName,
lcntfld => lcntfld.Id,
lcntfld => lcntfld.Group,
lcntfld => lcntfld.Title,
lcntfld => lcntfld.Hidden,
lcntfld => lcntfld.Description,
lcntfld => lcntfld.JSLink,
lcntfld => lcntfld.Indexed,
lcntfld => lcntfld.Required,
lcntfld => lcntfld.SchemaXml));
model.Url = _web.Url;
model.title = _web.Title;
LogVerbose("Processing: {0}", _web.Url);
/* Process Fields */
try
{
foreach (var _fields in _web.Fields)
{
if (string.IsNullOrEmpty(FieldColumnName) ||
_fields.Title.Equals(FieldColumnName, StringComparison.InvariantCultureIgnoreCase))
{
hasListFound = true;
model.FieldDefinitions.Add(new SPFieldDefinitionModel()
{
FieldTypeKind = _fields.FieldTypeKind,
InternalName = _fields.InternalName,
FieldGuid = _fields.Id,
GroupName = _fields.Group,
Title = _fields.Title,
HiddenField = _fields.Hidden,
Description = _fields.Description,
JSLink = _fields.JSLink,
FieldIndexed = _fields.Indexed,
Required = _fields.Required,
SchemaXml = _fields.SchemaXml
});
}
}
;
}
catch (Exception e)
{
LogError(e, "Failed to retrieve site owners {0}", _web.Url);
}
/* Process Content Type */
try
{
foreach (var _ctypes in _web.ContentTypes)
{
var cmodel = new SPContentTypeDefinition()
{
ContentTypeId = _ctypes.StringId,
Name = _ctypes.Name,
Description = _ctypes.Description,
DocumentTemplate = _ctypes.DocumentTemplate,
ContentTypeGroup = _ctypes.Group,
Hidden = _ctypes.Hidden,
JSLink = _ctypes.JSLink,
Scope = _ctypes.Scope
};
foreach (var _ctypeFields in _ctypes.FieldLinks)
{
if (string.IsNullOrEmpty(FieldColumnName) ||
_ctypeFields.Name.Equals(FieldColumnName, StringComparison.InvariantCultureIgnoreCase))
{
cmodel.FieldLinks.Add(new SPFieldLinkDefinitionModel()
{
Name = _ctypeFields.Name,
Id = _ctypeFields.Id,
Hidden = _ctypeFields.Hidden,
Required = _ctypeFields.Required
});
}
}
if (cmodel.FieldLinks.Any())
{
hasListFound = true;
model.ContentTypes.Add(cmodel);
}
}
;
}
catch (Exception e)
{
LogError(e, "Failed to retrieve site owners {0}", _web.Url);
}
// ********** Process List
try
{
var lists = ProcessList(_web);
if (lists.Any())
{
hasListFound = true;
model.Lists.AddRange(lists);
}
}
catch (Exception e)
{
LogError(e, "Exception occurred in processSite");
}
if (hasListFound)
{
// setting ID to indicate to parent consumer that this entity has unique permissions in the TREE
model.Id = _web.Id;
}
return(model);
}
private IList <SPListDefinition> ProcessList(Web _web)
{
var model = new List <SPListDefinition>();
// ********** Process Lists
ListCollection _lists = _web.Lists;
_web.Context.Load(_lists,
spp => spp.Include(
sppi => sppi.Id,
sppi => sppi.Title,
sppi => sppi.RootFolder.ServerRelativeUrl,
sppi => sppi.HasUniqueRoleAssignments,
sppi => sppi.BaseTemplate,
sppi => sppi.Hidden,
sppi => sppi.IsSystemList,
sppi => sppi.IsPrivate,
sppi => sppi.IsApplicationList,
sppi => sppi.IsCatalog,
sppi => sppi.IsSiteAssetsLibrary));
_web.Context.ExecuteQueryRetry();
var docLibEnumValue = Convert.ToInt32(Microsoft.SharePoint.Client.ListTemplateType.DocumentLibrary);
// Restrict to natural lists or custom lists
foreach (List _list in _lists.Where(sppi
=> !sppi.IsSystemList &&
!sppi.IsApplicationList &&
sppi.BaseTemplate != docLibEnumValue))
{
var hasListFound = false;
var listContext = _list.Context;
LogVerbose("Enumerating List {0} URL:{1}", _list.Title, _list.RootFolder.ServerRelativeUrl);
try
{
listContext.Load(_list,
lssp => lssp.Id,
lssp => lssp.Title,
lssp => lssp.HasUniqueRoleAssignments,
lssp => lssp.Title,
lssp => lssp.Hidden,
lssp => lssp.IsSystemList,
lssp => lssp.IsPrivate,
lssp => lssp.IsApplicationList,
lssp => lssp.IsCatalog,
lssp => lssp.IsSiteAssetsLibrary,
lssp => lssp.RootFolder.ServerRelativeUrl,
lssp => lssp.ContentTypes.Include(
lcnt => lcnt.Id,
lcnt => lcnt.Name,
lcnt => lcnt.StringId,
lcnt => lcnt.Description,
lcnt => lcnt.DocumentTemplate,
lcnt => lcnt.Group,
lcnt => lcnt.Hidden,
lcnt => lcnt.JSLink,
lcnt => lcnt.SchemaXml,
lcnt => lcnt.Scope,
lcnt => lcnt.FieldLinks.Include(
lcntlnk => lcntlnk.Id,
lcntlnk => lcntlnk.Name,
lcntlnk => lcntlnk.Hidden,
lcntlnk => lcntlnk.Required
),
lcnt => lcnt.Fields.Include(
lcntfld => lcntfld.FieldTypeKind,
lcntfld => lcntfld.InternalName,
lcntfld => lcntfld.Id,
lcntfld => lcntfld.Group,
lcntfld => lcntfld.Title,
lcntfld => lcntfld.Hidden,
lcntfld => lcntfld.Description,
lcntfld => lcntfld.JSLink,
lcntfld => lcntfld.Indexed,
lcntfld => lcntfld.Required,
lcntfld => lcntfld.SchemaXml)),
lssp => lssp.Fields.Include(
lcntfld => lcntfld.FieldTypeKind,
lcntfld => lcntfld.InternalName,
lcntfld => lcntfld.Id,
lcntfld => lcntfld.Group,
lcntfld => lcntfld.Title,
lcntfld => lcntfld.Hidden,
lcntfld => lcntfld.Description,
lcntfld => lcntfld.JSLink,
lcntfld => lcntfld.Indexed,
lcntfld => lcntfld.Required,
lcntfld => lcntfld.SchemaXml));
listContext.ExecuteQueryRetry();
var listModel = new SPListDefinition()
{
Id = _list.Id,
HasUniquePermission = _list.HasUniqueRoleAssignments,
ListName = _list.Title,
ServerRelativeUrl = _list.RootFolder.ServerRelativeUrl,
Hidden = _list.Hidden,
IsSystemList = _list.IsSystemList,
IsPrivate = _list.IsPrivate,
IsApplicationList = _list.IsApplicationList,
IsCatalog = _list.IsCatalog,
IsSiteAssetsLibrary = _list.IsSiteAssetsLibrary
};
/* Process Fields */
try
{
foreach (var _fields in _list.Fields)
{
if (string.IsNullOrEmpty(FieldColumnName) ||
_fields.Title.Equals(FieldColumnName, StringComparison.InvariantCultureIgnoreCase))
{
hasListFound = true;
listModel.FieldDefinitions.Add(new SPFieldDefinitionModel()
{
FieldTypeKind = _fields.FieldTypeKind,
InternalName = _fields.InternalName,
FieldGuid = _fields.Id,
GroupName = _fields.Group,
Title = _fields.Title,
HiddenField = _fields.Hidden,
Description = _fields.Description,
JSLink = _fields.JSLink,
FieldIndexed = _fields.Indexed,
Required = _fields.Required,
SchemaXml = _fields.SchemaXml
});
}
}
;
}
catch (Exception e)
{
LogError(e, "Failed to retrieve site owners {0}", _web.Url);
}
foreach (var _ctypes in _list.ContentTypes)
{
var cmodel = new SPContentTypeDefinition()
{
ContentTypeId = _ctypes.StringId,
Name = _ctypes.Name,
Description = _ctypes.Description,
DocumentTemplate = _ctypes.DocumentTemplate,
ContentTypeGroup = _ctypes.Group,
Hidden = _ctypes.Hidden,
JSLink = _ctypes.JSLink,
Scope = _ctypes.Scope
};
foreach (var _ctypeFields in _ctypes.FieldLinks)
{
if (string.IsNullOrEmpty(FieldColumnName) ||
_ctypeFields.Name.Equals(FieldColumnName, StringComparison.InvariantCultureIgnoreCase))
{
cmodel.FieldLinks.Add(new SPFieldLinkDefinitionModel()
{
Name = _ctypeFields.Name,
Id = _ctypeFields.Id,
Hidden = _ctypeFields.Hidden,
Required = _ctypeFields.Required
});
}
}
if (cmodel.FieldLinks.Any())
{
hasListFound = true;
listModel.ContentTypes.Add(cmodel);
}
}
if (hasListFound)
{
model.Add(listModel);
}
}
catch (Exception e)
{
LogError(e, "Failed in ProcessList");
}
}
return(model);
}
/// <summary>
/// Process the request
/// </summary>
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
// File Info
var fileInfo = new System.IO.FileInfo(this.ProvisionerFilePath);
// Initialize logging instance with Powershell logger
ITraceLogger logger = new DefaultUsageLogger(LogVerbose, LogWarning, LogError);
// Skip these specific fields
var skiptypes = new FieldType[]
{
FieldType.Computed,
FieldType.ContentTypeId,
FieldType.Invalid,
FieldType.WorkflowStatus,
FieldType.WorkflowEventType,
FieldType.Threading,
FieldType.ThreadIndex,
FieldType.Recurrence,
FieldType.PageSeparator,
FieldType.OutcomeChoice,
FieldType.CrossProjectLink,
FieldType.ModStat,
FieldType.Error,
FieldType.MaxItems,
FieldType.Attachments
};
var skipcolumns = new string[]
{
"_Hidden",
"Base Columns",
"Content Feedback",
"Core Contact and Calendar Columns",
"Core Document Columns",
"Core Task and Issue Columns",
"Display Template Columns",
"Document and Record Management Columns",
"Enterprise Keywords Group",
"Extended Columns",
"JavaScript Display Template Columns",
"Page Layout Columns",
"Publishing Columns",
"Reports",
"Status Indicators",
"Translation Columns"
};
var skipcontenttypes = new string[]
{
"_Hidden",
"Business Intelligence",
"Community Content Types",
"Digital Asset Content Types",
"Display Template Content Types",
"Document Content Types",
"Document Set Content Types",
"Folder Content Types",
"Content Feedback",
"Publishing Content Types",
"Page Layout Content Types",
"Special Content Types",
"Group Work Content Types",
"List Content Types"
};
// Construct the model
var SiteComponents = new SiteProvisionerModel();
// Load the Context
var contextWeb = this.ClientContext.Web;
this.ClientContext.Load(contextWeb, ctxw => ctxw.ServerRelativeUrl, ctxw => ctxw.Id);
// Get Site/Web fields
var fields = this.ClientContext.LoadQuery(contextWeb.Fields
.Include(
fctx => fctx.Id,
fctx => fctx.FieldTypeKind,
fctx => fctx.Group,
lft => lft.AutoIndexed,
lft => lft.CanBeDeleted,
lft => lft.DefaultFormula,
lft => lft.DefaultValue,
lft => lft.Description,
lft => lft.EnforceUniqueValues,
lft => lft.Filterable,
lft => lft.FromBaseType,
lft => lft.Hidden,
lft => lft.Indexed,
lft => lft.InternalName,
lft => lft.JSLink,
lft => lft.NoCrawl,
lft => lft.ReadOnlyField,
lft => lft.Required,
lft => lft.SchemaXml,
lft => lft.Scope,
lft => lft.Title));
var groupQuery = this.ClientContext.LoadQuery(contextWeb.SiteGroups
.Include(group => group.Id,
group => group.Title,
group => group.Description,
group => group.AllowRequestToJoinLeave,
group => group.AllowMembersEditMembership,
group => group.AutoAcceptRequestToJoinLeave,
group => group.OnlyAllowMembersViewMembership,
group => group.RequestToJoinLeaveEmailSetting));
var contentTypes = this.ClientContext.LoadQuery(contextWeb.ContentTypes
.Include(
ict => ict.Id,
ict => ict.Group,
ict => ict.Description,
ict => ict.Name,
ict => ict.Hidden,
ict => ict.JSLink,
ict => ict.FieldLinks,
ict => ict.Fields));
var lists = this.ClientContext.LoadQuery(contextWeb.Lists
.Include(
linc => linc.Title,
linc => linc.Id,
linc => linc.Description,
linc => linc.RootFolder.ServerRelativeUrl,
linc => linc.Hidden,
linc => linc.OnQuickLaunch,
linc => linc.BaseTemplate,
linc => linc.ContentTypesEnabled,
linc => linc.AllowContentTypes,
linc => linc.EnableFolderCreation,
linc => linc.IsApplicationList,
linc => linc.IsCatalog,
linc => linc.IsSiteAssetsLibrary,
linc => linc.IsPrivate,
linc => linc.IsSystemList,
lctx => lctx.SchemaXml).Where(w => !w.IsSystemList && !w.IsSiteAssetsLibrary));
this.ClientContext.ExecuteQueryRetry();
var weburl = TokenHelper.EnsureTrailingSlash(contextWeb.ServerRelativeUrl);
if (groupQuery.Any())
{
SiteComponents.Groups = new List <SPGroupDefinitionModel>();
foreach (var group in groupQuery)
{
var model = new SPGroupDefinitionModel()
{
Id = group.Id,
Title = group.Title,
Description = group.Description,
AllowRequestToJoinLeave = group.AllowRequestToJoinLeave,
AllowMembersEditMembership = group.AllowMembersEditMembership,
AutoAcceptRequestToJoinLeave = group.AutoAcceptRequestToJoinLeave,
OnlyAllowMembersViewMembership = group.OnlyAllowMembersViewMembership,
RequestToJoinLeaveEmailSetting = group.RequestToJoinLeaveEmailSetting
};
SiteComponents.Groups.Add(model);
}
}
if (fields.Any())
{
var webfields = new List <SPFieldDefinitionModel>();
foreach (var field in fields)
{
if (skiptypes.Any(st => field.FieldTypeKind == st) ||
skipcolumns.Any(sg => field.Group.Equals(sg, StringComparison.CurrentCultureIgnoreCase)))
{
continue;
}
try
{
var fieldModel = ClientContext.RetrieveField(field, logger, groupQuery);
webfields.Add(fieldModel);
}
catch (Exception ex)
{
System.Diagnostics.Trace.TraceError("Failed to parse field {0} MSG:{1}", field.InternalName, ex.Message);
}
}
SiteComponents.FieldDefinitions = webfields;
}
var contentTypesFieldset = new List <dynamic>();
if (contentTypes.Any())
{
SiteComponents.ContentTypes = new List <SPContentTypeDefinition>();
foreach (ContentType contenttype in contentTypes)
{
// skip core content types
if (skipcontenttypes.Any(sg => contenttype.Group.Equals(sg, StringComparison.CurrentCultureIgnoreCase)))
{
continue;
}
contenttype.EnsureProperties(ctp => ctp.Id, ctp => ctp.Group, ctp => ctp.Hidden, ctp => ctp.Description, ctp => ctp.Name, ctp => ctp.FieldLinks);
var ctypemodel = new SPContentTypeDefinition()
{
ContentTypeId = contenttype.Id.StringValue,
ContentTypeGroup = contenttype.Group,
Hidden = contenttype.Hidden,
Description = contenttype.Description,
Name = contenttype.Name
};
if (contenttype.FieldLinks.Any())
{
ctypemodel.FieldLinks = new List <SPFieldLinkDefinitionModel>();
foreach (FieldLink fieldlink in contenttype.FieldLinks)
{
ctypemodel.FieldLinks.Add(new SPFieldLinkDefinitionModel()
{
Id = fieldlink.Id,
Name = fieldlink.Name,
Required = fieldlink.Required,
Hidden = fieldlink.Hidden
});
contentTypesFieldset.Add(new { ctypeid = contenttype.Id.StringValue, name = fieldlink.Name });
}
}
SiteComponents.ContentTypes.Add(ctypemodel);
}
}
if (lists.Any())
{
var sitelists = new List <SPListDefinition>();
foreach (List list in lists.Where(lwt =>
(!_filterLists ||
(_filterLists && SpecificLists.Any(sl => lwt.Title.Equals(sl, StringComparison.InvariantCultureIgnoreCase))))))
{
var listdefinition = ClientContext.GetListDefinition(contextWeb, list, true, logger, skiptypes, groupQuery);
sitelists.Add(listdefinition);
}
if (sitelists.Any())
{
var idx = 0;
SiteComponents.Lists = new List <SPListDefinition>();
// lets add any list with NO lookups first
var nolookups = sitelists.Where(sl => !sl.ListDependency.Any());
nolookups.ToList().ForEach(nolookup =>
{
logger.LogInformation("adding list {0}", nolookup.ListName);
nolookup.ProvisionOrder = idx++;
SiteComponents.Lists.Add(nolookup);
sitelists.Remove(nolookup);
});
// order with first in stack
var haslookups = sitelists.Where(sl => sl.ListDependency.Any()).OrderBy(ob => ob.ListDependency.Count()).ToList();
while (haslookups.Count() > 0)
{
var listPopped = haslookups.FirstOrDefault();
haslookups.Remove(listPopped);
logger.LogInformation("adding list {0}", listPopped.ListName);
if (listPopped.ListDependency.Any(listField => listPopped.ListName.Equals(listField, StringComparison.InvariantCultureIgnoreCase) ||
listPopped.InternalName.Equals(listField, StringComparison.InvariantCultureIgnoreCase)))
{
// the list has a dependency on itself
logger.LogInformation("Adding list {0} with dependency on itself", listPopped.ListName);
listPopped.ProvisionOrder = idx++;
SiteComponents.Lists.Add(listPopped);
}
else if (listPopped.ListDependency.Any(listField =>
!SiteComponents.Lists.Any(sc => sc.ListName.Equals(listField, StringComparison.InvariantCultureIgnoreCase) ||
sc.InternalName.Equals(listField, StringComparison.InvariantCultureIgnoreCase))))
{
// no list definition exists in the collection with the dependent lookup lists
logger.LogWarning("List {0} depends on {1} which do not exist current collection", listPopped.ListName, string.Join(",", listPopped.ListDependency));
foreach (var dependent in listPopped.ListDependency.Where(dlist => !haslookups.Any(hl => hl.ListName == dlist)))
{
var sitelist = contextWeb.GetListByTitle(dependent, lctx => lctx.Id, lctx => lctx.Title, lctx => lctx.RootFolder.ServerRelativeUrl);
var listDefinition = ClientContext.GetListDefinition(contextWeb, sitelist, true, logger, skiptypes, groupQuery);
haslookups.Add(listDefinition);
}
haslookups.Add(listPopped); // add back to collection
listPopped = null;
}
else
{
logger.LogInformation("Adding list {0} to collection", listPopped.ListName);
listPopped.ProvisionOrder = idx++;
SiteComponents.Lists.Add(listPopped);
}
}
}
}
// Write the JSON to disc
var jsonsettings = new JsonSerializerSettings()
{
Formatting = Formatting.Indented,
Culture = System.Globalization.CultureInfo.CurrentUICulture,
DateFormatHandling = DateFormatHandling.IsoDateFormat,
NullValueHandling = NullValueHandling.Ignore
};
var json = JsonConvert.SerializeObject(SiteComponents, jsonsettings);
System.IO.File.WriteAllText(fileInfo.FullName, json);
}