/// <summary>
/// Determines if the column is a lookup
/// </summary>
/// <param name="List"></param>
/// <param name="ColumnName"></param>
/// <returns></returns>
static bool IsUser(SPListDefinition List, string ColumnName)
{
foreach (var spc in List.FieldDefinitions
.Where(sfield => sfield.InternalName.Equals(ColumnName, StringComparison.CurrentCultureIgnoreCase) && sfield.FieldTypeKind == FieldType.User))
{
return(true);
}
return(false);
}
/// <summary>
/// Determines if the column is a lookup
/// </summary>
/// <param name="List"></param>
/// <param name="ColumnName"></param>
/// <param name="LookupListName"></param>
/// <returns></returns>
static bool IsLookup(SPListDefinition List, string ColumnName, out SPFieldDefinitionModel LookupField)
{
LookupField = null;
foreach (var spc in List.FieldDefinitions
.Where(sfield => sfield.InternalName.Equals(ColumnName, StringComparison.CurrentCultureIgnoreCase) && sfield.FieldTypeKind == FieldType.Lookup))
{
LookupField = spc;
return(true);
}
return(false);
}
private SPListDefinition GetSampleLibrary()
{
var newList = new SPListDefinition()
{
ListName = "Sample 01 File Upload",
ListDescription = "Sample library for uploading files.",
ListTemplate = ListTemplateType.GenericList,
QuickLaunch = QuickLaunchOptions.On,
Versioning = false,
FieldDefinitions = GetSampleFields()
};
return(newList);
}
private SPListDefinition GetSampleLibrary()
{
var newList = new SPListDefinition()
{
ListName = "Sample Version History",
ListDescription = "Sample Version History for demonstrating version history and append changes.",
ListTemplate = ListTemplateType.GenericList,
QuickLaunch = QuickLaunchOptions.On,
Versioning = true,
FieldDefinitions = GetSampleFields()
};
return(newList);
}
/// <summary>
/// Provision a list to the specified web using the list definition
/// </summary>
/// <param name="web">Client Context web</param>
/// <param name="listDef">Hydrated list definition from JSON or Object</param>
/// <param name="loggerVerbose">TODO: convert to static logger</param>
/// <param name="loggerWarning">TODO: convert to static logger</param>
/// <param name="loggerError">TODO: convert to static logger</param>
/// <param name="SiteGroups">Collection of provisioned SharePoint group for field definitions</param>
/// <param name="JsonFilePath">(OPTIONAL) file path to JSON folder</param>
public static void CreateListFromDefinition(this Web web, SPListDefinition listDef, Action <string, string[]> loggerVerbose, Action <string, string[]> loggerWarning, Action <Exception, string, string[]> loggerError, List <SPGroupDefinitionModel> SiteGroups = null, string JsonFilePath = null)
{
var webContext = web.Context;
var siteColumns = new List <SPFieldDefinitionModel>();
var afterProvisionChanges = false;
// Content Type
var listName = listDef.ListName;
var listDescription = listDef.ListDescription;
// check to see if Picture library named Photos already exists
ListCollection allLists = web.Lists;
IEnumerable <List> foundLists = webContext.LoadQuery(allLists.Where(list => list.Title == listName)
.Include(arl => arl.Title, arl => arl.Id, arl => arl.ContentTypes, ol => ol.RootFolder, ol => ol.EnableVersioning, ol => ol.EnableFolderCreation, ol => ol.ContentTypesEnabled));
webContext.ExecuteQueryRetry();
List listToProvision = foundLists.FirstOrDefault();
if (listToProvision == null)
{
ListCreationInformation listToProvisionInfo = listDef.ToCreationObject();
listToProvision = web.Lists.Add(listToProvisionInfo);
webContext.Load(listToProvision, arl => arl.Title, arl => arl.Id, arl => arl.ContentTypes, ol => ol.RootFolder, ol => ol.EnableVersioning, ol => ol.EnableFolderCreation, ol => ol.ContentTypesEnabled);
webContext.ExecuteQuery();
}
if (listDef.Versioning && !listToProvision.EnableVersioning)
{
afterProvisionChanges = true;
listToProvision.EnableVersioning = true;
if (listDef.ListTemplate == ListTemplateType.DocumentLibrary)
{
listToProvision.EnableMinorVersions = true;
}
}
if (listDef.ContentTypeEnabled && !listToProvision.ContentTypesEnabled)
{
afterProvisionChanges = true;
listToProvision.ContentTypesEnabled = true;
}
if (listDef.EnableFolderCreation && !listToProvision.EnableFolderCreation)
{
afterProvisionChanges = true;
listToProvision.EnableFolderCreation = true;
}
if (afterProvisionChanges)
{
listToProvision.Update();
webContext.Load(listToProvision);
webContext.ExecuteQueryRetry();
}
webContext.Load(listToProvision, arl => arl.Title, arl => arl.Id, arl => arl.ContentTypes, ol => ol.RootFolder, ol => ol.EnableVersioning, ol => ol.EnableFolderCreation, ol => ol.ContentTypesEnabled);
webContext.ExecuteQuery();
if (listDef.ContentTypeEnabled && listDef.HasContentTypes)
{
foreach (var contentDef in listDef.ContentTypes)
{
if (!listToProvision.ContentTypeExistsByName(contentDef.Name))
{
var ctypeInfo = contentDef.ToCreationObject();
var accessContentType = listToProvision.ContentTypes.Add(ctypeInfo);
listToProvision.Update();
webContext.Load(accessContentType, tycp => tycp.Id, tycp => tycp.Name);
webContext.ExecuteQueryRetry();
if (contentDef.DefaultContentType)
{
listToProvision.SetDefaultContentTypeToList(accessContentType);
}
}
}
}
// Site Columns
foreach (var fieldDef in listDef.FieldDefinitions)
{
var column = listToProvision.CreateListColumn(fieldDef, loggerVerbose, loggerWarning, SiteGroups, JsonFilePath);
if (column == null)
{
loggerWarning("Failed to create column {0}.", new string[] { fieldDef.InternalName });
}
else
{
siteColumns.Add(new SPFieldDefinitionModel()
{
InternalName = column.InternalName,
DisplayName = column.Title,
FieldGuid = column.Id
});
}
}
if (listDef.ContentTypeEnabled && listDef.HasContentTypes)
{
foreach (var contentDef in listDef.ContentTypes)
{
var contentTypeName = contentDef.Name;
var accessContentTypes = listToProvision.ContentTypes;
IEnumerable <ContentType> allContentTypes = webContext.LoadQuery(accessContentTypes.Where(f => f.Name == contentTypeName).Include(tcyp => tcyp.Id, tcyp => tcyp.Name));
webContext.ExecuteQueryRetry();
if (allContentTypes != null)
{
var accessContentType = allContentTypes.FirstOrDefault();
foreach (var fieldInternalName in contentDef.FieldLinkRefs)
{
var column = siteColumns.FirstOrDefault(f => f.InternalName == fieldInternalName);
if (column != null)
{
var fieldLinks = accessContentType.FieldLinks;
webContext.Load(fieldLinks, cf => cf.Include(inc => inc.Id, inc => inc.Name));
webContext.ExecuteQueryRetry();
var convertedInternalName = column.DisplayNameMasked;
if (!fieldLinks.Any(a => a.Name == column.InternalName || a.Name == convertedInternalName))
{
loggerVerbose("Content Type {0} Adding Field {1}", new string[] { contentTypeName, column.InternalName });
var siteColumn = listToProvision.GetFieldById <Field>(column.FieldGuid);
webContext.ExecuteQueryRetry();
var flink = new FieldLinkCreationInformation();
flink.Field = siteColumn;
var flinkstub = accessContentType.FieldLinks.Add(flink);
//if(fieldDef.Required) flinkstub.Required = fieldDef.Required;
accessContentType.Update(false);
webContext.ExecuteQueryRetry();
}
}
else
{
loggerWarning("Failed to create column {0}.", new string[] { fieldInternalName });
}
}
}
}
}
// Views
if (listDef.Views != null && listDef.Views.Count() > 0)
{
ViewCollection views = listToProvision.Views;
webContext.Load(views, f => f.Include(inc => inc.Id, inc => inc.Hidden, inc => inc.Title, inc => inc.DefaultView));
webContext.ExecuteQueryRetry();
foreach (var viewDef in listDef.Views)
{
try
{
if (views.Any(v => v.Title.Equals(viewDef.Title, StringComparison.CurrentCultureIgnoreCase)))
{
loggerVerbose("View {0} found in list {1}", new string[] { viewDef.Title, listName });
continue;
}
var view = listToProvision.CreateView(viewDef.InternalName, viewDef.ViewCamlType, viewDef.FieldRefName, viewDef.RowLimit, viewDef.DefaultView, viewDef.QueryXml, viewDef.PersonalView, viewDef.PagedView);
webContext.Load(view, v => v.Title, v => v.Id, v => v.ServerRelativeUrl);
webContext.ExecuteQueryRetry();
view.Title = viewDef.Title;
if (viewDef.HasJsLink)
{
view.JSLink = viewDef.JsLink;
}
view.Update();
webContext.ExecuteQueryRetry();
}
catch (Exception ex)
{
loggerError(ex, "Failed to create view {0} with XML:{1}", new string[] { viewDef.Title, viewDef.QueryXml });
}
}
}
// List Data upload
if (listDef.ListItems != null && listDef.ListItems.Count() > 0)
{
foreach (var listItem in listDef.ListItems)
{
// Process the record into the notification email list
var itemCreateInfo = new ListItemCreationInformation();
var newSPListItem = listToProvision.AddItem(itemCreateInfo);
newSPListItem["Title"] = listItem.Title;
foreach (var listItemData in listItem.ColumnValues)
{
newSPListItem[listItemData.FieldName] = listItemData.FieldValue;
}
newSPListItem.Update();
webContext.ExecuteQueryRetry();
}
}
}
/// <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);
}
/// <summary>
/// Provision a list to the specified web using the list definition
/// </summary>
/// <param name="web">Client Context web</param>
/// <param name="listDefinition">Hydrated list definition from JSON or Object</param>
/// <param name="provisionerChoices">(OPTIONAL) deserialized choices from JSON</param>
public static List CreateListFromDefinition(this Web web, SPListDefinition listDefinition, List <SiteProvisionerFieldChoiceModel> provisionerChoices = null)
{
var webContext = web.Context;
var siteColumns = new List <SPFieldDefinitionModel>();
var afterProvisionChanges = false;
// Content Type
var listName = listDefinition.ListName;
var listDescription = listDefinition.ListDescription;
// check to see if Picture library named Photos already exists
ListCollection allLists = web.Lists;
IEnumerable <List> foundLists = webContext.LoadQuery(allLists.Where(list => list.Title == listName)
.Include(arl => arl.Title, arl => arl.Id, arl => arl.ContentTypes, ol => ol.RootFolder, ol => ol.EnableVersioning, ol => ol.EnableFolderCreation, ol => ol.ContentTypesEnabled));
webContext.ExecuteQueryRetry();
List listToProvision = foundLists.FirstOrDefault();
if (listToProvision == null)
{
ListCreationInformation listToProvisionInfo = listDefinition.ToCreationObject();
listToProvision = web.Lists.Add(listToProvisionInfo);
webContext.Load(listToProvision, arl => arl.Title, arl => arl.Id, arl => arl.ContentTypes, ol => ol.RootFolder, ol => ol.EnableVersioning, ol => ol.EnableFolderCreation, ol => ol.ContentTypesEnabled);
webContext.ExecuteQuery();
}
if (listDefinition.Versioning && !listToProvision.EnableVersioning)
{
afterProvisionChanges = true;
listToProvision.EnableVersioning = true;
if (listDefinition.ListTemplate == ListTemplateType.DocumentLibrary)
{
listToProvision.EnableMinorVersions = true;
}
}
if (listDefinition.ContentTypeEnabled && !listToProvision.ContentTypesEnabled)
{
afterProvisionChanges = true;
listToProvision.ContentTypesEnabled = true;
}
if (listDefinition.EnableFolderCreation && !listToProvision.EnableFolderCreation)
{
afterProvisionChanges = true;
listToProvision.EnableFolderCreation = true;
}
if (afterProvisionChanges)
{
listToProvision.Update();
webContext.Load(listToProvision);
webContext.ExecuteQueryRetry();
}
webContext.Load(listToProvision, arl => arl.Title, arl => arl.Id, arl => arl.ContentTypes, ol => ol.RootFolder, ol => ol.EnableVersioning, ol => ol.EnableFolderCreation, ol => ol.ContentTypesEnabled);
webContext.ExecuteQueryRetry();
return(listToProvision);
}
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);
}
