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 list = modelHost.WithAssertAndCast<SPList>("modelHost", value => value.RequireNotNull());
var listItemModel = model.WithAssertAndCast<ListItemDefinition>("model", value => value.RequireNotNull());
DeployInternall(list, listItemModel);
}
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 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 WithResolvingModelHost(object modelHost, DefinitionBase model, Type childModelType, Action<object> action)
{
var quickLaunchNode = model as QuickLaunchNavigationNodeDefinition;
if (modelHost is WebModelHost)
{
var webModelHost = modelHost as WebModelHost;
var currentNode = EnsureRootQuickLaunchNavigationNode(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 = EnsureQuickLaunchNavigationNode(nodeModelHost, quickLaunchNode);
var nodeHost = ModelHostBase.Inherit<NavigationNodeModelHost>(nodeModelHost, host =>
{
host.HostNavigationNode = currentNode;
});
action(nodeHost);
}
else
{
action(modelHost);
}
}
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 WithResolvingModelHost(object modelHost, DefinitionBase model, Type childModelType, Action<object> action)
{
var web = ExtractWeb(modelHost);
if (web != null)
{
string securityGroupName;
if (model is SecurityGroupLinkDefinition)
securityGroupName = (model as SecurityGroupLinkDefinition).SecurityGroupName;
else if (model is SecurityGroupDefinition)
securityGroupName = (model as SecurityGroupDefinition).Name;
else
{
throw new ArgumentException("model has to be SecurityGroupDefinition or SecurityGroupLinkDefinition");
}
var securityGroup = web.SiteGroups[securityGroupName];
var newModelHost = new SecurityGroupModelHost
{
SecurityGroup = securityGroup,
SecurableObject = modelHost as SPSecurableObject
};
action(newModelHost);
}
else
{
action(modelHost);
}
}
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 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 list = ExtractListFromHost(modelHost);
var hideContentTypeLinksDefinition = model.WithAssertAndCast<RemoveContentTypeLinksDefinition>("model", value => value.RequireNotNull());
DeployHideContentTypeLinks(modelHost, list, hideContentTypeLinksDefinition);
}
public override void Validate(DefinitionBase definition, List<ValidationResult> result)
{
Validate<ListDefinition>(definition, model =>
{
model
.NotNullString(m => m.Title, result)
.NotEmptyString(m => m.Title, result)
.NoSpacesBeforeOrAfter(m => m.Title, result)
.NotNullString(m => m.Description, result)
.NotEmptyString(m => m.Description, result)
.NoSpacesBeforeOrAfter(m => m.Description, result)
.NotNullString(m => m.Url, result)
.NotEmptyString(m => m.Url, result)
.NoSpacesBeforeOrAfter(m => m.Url, result);
if (model.TemplateType == 0)
{
model
.NotNullString(m => m.TemplateName, result)
.NotEmptyString(m => m.TemplateName, result)
.NoSpacesBeforeOrAfter(m => m.TemplateName, result);
}
if (string.IsNullOrEmpty(model.TemplateName))
{
model
.NotEqual(m => m.TemplateType, 0, result);
}
});
}
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 webModelHost = modelHost.WithAssertAndCast<WebModelHost>("modelHost", value => value.RequireNotNull());
var definition = model.WithAssertAndCast<MasterPageSettingsDefinition>("model", value => value.RequireNotNull());
var spObject = webModelHost.HostWeb;
var assert = ServiceFactory.AssertService
.NewAssert(model, definition, spObject)
.ShouldNotBeNull(spObject);
if (!string.IsNullOrEmpty(definition.SiteMasterPageUrl))
{
assert.ShouldBeEndOf(m => m.SiteMasterPageUrl, o => o.CustomMasterUrl);
}
else
{
assert.SkipProperty(m => m.SiteMasterPageUrl, "SiteMasterPageUrl is NULL or empty");
}
if (!string.IsNullOrEmpty(definition.SystemMasterPageUrl))
{
assert.ShouldBeEndOf(m => m.SystemMasterPageUrl, o => o.MasterUrl);
}
else
{
assert.SkipProperty(m => m.SystemMasterPageUrl, "SystemMasterPageUrl is NULL or empty");
}
}
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 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 securableObject = ExtractSecurableObject(modelHost);
var breakRoleInheritanceModel = model.WithAssertAndCast<BreakRoleInheritanceDefinition>("model", value => value.RequireNotNull());
ProcessRoleInheritance(modelHost, securableObject, breakRoleInheritanceModel);
}
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 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)
{
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)
{
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 folder = ExtractFolderFromModelHost(modelHost);
var welcomePgaeModel = model.WithAssertAndCast<WelcomePageDefinition>("model", value => value.RequireNotNull());
DeployWelcomePage(modelHost, model, folder, welcomePgaeModel);
}
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 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 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 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");
}
}
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 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 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 properties = ExtractProperties(modelHost);
var property = model.WithAssertAndCast<PropertyDefinition>("model", value => value.RequireNotNull());
DeployProperty(modelHost, properties, property);
}