public override void DeployModel(object modelHost, DefinitionBase model) { var definition = model.WithAssertAndCast<FieldDefinition>("model", value => value.RequireNotNull()); var spObject = GetField(modelHost, definition); var assert = ServiceFactory.AssertService.NewAssert(model, definition, spObject); ValidateField(assert, spObject, definition); var textField = spObject as SPFieldNumber; var textDefinition = model.WithAssertAndCast<NumberFieldDefinition>("model", value => value.RequireNotNull()); var typedFieldAssert = ServiceFactory.AssertService.NewAssert(model, textDefinition, textField); typedFieldAssert.ShouldBeEqual(m => m.MaximumValue, o => o.MaximumValue); typedFieldAssert.ShouldBeEqual(m => m.MinimumValue, o => o.MinimumValue); typedFieldAssert.ShouldBeEqual(m => m.ShowAsPercentage, o => o.ShowAsPercentage); if (!string.IsNullOrEmpty(textDefinition.DisplayFormat)) typedFieldAssert.ShouldBeEqual(m => m.DisplayFormat, o => o.GetDisplayFormat()); else typedFieldAssert.SkipProperty(m => m.DisplayFormat); }
public override void DeployModel(object modelHost, DefinitionBase model) { var definition = model.WithAssertAndCast<FieldDefinition>("model", value => value.RequireNotNull()); var spObject = GetField(modelHost, definition); var assert = ServiceFactory.AssertService.NewAssert(model, definition, spObject); ValidateField(assert, spObject, definition); var textField = spObject as SPFieldMultiLineText; var textDefinition = model.WithAssertAndCast<NoteFieldDefinition>("model", value => value.RequireNotNull()); var textFieldAssert = ServiceFactory.AssertService.NewAssert(model, textDefinition, textField); textFieldAssert.ShouldBeEqual(m => m.NumberOfLines, o => o.NumberOfLines); textFieldAssert.ShouldBeEqual(m => m.RichText, o => o.RichText); textFieldAssert.ShouldBeEqual(m => m.AppendOnly, o => o.AppendOnly); textFieldAssert.ShouldBeEqual(m => m.RichText, o => o.RichText); textFieldAssert.ShouldBeEqual(m => m.UnlimitedLengthInDocumentLibrary, o => o.UnlimitedLengthInDocumentLibrary); if (!string.IsNullOrEmpty(textDefinition.RichTextMode)) textFieldAssert.ShouldBeEqual(m => m.RichTextMode, o => o.GetRichTextMode()); else textFieldAssert.SkipProperty(m => m.RichTextMode); }
public override void DeployModel(object modelHost, DefinitionBase model) { var definition = model.WithAssertAndCast<FieldDefinition>("model", value => value.RequireNotNull()); var spObject = GetField(modelHost, definition); var assert = ServiceFactory.AssertService.NewAssert(model, definition, spObject); ValidateField(assert, spObject, definition); var textField = spObject.Context.CastTo<FieldDateTime>(spObject); var textDefinition = model.WithAssertAndCast<DateTimeFieldDefinition>("model", value => value.RequireNotNull()); var textFieldAssert = ServiceFactory.AssertService.NewAssert(model, textDefinition, textField); if (!string.IsNullOrEmpty(textDefinition.CalendarType)) textFieldAssert.ShouldBeEqual(m => m.CalendarType, o => o.GetCalendarType()); else textFieldAssert.SkipProperty(m => m.CalendarType, "CalendarType is null or empty. Skipping."); if (!string.IsNullOrEmpty(textDefinition.FriendlyDisplayFormat)) textFieldAssert.ShouldBeEqual(m => m.FriendlyDisplayFormat, o => o.GetFriendlyDisplayFormat()); else textFieldAssert.SkipProperty(m => m.FriendlyDisplayFormat, "FriendlyDisplayFormat is null or empty. Skipping."); if (!string.IsNullOrEmpty(textDefinition.DisplayFormat)) textFieldAssert.ShouldBeEqual(m => m.DisplayFormat, o => o.GetDisplayFormat()); else textFieldAssert.SkipProperty(m => m.DisplayFormat, "FriendlyDisplayFormat is null or empty. Skipping."); }
public override void DeployModel(object modelHost, DefinitionBase model) { if (modelHost is WebModelHost) { var workflowWebSubscriptionModelHost = modelHost.WithAssertAndCast<WebModelHost>("modelHost", value => value.RequireNotNull()); var definition = model.WithAssertAndCast<SP2013WorkflowSubscriptionDefinition>("model", value => value.RequireNotNull()); var web = workflowWebSubscriptionModelHost.HostWeb; var spObject = GetCurrentWebWorkflowSubscriptioBySourceId(workflowWebSubscriptionModelHost, web, web.ID, definition); ValidateWorkflowSubscription(modelHost, workflowWebSubscriptionModelHost.HostWeb, spObject, definition); } if (modelHost is ListModelHost) { var workflowSubscriptionModelHost = modelHost.WithAssertAndCast<ListModelHost>("modelHost", value => value.RequireNotNull()); var definition = model.WithAssertAndCast<SP2013WorkflowSubscriptionDefinition>("model", value => value.RequireNotNull()); var list = workflowSubscriptionModelHost.HostList; var web = list.ParentWeb; var spObject = GetCurrentWebWorkflowSubscriptioBySourceId(workflowSubscriptionModelHost, web, list.ID, definition); ValidateWorkflowSubscription(modelHost, web, spObject, definition); } }
public override void DeployModel(object modelHost, DefinitionBase model) { var definition = model.WithAssertAndCast<FieldDefinition>("model", value => value.RequireNotNull()); var spObject = GetField(modelHost, definition); var assert = ServiceFactory.AssertService.NewAssert(model, definition, spObject); ValidateField(assert, spObject, definition); var typedField = spObject.Context.CastTo<FieldUser>(spObject); var typedDefinition = model.WithAssertAndCast<UserFieldDefinition>("model", value => value.RequireNotNull()); var typedFieldAssert = ServiceFactory.AssertService.NewAssert(model, typedDefinition, typedField); typedFieldAssert.ShouldBeEqual(m => m.AllowMultipleValues, o => o.AllowMultipleValues); typedFieldAssert.ShouldBeEqual(m => m.AllowDisplay, o => o.AllowDisplay); typedFieldAssert.ShouldBeEqual(m => m.Presence, o => o.Presence); typedFieldAssert.ShouldBeEqual(m => m.SelectionMode, o => o.GetSelectionMode()); if (typedDefinition.SelectionGroup.HasValue) { typedFieldAssert.ShouldBeEqual(m => m.SelectionGroup, o => o.SelectionGroup); } else { typedFieldAssert.SkipProperty(m => m.SelectionGroup, "SelectionGroup is NULL. Skipping."); } if (!string.IsNullOrEmpty(typedDefinition.SelectionGroupName)) { var web = ExtractWebFromHost(modelHost); var context = web.Context; var group = web.SiteGroups.GetByName(typedDefinition.SelectionGroupName); context.Load(group); context.ExecuteQueryWithTrace(); typedFieldAssert.ShouldBeEqual((p, s, d) => { var srcProp = s.GetExpressionValue(m => m.SelectionGroupName); var isValid = typedField.SelectionGroup == group.Id; return new PropertyValidationResult { Tag = p.Tag, Src = srcProp, Dst = null, IsValid = isValid }; }); } else { typedFieldAssert.SkipProperty(m => m.SelectionGroupName, "SelectionGroupName is NULL. Skipping."); } }
public override void DeployModel(object modelHost, DefinitionBase model) { base.DeployModel(modelHost, model); var definition = model.WithAssertAndCast<FieldDefinition>("model", value => value.RequireNotNull()); var spObject = GetField(modelHost, definition); var textField = spObject.Context.CastTo<FieldChoice>(spObject); var textDefinition = model.WithAssertAndCast<ChoiceFieldDefinition>("model", value => value.RequireNotNull()); var textFieldAssert = ServiceFactory.AssertService.NewAssert(model, textDefinition, textField); textFieldAssert.ShouldBeEqual(m => m.EditFormat, o => o.GetEditFormat()); }
public override void DeployModel(object modelHost, DefinitionBase model) { var definition = model.WithAssertAndCast<FieldDefinition>("model", value => value.RequireNotNull()); var spObject = GetField(modelHost, definition); var assert = ServiceFactory.AssertService.NewAssert(model, definition, spObject); ValidateField(assert, spObject, definition); var textField = spObject as SPFieldBoolean; var textDefinition = model.WithAssertAndCast<BooleanFieldDefinition>("model", value => value.RequireNotNull()); var textFieldAssert = ServiceFactory.AssertService.NewAssert(model, textDefinition, textField); }
public override void DeployModel(object modelHost, DefinitionBase model) { var siteModelHost = modelHost.WithAssertAndCast<AdminSiteModelHost>("modelHost", value => value.RequireNotNull()); var o365SiteModel = model.WithAssertAndCast<O365SiteDefinition>("model", value => value.RequireNotNull()); DeployO365SiteCollection(modelHost, siteModelHost.HostClientContext, o365SiteModel); }
public override void DeployModel(object modelHost, DefinitionBase model) { var securableObject = ExtractSecurableObject(modelHost); var breakRoleInheritanceModel = model.WithAssertAndCast<BreakRoleInheritanceDefinition>("model", value => value.RequireNotNull()); ProcessRoleInheritance(modelHost, securableObject, breakRoleInheritanceModel); }
protected override void DeployModelInternal(object modelHost, DefinitionBase model) { var siteModelHost = modelHost.WithAssertAndCast<SiteModelHost>("modelHost", value => value.RequireNotNull()); var definitionModel = model.WithAssertAndCast<ContentTypeDefinition>("model", value => value.RequireNotNull()); var site = siteModelHost.HostSite; var rootWeb = site.RootWeb; var contentTypes = rootWeb.AvailableContentTypes; var spModel = contentTypes[definitionModel.Name]; TraceUtils.WithScope(traceScope => { Trace.WriteLine(string.Format("Validate model: {0} ContentType:{1}", definitionModel, spModel)); // assert base properties traceScope.WithTraceIndent(trace => { trace.WriteLine(string.Format("Validate Name: model:[{0}] ct:[{1}]", definitionModel.Name, spModel.Name)); Assert.AreEqual(definitionModel.Name, spModel.Name); trace.WriteLine(string.Format("Validate Description: model:[{0}] ct:[{1}]", definitionModel.Description, spModel.Description)); Assert.AreEqual(definitionModel.Description, spModel.Description); trace.WriteLine(string.Format("Validate Id: model:[{0}] ct:[{1}]", definitionModel.GetContentTypeId(), spModel.Id)); Assert.AreEqual(new SPContentTypeId(definitionModel.GetContentTypeId()), spModel.Id); trace.WriteLine(string.Format("Validate Group: model:[{0}] ct:[{1}]", definitionModel.Group, spModel.Group)); Assert.AreEqual(definitionModel.Group, spModel.Group); }); }); }
public override void DeployModel(object modelHost, DefinitionBase model) { var securableObject = ExtractSecurableObject(modelHost); var definition = model.WithAssertAndCast<ResetRoleInheritanceDefinition>("model", value => value.RequireNotNull()); var context = securableObject.Context; if (!securableObject.IsObjectPropertyInstantiated("HasUniqueRoleAssignments")) { context.Load(securableObject, s => s.HasUniqueRoleAssignments); context.ExecuteQueryWithTrace(); } var assert = ServiceFactory.AssertService .NewAssert(definition, securableObject) .ShouldNotBeNull(securableObject); assert.ShouldBeEqual((p, s, d) => { var dstProp = d.GetExpressionValue(m => m.HasUniqueRoleAssignments); return new PropertyValidationResult { Tag = p.Tag, Src = null, Dst = dstProp, IsValid = d.HasUniqueRoleAssignments == false }; }); }
public override void DeployModel(object modelHost, DefinitionBase model) { var definition = model.WithAssertAndCast<EventReceiverDefinition>("model", value => value.RequireNotNull()); Microsoft.SharePoint.Client.EventReceiverDefinition spObject = null; if (modelHost is ListModelHost) spObject = FindEventReceiverDefinition((modelHost as ListModelHost).HostList.EventReceivers, definition); else if (modelHost is WebModelHost) spObject = FindEventReceiverDefinition((modelHost as WebModelHost).HostWeb.EventReceivers, definition); else if (modelHost is SiteModelHost) spObject = FindEventReceiverDefinition((modelHost as SiteModelHost).HostSite.EventReceivers, definition); else { throw new SPMeta2UnsupportedModelHostException("model host should be ListModelHost or WebModelHost"); } var assert = ServiceFactory.AssertService .NewAssert(definition, spObject) .ShouldNotBeNull(spObject) .ShouldBeEqual(m => m.Name, o => o.ReceiverName) .ShouldBeEqual(m => m.Class, o => o.ReceiverClass) .ShouldBeEqual(m => m.Assembly, o => o.ReceiverAssembly) .SkipProperty(m => m.Data, "Data property is not supported by CSOM. SKipping.") .ShouldBeEqual(m => m.SequenceNumber, o => o.SequenceNumber) .ShouldBeEqual(m => m.Synchronization, o => o.GetSynchronization()) .ShouldBeEqual(m => m.Type, o => o.GetEventReceiverType()); }
public override void DeployModel(object modelHost, DefinitionBase model) { var webAppModelHost = modelHost.WithAssertAndCast<WebApplicationModelHost>("modelHost", value => value.RequireNotNull()); var definition = model.WithAssertAndCast<PeoplePickerSettingsDefinition>("model", value => value.RequireNotNull()); DeployPeoplePickerSettings(modelHost, webAppModelHost.HostWebApplication, definition); }
public override void DeployModel(object modelHost, DefinitionBase model) { // base validation base.DeployModel(modelHost, model); // web specific validation var host = modelHost.WithAssertAndCast<WebpartPageModelHost>("modelHost", value => value.RequireNotNull()); var definition = model.WithAssertAndCast<PageViewerWebPartDefinition>("model", value => value.RequireNotNull()); var item = host.PageListItem; WebPartExtensions.WithExistingWebPart(item, definition, (spWebPartManager, spObject) => { var web = spWebPartManager.Web; var typedObject = spObject as PageViewerWebPart; var assert = ServiceFactory.AssertService .NewAssert(definition, typedObject) .ShouldNotBeNull(typedObject); if (!string.IsNullOrEmpty(definition.ContentLink)) assert.ShouldBeEqual(m => m.ContentLink, o => o.ContentLink); else assert.SkipProperty(m => m.ContentLink); if (!string.IsNullOrEmpty(definition.SourceType)) assert.ShouldBeEqual(m => m.SourceType, o => o.GetSourceType()); else assert.SkipProperty(m => m.SourceType); }); }
public override void DeployModel(object modelHost, DefinitionBase model) { var securableObject = modelHost.WithAssertAndCast<SecurableObject>("modelHost", value => value.RequireNotNull()); var securityGroupLinkModel = model.WithAssertAndCast<SecurityGroupLinkDefinition>("model", value => value.RequireNotNull()); var web = GetWebFromSPSecurableObject(securableObject); var context = web.Context; context.Load(web, w => w.SiteGroups); context.Load(securableObject, s => s.RoleAssignments.Include(r => r.Member)); context.ExecuteQuery(); var securityGroup = WebExtensions.FindGroupByName(web.SiteGroups, securityGroupLinkModel.SecurityGroupName); TraceUtils.WithScope(traceScope => { traceScope.WriteLine(string.Format("Validate model:[{0}] securableObject:[{1}]", securityGroupLinkModel, securityGroup)); traceScope.WithTraceIndent(trace => { // asserting it exists trace.WriteLine(string.Format("Validating existance...")); var existingRoleAssignments = FindClientRoleRoleAssignment(securableObject.RoleAssignments, securityGroup); Assert.IsNotNull(existingRoleAssignments); trace.WriteLine(string.Format("RoleAssignments for security group link [{0}] exists.", securityGroupLinkModel.SecurityGroupName)); }); }); }
public override void DeployModel(object modelHost, DefinitionBase model) { var webAppModelHost = modelHost.WithAssertAndCast<WebApplicationModelHost>("modelHost", value => value.RequireNotNull()); var siteModel = model.WithAssertAndCast<SiteDefinition>("model", value => value.RequireNotNull()); DeploySite(webAppModelHost, webAppModelHost.HostWebApplication, siteModel); }
public override void DeployModel(object modelHost, DefinitionBase model) { var farmModelHost = modelHost.WithAssertAndCast<FarmModelHost>("modelHost", value => value.RequireNotNull()); var managedAccountDefinition = model.WithAssertAndCast<ManagedAccountDefinition>("model", value => value.RequireNotNull()); DeployManagedAccount(modelHost, farmModelHost.HostFarm, managedAccountDefinition); }
public override void DeployModel(object modelHost, DefinitionBase model) { var list = ExtractListFromHost(modelHost); var hideContentTypeLinksDefinition = model.WithAssertAndCast<RemoveContentTypeLinksDefinition>("model", value => value.RequireNotNull()); DeployHideContentTypeLinks(modelHost, list, hideContentTypeLinksDefinition); }
public override void DeployModel(object modelHost, DefinitionBase model) { var webModelHost = modelHost.WithAssertAndCast<WebModelHost>("modelHost", value => value.RequireNotNull()); var navigationModel = model.WithAssertAndCast<WebNavigationSettingsDefinition>("model", value => value.RequireNotNull()); DeployNavigationSettings(modelHost, webModelHost, navigationModel); }
public override void DeployModel(object modelHost, DefinitionBase model) { var modelHostContext = modelHost.WithAssertAndCast<ModelHostContext>("modelHost", value => value.RequireNotNull()); var fieldlinkModel = model.WithAssertAndCast<ContentTypeFieldLinkDefinition>("model", value => value.RequireNotNull()); var site = modelHostContext.Site; var contentType = modelHostContext.ContentType; var context = site.Context; context.Load(contentType, ct => ct.FieldLinks); context.ExecuteQuery(); var spFieldLink = FindFieldLinkById(contentType.FieldLinks, fieldlinkModel.FieldId); TraceUtils.WithScope(traceScope => { Trace.WriteLine(string.Format("Validate model: {0} ContentType:{1}", fieldlinkModel, contentType)); // assert base properties traceScope.WithTraceIndent(trace => { trace.WriteLine(string.Format("Validate FieldId: model:[{0}] ct field link:[{1}]", fieldlinkModel.FieldId, spFieldLink.Id)); Assert.AreEqual(fieldlinkModel.FieldId, spFieldLink.Id); }); }); }
public override void DeployModel(object modelHost, DefinitionBase model) { base.DeployModel(modelHost, model); var listItemModelHost = modelHost.WithAssertAndCast<ListItemModelHost>("modelHost", value => value.RequireNotNull()); var definition = model.WithAssertAndCast<ClientWebPartDefinition>("model", value => value.RequireNotNull()); //var pageItem = listItemModelHost.HostListItem; WithExistingWebPart(listItemModelHost.HostFile, definition, spObject => { var assert = ServiceFactory.AssertService .NewAssert(model, definition, spObject) .ShouldNotBeNull(spObject); // some of the properties can actually be validated // http://stackoverflow.com/questions/11814829/how-to-read-webpart-content-using-sharepoint-client-om // asmx calls are required to get additional information about the current web parts assert .SkipProperty(m => m.ZoneIndex, "Property is not available in CSOM. Skipping.") .SkipProperty(m => m.Id, "Property is not available in CSOM. Skipping.") .SkipProperty(m => m.ZoneId, "Property is not available in CSOM. Skipping.") .SkipProperty(m => m.WebpartFileName, "Property is not available in CSOM. Skipping.") .SkipProperty(m => m.WebpartType, "Property is not available in CSOM. Skipping.") .SkipProperty(m => m.WebpartXmlTemplate, "Property is not available in CSOM. Skipping.") .ShouldBeEqual(m => m.Title, o => o.Title); }); }
public override void DeployModel(object modelHost, DefinitionBase model) { var list = modelHost.WithAssertAndCast<SPList>("modelHost", value => value.RequireNotNull()); var listItemModel = model.WithAssertAndCast<ListItemDefinition>("model", value => value.RequireNotNull()); DeployInternall(list, listItemModel); }
public override void WithResolvingModelHost(object modelHost, DefinitionBase model, Type childModelType, Action<object> action) { var folderModelHost = modelHost.WithAssertAndCast<FolderModelHost>("modelHost", value => value.RequireNotNull()); var folderModel = model.WithAssertAndCast<FolderDefinition>("model", value => value.RequireNotNull()); if (folderModelHost.CurrentLibrary != null) { var currentFolder = EnsureLibraryFolder(folderModelHost, folderModel); var newContext = new FolderModelHost { CurrentLibrary = folderModelHost.CurrentLibrary, CurrentLibraryFolder = currentFolder }; action(newContext); } else if (folderModelHost.CurrentList != null) { var currentListItem = EnsureListFolder(folderModelHost, folderModel); var newContext = new FolderModelHost { CurrentList = folderModelHost.CurrentList, CurrentListItem = currentListItem }; action(newContext); } }
public override void DeployModel(object modelHost, DefinitionBase model) { var typedModelHost = modelHost.WithAssertAndCast<WebModelHost>("modelHost", value => value.RequireNotNull()); var typedDefinition = model.WithAssertAndCast<DeleteTopNavigationNodesDefinition>("model", value => value.RequireNotNull()); DeployDefinition(modelHost, typedModelHost, typedDefinition); }
public override void DeployModel(object modelHost, DefinitionBase model) { var webModelHost = modelHost.WithAssertAndCast<WebModelHost>("modelHost", value => value.RequireNotNull()); var definition = model.WithAssertAndCast<RegionalSettingsDefinition>("model", value => value.RequireNotNull()); DeployRegionalSettings(modelHost, webModelHost.HostWeb, definition); }
public override void DeployModel(object modelHost, DefinitionBase model) { var folder = ExtractFolderFromModelHost(modelHost); var welcomePgaeModel = model.WithAssertAndCast<WelcomePageDefinition>("model", value => value.RequireNotNull()); DeployWelcomePage(modelHost, model, folder, welcomePgaeModel); }
public override void DeployModel(object modelHost, DefinitionBase model) { var siteModelHost = modelHost.WithAssertAndCast<TermStoreModelHost>("modelHost", value => value.RequireNotNull()); var groupModel = model.WithAssertAndCast<TaxonomyTermGroupDefinition>("model", value => value.RequireNotNull()); DeployTaxonomyGroup(modelHost, siteModelHost, groupModel); }
public override void DeployModel(object modelHost, DefinitionBase model) { var farmModelHost = modelHost.WithAssertAndCast<FarmModelHost>("modelHost", value => value.RequireNotNull()); var solutionModel = model.WithAssertAndCast<FarmSolutionDefinition>("model", value => value.RequireNotNull()); DeploySolution(farmModelHost, solutionModel); }
public override void DeployModel(object modelHost, DefinitionBase model) { var folder = modelHost.WithAssertAndCast<SPFolder>("modelHost", value => value.RequireNotNull()); var moduleFile = model.WithAssertAndCast<ModuleFileDefinition>("model", value => value.RequireNotNull()); ProcessFile(modelHost, folder, moduleFile); }
public override void DeployModel(object modelHost, DefinitionBase model) { var workflowAssociationModel = model.WithAssertAndCast<WorkflowAssociationDefinition>("model", value => value.RequireNotNull()); if (modelHost is ListModelHost) { var listModelHost = (modelHost as ListModelHost); var list = listModelHost.HostList; DeployListWorkflowAssociationDefinition(listModelHost, list, workflowAssociationModel); } else if (modelHost is WebModelHost) { var webModelHost = (modelHost as WebModelHost); var web = webModelHost.HostWeb; DeployWebWorkflowAssociationDefinition(webModelHost, web, workflowAssociationModel); } else if (modelHost is ModelHostContext) { var contentType = (modelHost as ModelHostContext).ContentType; DeployContentTypeWorkflowAssociationDefinition(modelHost, contentType, workflowAssociationModel); } else { throw new SPMeta2NotSupportedException("model host should be of type ListModelHost or WebModelHost"); } }