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 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); }