public override void WithResolvingModelHost(ModelHostResolveContext modelHostContext)
{
var modelHost = modelHostContext.ModelHost;
var model = modelHostContext.Model;
var childModelType = modelHostContext.ChildModelType;
var action = modelHostContext.Action;
var siteModelHost = modelHost.WithAssertAndCast <SiteModelHost>("model", value => value.RequireNotNull());
var termStoreModel = model.WithAssertAndCast <TaxonomyTermStoreDefinition>("model", value => value.RequireNotNull());
var termStore = FindTermStore(siteModelHost, termStoreModel);
var termStoreModelHost = ModelHostBase.Inherit <TermStoreModelHost>(siteModelHost, context =>
{
context.HostTermStore = termStore;
});
action(termStoreModelHost);
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Calling termStore.CommitAll()");
termStore.CommitAll();
termStore.Context.ExecuteQueryWithTrace();
}
public override void RetractModel(ModelHostBase modelHost, ModelNode model)
{
if (!(modelHost is SSOMModelHostBase))
throw new ArgumentException("model host for SSOM needs to be inherited from SSOMModelHostBase.");
base.RetractModel(modelHost, model);
}
public override IEnumerable <ReverseHostBase> ReverseHosts(ReverseHostBase parentHost, ReverseOptions options)
{
var result = new List <ListReverseHost>();
var typedHost = parentHost.WithAssertAndCast <WebReverseHost>("reverseHost", value => value.RequireNotNull());
var site = typedHost.HostSite;
var web = typedHost.HostWeb;
var context = typedHost.HostClientContext;
var items = web.Lists;
//context.Load(items, i => i.Include(r => r.RootFolder, r => r.RootFolder.Properties));
context.Load(items,
i => i.Include(r => r.RootFolder,
r => r.Title,
r => r.Description,
r => r.Hidden,
r => r.BaseTemplate,
r => r.ContentTypesEnabled)
);
context.ExecuteQueryWithTrace();
result.AddRange(ApplyReverseFilters(items, options).ToArray().Select(i =>
{
return(ModelHostBase.Inherit <ListReverseHost>(parentHost, h =>
{
h.HostList = i;
}));
}));
return(result);
}
public override void WithResolvingModelHost(ModelHostResolveContext modelHostContext)
{
var modelHost = modelHostContext.ModelHost;
var model = modelHostContext.Model;
var childModelType = modelHostContext.ChildModelType;
var action = modelHostContext.Action;
var webApplicationDefinition = model.WithAssertAndCast <WebApplicationDefinition>("model", value => value.RequireNotNull());
if (modelHost is WebApplicationModelHost)
{
base.WithResolvingModelHost(modelHostContext);
return;
}
var farmModelHost = modelHost.WithAssertAndCast <FarmModelHost>("modelHost", value => value.RequireNotNull());
var webApps = SPWebService.ContentService.WebApplications;
var existingWebApp = FindWebApplication(webApplicationDefinition, webApps);
if (existingWebApp == null)
{
throw new SPMeta2Exception(string.Format(
"Cannot find web aplication by definition:[]",
webApplicationDefinition));
}
var webAppModelHost = ModelHostBase.Inherit <WebApplicationModelHost>(farmModelHost, h =>
{
h.HostWebApplication = existingWebApp;
});
action(webAppModelHost);
}
public override IEnumerable <ReverseHostBase> ReverseHosts(ReverseHostBase parentHost, ReverseOptions options)
{
var result = new List <TaxonomyTermStoreReverseHost>();
var typedHost = parentHost.WithAssertAndCast <SiteReverseHost>("reverseHost", value => value.RequireNotNull());
var context = typedHost.HostClientContext;
var site = typedHost.HostSite;
var session = TaxonomySession.GetTaxonomySession(context);
var termStore = session.GetDefaultSiteCollectionTermStore();
context.Load(site);
context.Load(termStore);
context.ExecuteQueryWithTrace();
result.AddRange(ApplyReverseFilters(new[] { site }, options).ToArray().Select(i =>
{
return(ModelHostBase.Inherit <TaxonomyTermStoreReverseHost>(parentHost, h =>
{
h.HostTermStore = termStore;
}));
}));
return(result);
}
/// <summary>
/// A shortcut for incremental provision
/// Sets incremental provision mode with IncrementalProvisionConfig.AutoDetectSharePointPersistenceStorage = true
/// Once done, reverts back to default provision mode
/// Callback on IncrementalProvisionConfig makes it easy to configure IncrementalProvisionConfig instance
/// </summary>
/// <param name="provisionService"></param>
/// <param name="modelHost"></param>
/// <param name="model"></param>
/// <param name="incrementalModelId"></param>
/// <param name="config"></param>
public static void DeployModelIncrementally(this ProvisionServiceBase provisionService,
ModelHostBase modelHost,
ModelNode model,
string incrementalModelId,
Action <IncrementalProvisionConfig> config)
{
try
{
var incrementalProvisionConfig = new IncrementalProvisionConfig
{
AutoDetectSharePointPersistenceStorage = true
};
if (config != null)
{
config(incrementalProvisionConfig);
}
provisionService.SetIncrementalProvisionMode(incrementalProvisionConfig);
model.InternalSetIncrementalProvisionModelId(incrementalModelId);
provisionService.DeployModel(modelHost, model);
}
finally
{
provisionService.SetDefaultProvisionMode();
}
}
public override void DeployModel(ModelHostBase modelHost, ModelNode model)
{
var defaultTraserveService = ServiceContainer.Instance.GetService <ModelTreeTraverseServiceBase>();
defaultTraserveService.OnModelHandlerResolve += ResolveDefaultModelHandler;
defaultTraserveService.Traverse(modelHost, model);
}
public override IEnumerable <ReverseHostBase> ReverseHosts(ReverseHostBase parentHost, ReverseOptions options)
{
var result = new List <ListReverseHost>();
var typedHost = parentHost.WithAssertAndCast <ListReverseHost>("reverseHost", value => value.RequireNotNull());
var list = typedHost.HostList;
var context = typedHost.HostClientContext;
var folder = list.RootFolder;
context.Load(list);
context.Load(list, l => l.ContentTypes);
context.Load(folder);
context.Load(folder, f => f.UniqueContentTypeOrder);
context.ExecuteQueryWithTrace();
result.AddRange(ApplyReverseFilters(new[] { list }, options).ToArray().Select(i =>
{
return(ModelHostBase.Inherit <ListReverseHost>(parentHost, h =>
{
h.HostList = i;
}));
}));
return(result);
}
public override void WithResolvingModelHost(ModelHostResolveContext modelHostContext)
{
var modelHost = modelHostContext.ModelHost;
var model = modelHostContext.Model;
var childModelType = modelHostContext.ChildModelType;
var action = modelHostContext.Action;
var storeModelHost = modelHost.WithAssertAndCast <TermStoreModelHost>("modelHost", value => value.RequireNotNull());
var groupModel = model.WithAssertAndCast <TaxonomyTermGroupDefinition>("model", value => value.RequireNotNull());
var context = storeModelHost.HostClientContext;
var termStore = storeModelHost.HostTermStore;
var currentGroup = FindGroup(storeModelHost, groupModel);
if (currentGroup == null && IsSharePointOnlineContext(context))
{
TryRetryService.TryWithRetry(() =>
{
currentGroup = FindGroup(storeModelHost, groupModel);
return(currentGroup != null);
});
}
if (currentGroup == null)
{
throw new SPMeta2Exception(string.Format("Cannot find a taxonomy group after provision"));
}
action(ModelHostBase.Inherit <TermGroupModelHost>(storeModelHost, host =>
{
host.HostTermStore = termStore;
host.HostGroup = currentGroup;
}));
}
public override IEnumerable <ReverseHostBase> ReverseHosts(ReverseHostBase parentHost, ReverseOptions options)
{
var result = new List <TaxonomyTermSetReverseHost>();
var typedHost = parentHost.WithAssertAndCast <TaxonomyTermGroupReverseHost>("reverseHost", value => value.RequireNotNull());
var context = typedHost.HostClientContext;
var site = typedHost.HostSite;
var termGroup = typedHost.HostTermGroup;
var items = termGroup.TermSets;
context.Load(items);
context.ExecuteQueryWithTrace();
result.AddRange(ApplyReverseFilters(items, options).ToArray().Select(i =>
{
return(ModelHostBase.Inherit <TaxonomyTermSetReverseHost>(parentHost, h =>
{
h.HostTermSet = i;
}));
}));
return(result);
}
public override void WithResolvingModelHost(object modelHost, DefinitionBase model, Type childModelType, Action <object> action)
{
var quickLaunchNode = model as NavigationNodeDefinitionBase;
if (modelHost is WebModelHost)
{
var webModelHost = modelHost as WebModelHost;
var currentNode = EnsureRootNavigationNode(webModelHost, quickLaunchNode);
var nodeHost = ModelHostBase.Inherit <NavigationNodeModelHost>(webModelHost, host =>
{
host.HostNavigationNode = currentNode;
});
action(nodeHost);
}
else if (modelHost is NavigationNodeModelHost)
{
var nodeModelHost = modelHost as NavigationNodeModelHost;
var currentNode = EnsureNavigationNode(nodeModelHost, quickLaunchNode);
var nodeHost = ModelHostBase.Inherit <NavigationNodeModelHost>(nodeModelHost, host =>
{
host.HostNavigationNode = currentNode;
});
action(nodeHost);
}
else
{
action(modelHost);
}
}
/// <summary>
/// A shortcut for incremental provision
/// Sets incremental provision mode with AutoDetectSharePointPersistenceStorage = true
/// Once done, reverts back to default provision mode
/// </summary>
/// <param name="provisionService"></param>
/// <param name="modelHost"></param>
/// <param name="model"></param>
/// <param name="incrementalModelId"></param>
public static void DeployModelIncrementally(this ProvisionServiceBase provisionService,
ModelHostBase modelHost,
ModelNode model,
string incrementalModelId)
{
DeployModelIncrementally(provisionService, modelHost, model, incrementalModelId, null);
}
public override IEnumerable <ReverseHostBase> ReverseHosts(ReverseHostBase parentHost, ReverseOptions options)
{
var result = new List <ContentTypeReverseHost>();
var typedHost = parentHost.WithAssertAndCast <ContentTypeReverseHost>("reverseHost", value => value.RequireNotNull());
var contentType = typedHost.HostContentType;
var context = typedHost.HostClientContext;
var item = contentType;
context.Load(item);
context.Load(item, i => i.Fields);
context.Load(item, i => i.FieldLinks);
context.ExecuteQueryWithTrace();
result.AddRange(ApplyReverseFilters(new[] { item }, options).ToArray().Select(i =>
{
return(ModelHostBase.Inherit <ContentTypeReverseHost>(parentHost, h =>
{
h.HostContentType = i;
}));
}));
return(result);
}
public override void WithResolvingModelHost(object modelHost, DefinitionBase model, Type childModelType, Action <object> action)
{
var webModelHost = modelHost.WithAssertAndCast <WebModelHost>("modelHost", value => value.RequireNotNull());
var webModel = model.WithAssertAndCast <WebDefinition>("model", value => value.RequireNotNull());
var parentWeb = GetParentWeb(webModelHost);
var context = parentWeb.Context;
context.Load(parentWeb, w => w.RootFolder);
context.Load(parentWeb, w => w.ServerRelativeUrl);
context.ExecuteQuery();
var currentWebUrl = GetCurrentWebUrl(context, parentWeb, webModel);
using (var webContext = new ClientContext(currentWebUrl))
{
var tmpWebContext = webContext;
webContext.Credentials = context.Credentials;
var tmpWebModelHost = ModelHostBase.Inherit <WebModelHost>(webModelHost,
webHost =>
{
webHost.HostWeb = tmpWebContext.Web;
});
action(tmpWebModelHost);
}
}
public override void WithResolvingModelHost(object modelHost, DefinitionBase model, Type childModelType, Action <object> action)
{
var folderModelHost = modelHost.WithAssertAndCast <FolderModelHost>("modelHost", value => value.RequireNotNull());
var wikiPageModel = model.WithAssertAndCast <WikiPageDefinition>("model", value => value.RequireNotNull());
var web = folderModelHost.CurrentList.ParentWeb;
var folder = folderModelHost.CurrentLibraryFolder;
var currentPage = GetWikiPageFile(web, folder, wikiPageModel);
var context = folder.Context;
var currentListItem = currentPage.ListItemAllFields;
context.Load(currentListItem);
context.ExecuteQueryWithTrace();
if (typeof(WebPartDefinitionBase).IsAssignableFrom(childModelType))
{
var listItemHost = ModelHostBase.Inherit <ListItemModelHost>(folderModelHost, itemHost =>
{
itemHost.HostListItem = currentListItem;
});
action(listItemHost);
}
context.ExecuteQueryWithTrace();
}
public override void DeployModel(ModelHostBase modelHost, ModelNode model)
{
if (!(modelHost is CSOMModelHostBase))
throw new ArgumentException("model host for CSOM needs to be inherited from CSOMModelHostBase");
base.DeployModel(modelHost, model);
}
public override IEnumerable <ReverseHostBase> ReverseHosts(ReverseHostBase parentHost, ReverseOptions options)
{
var result = new List <FieldReverseHost>();
var siteHost = parentHost as SiteReverseHost;
var webHost = parentHost as WebReverseHost;
var site = siteHost.HostSite;
var context = siteHost.HostClientContext;
FieldCollection items = null;
if (webHost != null)
{
items = webHost.HostWeb.Fields;
}
else
{
items = siteHost.HostSite.RootWeb.Fields;
}
var typedItems = GetTypedFields(context, items);
result.AddRange(ApplyReverseFilters(typedItems, options).ToArray().Select(i =>
{
return(ModelHostBase.Inherit <FieldReverseHost>(parentHost, h =>
{
h.Field = i;
}));
}));
return(result);
}
public override IEnumerable <ReverseHostBase> ReverseHosts(ReverseHostBase parentHost, ReverseOptions options)
{
var result = new List <PropertyReverseHost>();
PropertyValues items = null;
if (parentHost is ListReverseHost)
{
items = (parentHost as ListReverseHost).HostList.RootFolder.Properties;
}
else if (parentHost is WebReverseHost)
{
items = (parentHost as WebReverseHost).HostWeb.AllProperties;
}
else if (parentHost is SiteReverseHost)
{
items = (parentHost as SiteReverseHost).HostSite.RootWeb.AllProperties;
}
var context = (parentHost as CSOMReverseHostBase).HostClientContext;
context.Load(items);
context.ExecuteQueryWithTrace();
result.AddRange(ApplyReverseFilters(items.FieldValues.Keys, options).ToArray().Select(i =>
{
return(ModelHostBase.Inherit <PropertyReverseHost>(parentHost, h =>
{
h.HostPropertyName = i;
h.HostPropertyValue = items[i];
}));
}));
return(result);
}
public override IEnumerable <ReverseHostBase> ReverseHosts(ReverseHostBase parentHost, ReverseOptions options)
{
var result = new List <WelcomePageReverseHost>();
Folder hostFolder = null;
if (parentHost is FolderReverseHost)
{
hostFolder = (parentHost as FolderReverseHost).HostFolder;
}
else if (parentHost is ListReverseHost)
{
hostFolder = (parentHost as ListReverseHost).HostList.RootFolder;
}
else if (parentHost is WebReverseHost)
{
hostFolder = (parentHost as WebReverseHost).HostWeb.RootFolder;
}
var context = (parentHost as CSOMReverseHostBase).HostClientContext;
context.Load(hostFolder);
context.ExecuteQueryWithTrace();
result.AddRange(ApplyReverseFilters(new[] { hostFolder }, options).ToArray().Select(i =>
{
return(ModelHostBase.Inherit <WelcomePageReverseHost>(parentHost, h =>
{
h.HostFolder = i;
}));
}));
return(result);
}
public override IEnumerable <ReverseHostBase> ReverseHosts(ReverseHostBase parentHost, ReverseOptions options)
{
var result = new List <SandboxSolutionReverseHost>();
var typedHost = parentHost.WithAssertAndCast <SiteReverseHost>("reverseHost", value => value.RequireNotNull());
var site = typedHost.HostSite;
var context = typedHost.HostClientContext;
var solutionList = site.RootWeb.GetCatalog((int)ListTemplateType.SolutionCatalog);
var items = solutionList.RootFolder.Files;
context.Load(items, i => i.Include(f => f.Name,
f => f.ServerRelativeUrl,
f => f.ListItemAllFields));
context.ExecuteQueryWithTrace();
result.AddRange(ApplyReverseFilters(items, options).ToArray().Select(i =>
{
return(ModelHostBase.Inherit <SandboxSolutionReverseHost>(parentHost, h =>
{
h.HostSandboxSolutionFile = i;
}));
}));
return(result);
}
public override void WithResolvingModelHost(object modelHost, DefinitionBase model, Type childModelType, Action <object> action)
{
var folderModelHost = modelHost as FolderModelHost;
var webPartPageDefinition = model as WebPartPageDefinition;
Folder folder = folderModelHost.CurrentLibraryFolder;
if (folder != null && webPartPageDefinition != null)
{
var context = folder.Context;
var currentPage = GetCurrentWebPartPage(folderModelHost.CurrentList, folder, GetSafeWebPartPageFileName(webPartPageDefinition));
var currentListItem = currentPage.ListItemAllFields;
context.Load(currentListItem);
context.ExecuteQueryWithTrace();
if (typeof(WebPartDefinitionBase).IsAssignableFrom(childModelType))
{
var listItemHost = ModelHostBase.Inherit <ListItemModelHost>(folderModelHost, itemHost =>
{
itemHost.HostListItem = currentListItem;
});
action(listItemHost);
//currentListItem.Update();
}
context.ExecuteQueryWithTrace();
}
else
{
action(modelHost);
}
}
public override void WithResolvingModelHost(ModelHostResolveContext modelHostContext)
{
var modelHost = modelHostContext.ModelHost as ModelHostBase;
var model = modelHostContext.Model;
var childModelType = modelHostContext.ChildModelType;
var action = modelHostContext.Action;
var listModelHost = modelHost.WithAssertAndCast <ListModelHost>("modelHost", value => value.RequireNotNull());
var contentTypeLinkModel = model.WithAssertAndCast <ContentTypeLinkDefinition>("model", value => value.RequireNotNull());
var list = listModelHost.HostList;
var contentType = list.ContentTypes[contentTypeLinkModel.ContentTypeName];
var contentTypeLinkHost = ModelHostBase.Inherit <ContentTypeLinkModelHost>(modelHost, host =>
{
host.HostContentType = contentType;
host.HostList = list;
});
action(contentTypeLinkHost);
if (contentTypeLinkHost.ShouldUpdateHost)
{
if (!contentType.ReadOnly)
{
contentType.Update(false);
}
}
}
public override void WithResolvingModelHost(ModelHostResolveContext modelHostContext)
{
var modelHost = modelHostContext.ModelHost;
var model = modelHostContext.Model;
var childModelType = modelHostContext.ChildModelType;
var action = modelHostContext.Action;
var folderModelHost = modelHost as FolderModelHost;
var definition = model as PublishingPageDefinition;
Folder folder = folderModelHost.CurrentListFolder;
if (folder != null && definition != null)
{
var context = folder.Context;
var currentPage = GetCurrentPage(folderModelHost.CurrentList, folder, GetSafePageFileName(definition));
if (typeof(WebPartDefinitionBase).IsAssignableFrom(childModelType) ||
childModelType == typeof(DeleteWebPartsDefinition))
{
var listItemHost = ModelHostBase.Inherit <ListItemModelHost>(folderModelHost, itemHost =>
{
itemHost.HostFile = currentPage;
itemHost.HostList = folderModelHost.CurrentList;
});
action(listItemHost);
//currentListItem.Update();
}
else if (typeof(BreakRoleInheritanceDefinition).IsAssignableFrom(childModelType) ||
typeof(SecurityGroupLinkDefinition).IsAssignableFrom(childModelType))
{
var currentListItem = currentPage.ListItemAllFields;
context.Load(currentListItem);
context.ExecuteQueryWithTrace();
var listItemHost = ModelHostBase.Inherit <ListItemModelHost>(folderModelHost, itemHost =>
{
itemHost.HostListItem = currentListItem;
});
action(listItemHost);
}
else
{
action(currentPage);
}
//context.ExecuteQueryWithTrace();
}
else
{
action(modelHost);
}
}
public override void DeployModel(ModelHostBase modelHost, ModelNode model)
{
if (!(modelHost is SSOMModelHostBase))
{
throw new ArgumentException("modelHost for SSOM needs to be inherited from SSOMModelHostBase.");
}
base.DeployModel(modelHost, model);
}
public static void DeployListModel(this SSOMProvisionService modelHost, SPList list, ModelNode model)
{
var listHost = ModelHostBase.Inherit <ListModelHost>(WebModelHost.FromWeb(list.ParentWeb), h =>
{
h.HostList = list;
});
modelHost.DeployModel(listHost, model);
}
private void RunPreDeploymentServices(ModelHostBase modelHost, ModelNode model)
{
var services = PreDeploymentServices.OrderBy(s => s.Order);
foreach (var service in services)
{
service.DeployModel(modelHost, model);
}
}
public virtual void DeployModel(ModelHostBase modelHost, ModelNode model)
{
RunPreDeploymentServices(modelHost, model);
EnsureModelHandleEvents();
ProcessModelDeployment(modelHost, model);
RunPostDeploymentServices(modelHost, model);
}
public override void DeployModel(ModelHostBase modelHost, ModelNode model)
{
// before model provision
if (IsRegisteredModel(model))
{
AttachToOnProvisionedEvents(model);
CalculateIncrementalModel(model);
}
}
public static void DeployListModel(this CSOMProvisionService modelHost, ClientContext context, List list, ModelNode model)
{
var listHost = ModelHostBase.Inherit <ListModelHost>(WebModelHost.FromClientContext(context), h =>
{
h.HostList = list;
});
modelHost.DeployModel(listHost, model);
}
public override void DeployModel(ModelHostBase modelHost, ModelNode model)
{
// before model provision
if (IsRegisteredModel(model))
{
AttachToOnProvisionedEvents(model);
CalculateIncrementalModel(model);
}
}
public override void RetractModel(ModelHostBase modelHost, ModelNode model)
{
if (!(modelHost is CSOMModelHostBase))
{
throw new ArgumentException("model host for CSOM needs to be inherited from CSOMModelHostBase");
}
base.RetractModel(modelHost, model);
}
public override void WithResolvingModelHost(object modelHost, DefinitionBase model, Type childModelType, Action <object> action)
{
var site = ExtractSite(modelHost);
var web = ExtractWeb(modelHost);
var mdHHost = modelHost as CSOMModelHostBase;
var contentTypeModel = model as ContentTypeDefinition;
if (web != null && contentTypeModel != null)
{
var context = web.Context;
var id = contentTypeModel.GetContentTypeId();
var currentContentType = web.ContentTypes.GetById(id);
context.ExecuteQueryWithTrace();
if (childModelType == typeof(ModuleFileDefinition))
{
TraceService.Information((int)LogEventId.ModelProvisionCoreCall, "Resolving content type resource folder for ModuleFileDefinition");
var serverRelativeFolderUrl = ExtractResourceFolderServerRelativeUrl(web, context, currentContentType);
var ctFolder = web.GetFolderByServerRelativeUrl(serverRelativeFolderUrl);
context.ExecuteQueryWithTrace();
var folderModelHost = ModelHostBase.Inherit <FolderModelHost>(mdHHost, host =>
{
host.CurrentContentType = currentContentType;
host.CurrentContentTypeFolder = ctFolder;
});
action(folderModelHost);
}
else
{
action(new ModelHostContext
{
Site = site,
Web = web,
ContentType = currentContentType
});
}
TraceService.Information((int)LogEventId.ModelProvisionCoreCall, "Calling currentContentType.Update(true)");
currentContentType.Update(true);
context.ExecuteQueryWithTrace();
}
else
{
action(modelHost);
}
}
public override IEnumerable <ReverseHostBase> ReverseHosts(ReverseHostBase parentHost, ReverseOptions options)
{
TraceService.Information((int)ReverseLogEventId.ReverseHostsStart, "Processing web reverse host start");
var result = new List <WebReverseHost>();
Web web = null;
if (parentHost is WebReverseHost)
{
web = (parentHost as WebReverseHost).HostWeb;
}
else if (parentHost is SiteReverseHost)
{
web = (parentHost as SiteReverseHost).HostWeb;
}
var rootWeb = (parentHost as SiteReverseHost).HostSite.RootWeb;
var context = (parentHost as CSOMReverseHostBase).HostClientContext;
//if (!web.IsObjectPropertyInstantiated("ServerRelativeUrl"))
//{
// context.Load(web, w => w.ServerRelativeUrl);
// context.Load(rootWeb, w => w.ServerRelativeUrl);
// context.ExecuteQueryWithTrace();
//}
//var isRootWeb = web.ServerRelativeUrl == rootWeb.ServerRelativeUrl;
//if (UseRootWebOnly && isRootWeb)
//{
// return new[] { parentHost };
//}
var items = web.Webs;
context.Load(items);
context.ExecuteQueryWithTrace();
result.AddRange(ApplyReverseFilters(items, options).ToArray().Select(i =>
{
return(ModelHostBase.Inherit <WebReverseHost>(parentHost, h =>
{
h.HostWeb = i;
}));
}));
TraceService.Information((int)ReverseLogEventId.ReverseHostsStart, "Processing web reverse host end");
return(result);
}
public override void DeployModel(ModelHostBase modelHost, ModelNode model)
{
if (!(modelHost is CSOMModelHostBase))
throw new ArgumentException("model host for CSOM needs to be inherited from CSOMModelHostBase");
var clientContext = (modelHost as CSOMModelHostBase).HostClientContext;
PreloadProperties(clientContext);
// TODO, check clientContext.ServerLibraryVersion to make sure it's >= SP2013 SP
base.DeployModel(modelHost, model);
}
public override void DeployModel(ModelHostBase modelHost, ModelNode model)
{
CheckCSOMRuntimeVersion();
}
public override void DeployModel(ModelHostBase modelHost, ModelNode model)
{
var validationModelHost = modelHost as ReverseValidationModeHost;
if (validationModelHost == null)
throw new ArgumentException("modelHost should be of type ReverseValidationModeHost");
var orginalModel = validationModelHost.OriginalModel;
var reversedModel = validationModelHost.ReversedModel;
var allOriginalNodes = orginalModel.Flatten();
var allReversedNodes = reversedModel.Flatten();
foreach (var originalNode in allOriginalNodes)
{
if (!originalNode.Options.RequireSelfProcessing)
continue;
if (originalNode.RegIsExcludedFromValidation())
continue;
var originalDefinition = originalNode.Value;
var originalDefinitionId = ModelIdService.GetDefinitionIdentityKey(originalDefinition);
var reversedNode = allReversedNodes
.FirstOrDefault(n => ModelIdService.GetDefinitionIdentityKey(n.Value) == originalDefinitionId);
if (reversedNode == null)
{
// check the level
var level = 0;
var node = originalNode;
while (node != null)
{
node = allOriginalNodes.FirstOrDefault(n => n.ChildModels.Contains(node));
level++;
}
var defOptions = validationModelHost.ReverseOptions;
if (defOptions != null)
{
var definitionType = originalNode.Value.GetType();
var depthOption = defOptions
.Options
.FirstOrDefault(o => o.DefinitionClassFullName == definitionType.FullName
&& o is ReverseDepthOption) as ReverseDepthOption;
// does it exist? no more that suggested depth
if (depthOption != null)
{
if (depthOption.Depth < level)
{
// all good, we don't need to validate def which out of the depth leve;
originalNode.RegExcludeFromValidation();
continue;
}
}
}
throw new SPMeta2ReverseException(
string.Format("Cannot find node of type:[{0}] by identity id:[{1}]. Original definition is:[{2}]",
originalDefinition.GetType(), originalDefinitionId, originalDefinition));
}
var definitionValidator = ResolveModelHandlerForNode(originalNode);
definitionValidator.DeployModel(new ReverseValidationModeHost
{
OriginalModel = originalNode,
ReversedModel = reversedNode,
ReverseOptions = validationModelHost.ReverseOptions
}, null);
}
}
public override void DeployModel(ModelHostBase modelHost, ModelNode model)
{
Result.Clear();
ProcessModelDeployment(modelHost, model, Result);
}
