public void Can_Provision_Incrementally_With_AutoDetection_As_SSOM()
{
var provisionRunner = new SSOMProvisionRunner();
var provisionService = provisionRunner.ProvisionService;
var incrementalModelId = "m2.regression." + Guid.NewGuid().ToString("N");
provisionRunner.WithSSOMFarmContext(farm =>
{
for (var i = 0; i < 3; i++)
{
var incrementalProvisionConfig = new IncrementalProvisionConfig();
incrementalProvisionConfig.AutoDetectSharePointPersistenceStorage = true;
provisionService.SetIncrementalProvisionMode(incrementalProvisionConfig);
var model = SPMeta2Model.NewFarmModel(site =>
{
});
model.SetIncrementalProvisionModelId(incrementalModelId);
provisionService.DeployModel(SPMeta2.SSOM.ModelHosts.FarmModelHost.FromFarm(farm), model);
}
});
provisionRunner.WebApplicationUrls.ForEach(url =>
{
provisionRunner.WithSSOMWebApplicationContext(url, spWebApp =>
{
for (var i = 0; i < 3; i++)
{
var incrementalProvisionConfig = new IncrementalProvisionConfig();
incrementalProvisionConfig.AutoDetectSharePointPersistenceStorage = true;
provisionService.SetIncrementalProvisionMode(incrementalProvisionConfig);
var model = SPMeta2Model.NewWebApplicationModel(site =>
{
});
model.SetIncrementalProvisionModelId(incrementalModelId);
provisionService.DeployModel(SPMeta2.SSOM.ModelHosts.WebApplicationModelHost.FromWebApplication(spWebApp), model);
}
});
});
provisionRunner.SiteUrls.ForEach(siteUrl =>
{
provisionRunner.WithSSOMSiteAndWebContext((spSite, spWeb) =>
{
for (var i = 0; i < 3; i++)
{
var incrementalProvisionConfig = new IncrementalProvisionConfig();
incrementalProvisionConfig.AutoDetectSharePointPersistenceStorage = true;
provisionService.SetIncrementalProvisionMode(incrementalProvisionConfig);
var model = SPMeta2Model.NewSiteModel(site =>
{
});
model.SetIncrementalProvisionModelId(incrementalModelId);
provisionService.DeployModel(SPMeta2.SSOM.ModelHosts.WebModelHost.FromWeb(spWeb), model);
}
});
});
}
private void DeployWebpartOnSupportedHosts <TWebpartType>()
where TWebpartType : WebPartDefinitionBase, new()
{
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddSiteFeature(BuiltInSiteFeatures.SharePointServerPublishingInfrastructure.Inherit(def =>
{
def.Enable = true;
def.ForceActivate = true;
}));
site.AddSiteFeature(BuiltInSiteFeatures.EnableAppSideLoading.Inherit(def =>
{
def.Enable = true;
def.ForceActivate = true;
}));
});
var model = SPMeta2Model.NewWebModel(web =>
{
web.AddWebFeature(BuiltInWebFeatures.SharePointServerPublishing.Inherit(def =>
{
def.Enable = true;
def.ForceActivate = true;
}));
web.AddWebFeature(BuiltInWebFeatures.WikiPageHomePage.Inherit(def =>
{
def.Enable = true;
def.ForceActivate = true;
}));
// always deploy to root web
FillWebWithTheTestwebPartSuite <TWebpartType>(web);
if (UseSubWebs)
{
// and then sub web too
web.AddRandomWeb(subWeb =>
{
subWeb.AddWebFeature(BuiltInWebFeatures.SharePointServerPublishing.Inherit(def =>
{
def.Enable = true;
def.ForceActivate = true;
}));
subWeb.AddWebFeature(BuiltInWebFeatures.WikiPageHomePage.Inherit(def =>
{
def.Enable = true;
def.ForceActivate = true;
}));
FillWebWithTheTestwebPartSuite <TWebpartType>(subWeb);
});
}
});
WithDisabledPropertyUpdateValidation(() =>
{
TestModel(siteModel, model);
});
}
protected LookupFieldEnvironment GetLookupFieldEnvironment(Action <LookupFieldEnvironment> action)
{
var result = new LookupFieldEnvironment();
var dataList = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
{
def.TemplateType = BuiltInListTemplateTypeId.GenericList;
});
var masterList = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
{
def.TemplateType = BuiltInListTemplateTypeId.GenericList;
});
var lookupField = GetSingleSelectLookupDefinition(def =>
{
def.Indexed = false;
//def.LookupListTitle = dataList.Title;
});
ModelNode childListNode = null;
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddField(lookupField);
});
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddField(lookupField);
});
var childWebModel = SPMeta2Model.NewWebModel(web =>
{
web.AddList(dataList, list =>
{
childListNode = list;
list
.AddRandomListItem()
.AddRandomListItem()
.AddRandomListItem();
});
});
var masterWebModel = SPMeta2Model.NewWebModel(web =>
{
web
.AddList(masterList, list =>
{
list.AddListFieldLink(lookupField);
});
});
result.LookupField = lookupField;
result.ChildList = dataList;
result.ChildListNode = childListNode;
result.ChildListModel = childWebModel;
result.MasterList = masterList;
result.MasterListModel = masterWebModel;
result.SiteModel = siteModel;
result.WebModel = webModel;
if (action != null)
{
action(result);
}
return(result);
}
public void Create_Package_SPMeta2()
{
// Follows NuGet spec design - https://docs.nuget.org/ndocs/schema/nuspec
// Solution package is a container for SERIALIZED models.
var solutionPackage = new SolutionPackageBase();
solutionPackage.Name = "Contoso Intranet SPMeta2 - Site Fields";
solutionPackage.Title = "Contoso Intranet SPMeta2 - Site Fields";
solutionPackage.Description = "Contains site level fields for Contoso intranet";
solutionPackage.Id = "Contoso.Intranet.SiteFields.SPMeta2";
solutionPackage.Authors = "SubPoint Solutions";
solutionPackage.Company = "SubPoint Solutions";
solutionPackage.Version = "1.0.0.0";
solutionPackage.Owners = "SubPoint Solutions";
solutionPackage.ReleaseNotes = "Initial set of the site fields for Contoso Intranet";
solutionPackage.Summary = "All site fields required for Contoso intranet";
solutionPackage.ProjectUrl = "https://github.com/SubPointSolutions/DefinitelyPacked";
solutionPackage.IconUrl = "https://github.com/SubPointSolutions/metapack/metapack.png";
solutionPackage.LicenseUrl = "https://opensource.org/licenses/MIT";
solutionPackage.Copyright = "All yours";
solutionPackage.Tags = "MetaPack SPMeta2 SiteFields Taxonomy";
// here are all your SPMeta2 models
var models = new List <ModelNode>();
// create a new ModelContainerBase for every model
// and then add to solution package
// you can put "Order" option to control deployment order of the models
for (var index = 0; index < models.Count; index++)
{
var model = models[index];
var xmlContext = SPMeta2Model.ToXML(model);
// create ModelContainerBase, put serialized model there
var modelContainer = new ModelContainerBase
{
Model = Encoding.UTF8.GetBytes(xmlContext),
};
// add sort order to control deployment order of the models
modelContainer.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.Model.Order.Id,
Value = index.ToString()
});
// add model container to solution
solutionPackage.AddModel(modelContainer);
}
// flag a provider which will be used for solution package deployment
solutionPackage.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.SolutionToolPackage.PackageId.Id,
Value = "MetaPack.SPMeta2"
});
var solutionPackageService = new SPMeta2SolutionPackageService();
// save your NuGet solution package as stream
var nuGetPackageStream = solutionPackageService.Pack(solutionPackage, null);
// or save it straight to file, for instance, on shared folder
solutionPackageService.PackToFile(solutionPackage, "Contoso.Intranet.SiteFields.SPMeta2.nupkg");
// or push it straight to NuGet gallery you've got - http://NuGet.org or http://MyGet.org
// follow instructions on how obtain Url/Key for a specific NuGet Gallery
var nuGetGallery_ApiUrl = "";
var nuGetGallery_ApiKey = "";
solutionPackageService.Push(solutionPackage, nuGetGallery_ApiUrl, nuGetGallery_ApiKey);
}
public void CanDeploy_DependentLookupField_OnContentType()
{
var lookupField = ModelGeneratorService.GetRandomDefinition<LookupFieldDefinition>(def =>
{
def.ShowInNewForm = true;
def.ShowInDisplayForm = true;
def.ShowInEditForm = true;
def.ShowInListSettings = true;
def.ShowInViewForms = true;
def.Hidden = false;
def.Required = false;
def.AllowMultipleValues = false;
});
var contentTypeWithDepLookup = ModelGeneratorService.GetRandomDefinition<ContentTypeDefinition>(def =>
{
def.Hidden = false;
});
var dependentIdLookupField = ModelGeneratorService.GetRandomDefinition<DependentLookupFieldDefinition>(
def =>
{
def.LookupField = BuiltInInternalFieldNames.ID;
def.PrimaryLookupFieldId = lookupField.Id;
def.LookupWebId = lookupField.LookupWebId;
def.LookupWebUrl = lookupField.LookupWebUrl;
def.LookupList = lookupField.LookupList;
def.LookupListTitle = lookupField.LookupListTitle;
def.LookupListUrl = lookupField.LookupListUrl;
});
var dependentTitleLookupField = ModelGeneratorService.GetRandomDefinition<DependentLookupFieldDefinition>(
def =>
{
def.LookupField = BuiltInInternalFieldNames.Title;
def.PrimaryLookupFieldId = lookupField.Id;
def.LookupWebId = lookupField.LookupWebId;
def.LookupWebUrl = lookupField.LookupWebUrl;
def.LookupList = lookupField.LookupList;
def.LookupListTitle = lookupField.LookupListTitle;
def.LookupListUrl = lookupField.LookupListUrl;
});
var masterList = ModelGeneratorService.GetRandomDefinition<ListDefinition>();
var childList = ModelGeneratorService.GetRandomDefinition<ListDefinition>(list =>
{
list.ContentTypesEnabled = true;
});
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddLookupField(lookupField);
site.AddDependentLookupField(dependentIdLookupField);
site.AddDependentLookupField(dependentTitleLookupField);
site.AddContentType(contentTypeWithDepLookup, contentType =>
{
contentType
.AddContentTypeFieldLink(lookupField)
.AddContentTypeFieldLink(dependentIdLookupField)
.AddContentTypeFieldLink(dependentTitleLookupField);
});
});
TestModel(siteModel);
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddList(masterList, list =>
{
for (var i = 0; i < 10; i++)
{
list.AddListItem(new ListItemDefinition
{
Title = string.Format("master item {0} - {1}", i, Rnd.String())
});
}
});
web.AddList(childList, list =>
{
// list.AddListFieldLink(lookupField);
});
});
TestModel(webModel);
// rebind lookup
#pragma warning disable 618
lookupField.LookupListUrl = masterList.GetListUrl();
#pragma warning restore 618
TestModel(siteModel);
// add dep field
var depWebModel = SPMeta2Model.NewWebModel(web =>
{
web.AddList(childList, list =>
{
list.AddContentTypeLink(contentTypeWithDepLookup);
list.AddUniqueContentTypeOrder(new UniqueContentTypeOrderDefinition
{
ContentTypes = new List<ContentTypeLinkValue>
{
new ContentTypeLinkValue { ContentTypeName = contentTypeWithDepLookup.Name }
}
});
//list.AddListFieldLink(dependentIdLookupField);
//list.AddListFieldLink(dependentTitleLookupField);
list.AddListView(new ListViewDefinition
{
Title = "Test View",
Fields = new Collection<string>
{
BuiltInInternalFieldNames.Edit,
BuiltInInternalFieldNames.ID,
BuiltInInternalFieldNames.Title,
lookupField.InternalName,
dependentIdLookupField.InternalName,
dependentTitleLookupField.InternalName
},
IsDefault = true
});
});
});
TestModel(depWebModel);
}
public void CanDeploy_Custom_WebTemplate_As_SaveAsTemplate()
{
// should be uploaded manually yet
var customWebAsTemplateSolution = new SandboxSolutionDefinition
{
FileName = Rnd.WspFileName(),
Content = File.ReadAllBytes(DefaultContainers.WebTemplates.M2CustomWebAsTemplate.FilePath),
Activate = true,
SolutionId = DefaultContainers.WebTemplates.M2CustomWebAsTemplate.SolutionId
};
var customTeamSiteTemplateSolution = new SandboxSolutionDefinition
{
FileName = Rnd.WspFileName(),
Content = File.ReadAllBytes(DefaultContainers.WebTemplates.M2CustomTeamSite.FilePath),
Activate = true,
SolutionId = DefaultContainers.WebTemplates.M2CustomWebAsTemplate.SolutionId
};
var mainWeb = ModelGeneratorService.GetRandomDefinition <WebDefinition>(def =>
{
def.WebTemplate = string.Empty;
def.CustomWebTemplate = DefaultContainers.WebTemplates.M2CustomWebAsTemplate.WebTemplateName;
});
var subWeb = ModelGeneratorService.GetRandomDefinition <WebDefinition>(def =>
{
def.WebTemplate = string.Empty;
def.CustomWebTemplate = DefaultContainers.WebTemplates.M2CustomWebAsTemplate.WebTemplateName;
});
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
// required by the team site template
// might not be eabled due to publishing site collection
var targetSiteFeatureIds = new[]
{
new Guid("14aafd3a-fcb9-4bb7-9ad7-d8e36b663bbd"),
new Guid("b21b090c-c796-4b0f-ac0f-7ef1659c20ae"),
new Guid("{5f3b0127-2f1d-4cfd-8dd2-85ad1fb00bfc}"),
new Guid("{2ed1c45e-a73b-4779-ae81-1524e4de467a}"),
new Guid("{39d18bbf-6e0f-4321-8f16-4e3b51212393}"),
new Guid("{4248e21f-a816-4c88-8cab-79d82201da7b}"),
new Guid("{43f41342-1a37-4372-8ca0-b44d881e4434}"),
new Guid("{5a979115-6b71-45a5-9881-cdc872051a69}"),
new Guid("{3cb475e7-4e87-45eb-a1f3-db96ad7cf313}"),
new Guid("{4c42ab64-55af-4c7c-986a-ac216a6e0c0e}"),
new Guid("{9fec40ea-a949-407d-be09-6cba26470a0c}"),
new Guid("{875d1044-c0cf-4244-8865-d2a0039c2a49}"),
new Guid("{5eac763d-fbf5-4d6f-a76b-eded7dd7b0a5}"),
new Guid("{6e8f2b8d-d765-4e69-84ea-5702574c11d6}"),
new Guid("{744b5fd3-3b09-4da6-9bd1-de18315b045d}"),
new Guid("{8581a8a7-cf16-4770-ac54-260265ddb0b2}"),
new Guid("{2fcd5f8a-26b7-4a6a-9755-918566dba90a}"),
new Guid("{e995e28b-9ba8-4668-9933-cf5c146d7a9f}"),
//new Guid("{c9c9515d-e4e2-4001-9050-74f980f93160}"),
};
foreach (var featureId in targetSiteFeatureIds)
{
site.AddSiteFeature(new FeatureDefinition
{
Id = featureId,
Enable = true,
Scope = FeatureDefinitionScope.Site
});
}
//site.AddSandboxSolution(solution);
});
var model = SPMeta2Model.NewWebModel(rootWeb =>
{
rootWeb.AddWeb(mainWeb, web =>
{
web.AddWeb(subWeb);
});
});
TestModel(siteModel, model);
}
public void CanDeploy_ListFieldLink_AsAddToAllContentTypes()
{
var field = ModelGeneratorService.GetRandomDefinition <FieldDefinition>();
field.AddToDefaultView = true;
var listFieldLink = new ListFieldLinkDefinition
{
FieldId = field.Id,
AddFieldOptions = BuiltInAddFieldOptions.AddToAllContentTypes,
AddToDefaultView = true
};
var ct_1 = ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>(def =>
{
def.ParentContentTypeId = BuiltInContentTypeId.Item;
});
var ct_2 = ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>(def =>
{
def.ParentContentTypeId = BuiltInContentTypeId.Item;
});
var ct_3 = ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>(def =>
{
def.ParentContentTypeId = BuiltInContentTypeId.Item;
});
var genericList = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
{
def.ContentTypesEnabled = true;
def.TemplateType = BuiltInListTemplateTypeId.GenericList;
});
var siteModel = SPMeta2Model
.NewSiteModel(site =>
{
site.AddContentType(ct_1);
site.AddContentType(ct_2);
site.AddContentType(ct_3);
site.AddField(field);
});
var webModel = SPMeta2Model
.NewWebModel(web =>
{
web.AddList(genericList, list =>
{
list.AddContentTypeLink(ct_1);
list.AddContentTypeLink(ct_2);
list.AddContentTypeLink(ct_3);
list.AddListFieldLink(listFieldLink);
});
});
// content types are deployed after fields
// so, to test AddToAllContentTypes, we need to deploy content type first, and then the rest
//var fieldLinkModel = SPMeta2Model
// .NewWebModel(web =>
// {
// web.AddHostList(genericList, list =>
// {
// });
// });
TestModels(new[] { siteModel, webModel });
}
public void CanDeploy_ListViewWebPart_As_Calender_With_DateRangesOverlap()
{
// ListViewWebPartDefinition doesn't show calendar view #988
// https://github.com/SubPointSolutions/spmeta2/issues/988
var contentTypeDef = ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>(def =>
{
def.ParentContentTypeId = BuiltInContentTypeId.DocumentSet_Correct;
});
var listDef = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
{
//def.TemplateName = BuiltInListTemplates.DocumentLibrary.InternalName;
//def.TemplateType = BuiltInListTemplateTypeId.DocumentLibrary;
def.TemplateType = BuiltInListTemplateTypeId.DocumentLibrary;
def.ContentTypesEnabled = true;
});
var listViewDef = ModelGeneratorService.GetRandomDefinition <ListViewDefinition>(def =>
{
def.IsDefault = true;
//def.MobileDefaultView = true;
def.RowLimit = 2147483647;
def.Query = @"<Where>
<DateRangesOverlap>
<FieldRef Name=""StartDate"" />
<FieldRef Name=""_EndDate"" />
<FieldRef Name=""RecurrenceID"" />
<Value Type=""DateTime"">
<Month />
</Value>
</DateRangesOverlap>
</Where>";
def.ViewData = @"<FieldRef Name=""Title"" Type=""CalendarMonthTitle""/>
<FieldRef Name=""Title"" Type=""CalendarWeekTitle""/>
<FieldRef Name=""Location"" Type=""CalendarWeekLocation""/>
<FieldRef Name=""Title"" Type=""CalendarDayTitle""/>
<FieldRef Name=""Location"" Type=""CalendarDayLocation""/>";
def.IsPaged = false;
def.IsDefault = false;
def.Fields = new System.Collections.ObjectModel.Collection <string> {
BuiltInFieldDefinitions.Title.InternalName,
BuiltInFieldDefinitions.StartDate.InternalName,
BuiltInFieldDefinitions._EndDate.InternalName,
BuiltInFieldDefinitions.Title.InternalName,
BuiltInFieldDefinitions.Location.InternalName,
BuiltInFieldDefinitions.fAllDayEvent.InternalName,
BuiltInFieldDefinitions.fRecurrence.InternalName,
BuiltInFieldDefinitions.EventType.InternalName
};
def.Type = @"Html";
def.Types = new Collection <string> {
"Calendar",
"Recurrence"
};
});
var webpartPageDef = ModelGeneratorService.GetRandomDefinition <WebPartPageDefinition>(def =>
{
});
var calendarWebPart = ModelGeneratorService.GetRandomDefinition <ListViewWebPartDefinition>(def =>
{
def.ListId = null;
def.ListUrl = null;
def.ListTitle = listDef.Title;
def.ViewName = listViewDef.Title;
def.ChromeType = @"Default";
//def.ZoneId = @"LeftColumn",
//ZoneIndex = 0,
});
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddContentType(contentTypeDef, contentType =>
{
contentType
.AddContentTypeFieldLink(SPMeta2.BuiltInDefinitions.BuiltInFieldDefinitions.Title)
.AddContentTypeFieldLink(SPMeta2.BuiltInDefinitions.BuiltInFieldDefinitions.StartDate)
.AddContentTypeFieldLink(SPMeta2.BuiltInDefinitions.BuiltInFieldDefinitions._EndDate);
});
});
var webModel = SPMeta2Model.NewWebModel(web =>
{
web
.AddList(listDef, list =>
{
list
.AddListFieldLink(BuiltInFieldDefinitions.Location)
.AddListFieldLink(BuiltInFieldDefinitions.fAllDayEvent)
.AddListFieldLink(BuiltInFieldDefinitions.fRecurrence)
.AddListFieldLink(BuiltInFieldDefinitions.EventType)
.AddContentTypeLink(contentTypeDef)
.AddListView(listViewDef);
})
.AddHostList(BuiltInListDefinitions.SitePages, list =>
{
list
.AddWebPartPage(webpartPageDef, page =>
{
page.AddWebPart(calendarWebPart);
});
});
});
TestModel(siteModel, webModel);
}
public void Can_Reverse_Terms()
{
var siteTermStore = new TaxonomyTermStoreDefinition
{
Id = null,
Name = string.Empty,
UseDefaultSiteCollectionTermStore = true
};
var termGroup1 = new TaxonomyTermGroupDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid()
};
var termSet1 = new TaxonomyTermSetDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid(),
Contact = Rnd.String(),
Description = Rnd.String()
};
var term1 = new TaxonomyTermDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid(),
Description = Rnd.String()
};
var term2 = new TaxonomyTermDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid(),
Description = Rnd.String()
};
var term3 = new TaxonomyTermDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid(),
Description = Rnd.String()
};
// only witin a tes term group
// performance boost
var groupName = termGroup1.Name;
var options = ReverseOptions.Default
.AddFilterOption <TaxonomyTermGroupDefinition>(g => g.Name == groupName);
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddTaxonomyTermStore(siteTermStore, store =>
{
store.AddTaxonomyTermGroup(termGroup1, group =>
{
group.AddTaxonomyTermSet(termSet1, termSet =>
{
termSet.AddTaxonomyTerm(term1, t =>
{
t.AddTaxonomyTerm(term3);
});
termSet.AddTaxonomyTerm(term2);
});
});
});
});
DeployReverseAndTestModel(model, options);
}
public void CanDeploy_Default_PublishingPage_WithRequiredFields()
{
var siteFeature = BuiltInSiteFeatures.SharePointServerPublishingInfrastructure.Inherit(f => f.Enable());
var webFeature = BuiltInWebFeatures.SharePointServerPublishing.Inherit(f => f.Enable());
var publishingPageLayoutContentType = ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>(def =>
{
def.Name = string.Format("Required - {0}", Environment.TickCount);
def.Hidden = false;
def.ParentContentTypeId = BuiltInPublishingContentTypeId.ArticlePage;
});
var requiredText = ModelGeneratorService.GetRandomDefinition <TextFieldDefinition>(def =>
{
def.ShowInDisplayForm = true;
def.ShowInEditForm = true;
def.ShowInListSettings = true;
def.ShowInNewForm = true;
def.ShowInVersionHistory = true;
def.ShowInViewForms = true;
def.ValidationFormula = null;
def.ValidationMessage = null;
def.Hidden = false;
def.DefaultValue = string.Empty;
def.Required = true;
});
var publishingPageLayout = ModelGeneratorService.GetRandomDefinition <PublishingPageLayoutDefinition>(def =>
{
def.AssociatedContentTypeId = publishingPageLayoutContentType.GetContentTypeId();
});
var page = ModelGeneratorService.GetRandomDefinition <PublishingPageDefinition>(def =>
{
def.PageLayoutFileName = publishingPageLayout.FileName;
def.DefaultValues.Add(new FieldValue()
{
FieldName = requiredText.InternalName,
Value = Rnd.String()
});
});
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddSiteFeature(siteFeature);
site.AddField(requiredText);
site.AddContentType(publishingPageLayoutContentType, contentType =>
{
contentType.AddContentTypeFieldLink(requiredText);
});
});
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddWebFeature(webFeature);
web.AddHostList(BuiltInListDefinitions.Calalogs.MasterPage, list =>
{
list.AddPublishingPageLayout(publishingPageLayout);
});
web.AddHostList(BuiltInListDefinitions.Pages, list =>
{
list.AddContentTypeLink(publishingPageLayoutContentType);
list.AddPublishingPage(page);
});
});
TestModels(new[] { siteModel, webModel });
}
public void CanDeploy_XsltListViewWebPart_As_GridView()
{
// CSOM issue to get GridView on the XsltLIstViewWebPart done #725
// https://github.com/SubPointSolutions/spmeta2/issues/725
var sourceList = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
{
def.TemplateType = BuiltInListTemplateTypeId.GenericList;
});
var sourceListView = ModelGeneratorService.GetRandomDefinition <ListViewDefinition>(def =>
{
def.Title = Rnd.String();
def.Type = BuiltInViewType.Grid;
def.IsDefault = false;
def.TabularView = null;
def.Fields = new Collection <string>
{
BuiltInInternalFieldNames.ID,
BuiltInInternalFieldNames.Title
};
});
var listViewWebpart = ModelGeneratorService.GetRandomDefinition <XsltListViewWebPartDefinition>(def =>
{
def.ListId = Guid.Empty;
def.ListTitle = sourceList.Title;
def.ListUrl = string.Empty;
def.ViewName = sourceListView.Title;
def.ViewId = null;
});
var model = SPMeta2Model.NewWebModel(web =>
{
web
.AddList(sourceList, list =>
{
list.AddListView(sourceListView);
})
.AddHostList(BuiltInListDefinitions.SitePages, list =>
{
var pageName = string.Empty;
list.AddRandomWebPartPage(page =>
{
pageName = (page.Value as WebPartPageDefinition).FileName;
page.AddXsltListViewWebPart(listViewWebpart);
});
list.AddDefinitionNode(new XsltListViewWebPartGridModePresenceDefinition
{
PageFileName = pageName,
WebPartDefinitions = new List <WebPartDefinitionBase>(new[] { listViewWebpart })
}, def =>
{
def.RegExcludeFromEventsValidation();
});
});
});
TestModel(model);
}
public void CanDeploy_WebNavigationSettings_As_TaxonomyProvider()
{
var globalTerm = Rnd.String();
var currentlTerm = Rnd.String();
var currentNavigationGroup = new TaxonomyTermGroupDefinition
{
Name = string.Format("{0}", globalTerm)
};
var currentNavigationTermSet = new TaxonomyTermSetDefinition
{
Name = string.Format("{0}", globalTerm)
};
var globalNavigationGroup = new TaxonomyTermGroupDefinition
{
Name = string.Format("{0}", currentlTerm)
};
var globalNavigationTermSet = new TaxonomyTermSetDefinition
{
Name = string.Format("{0}", currentlTerm)
};
var taxWeb = ModelGeneratorService.GetRandomDefinition <WebDefinition>(def =>
{
});
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddSiteFeature(BuiltInSiteFeatures.SharePointServerPublishingInfrastructure.Inherit(def =>
{
def.Enable = true;
}));
site.AddTaxonomyTermStore(new TaxonomyTermStoreDefinition
{
UseDefaultSiteCollectionTermStore = true
},
store =>
{
store.AddTaxonomyTermGroup(currentNavigationGroup, group =>
{
group.AddTaxonomyTermSet(currentNavigationTermSet, termSet =>
{
termSet.AddRandomTerm();
termSet.AddRandomTerm();
termSet.AddRandomTerm();
});
});
store.AddTaxonomyTermGroup(globalNavigationGroup, group =>
{
group.AddTaxonomyTermSet(globalNavigationTermSet, termSet =>
{
termSet.AddRandomTerm();
termSet.AddRandomTerm();
termSet.AddRandomTerm();
});
});
});
});
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddWeb(taxWeb, subWeb =>
{
subWeb.AddSiteFeature(BuiltInWebFeatures.SharePointServerPublishing.Inherit(def =>
{
def.Enable = true;
}));
subWeb.AddWebNavigationSettings(new WebNavigationSettingsDefinition()
{
CurrentNavigationSource = BuiltInStandardNavigationSources.TaxonomyProvider,
CurrentNavigationUseDefaultSiteCollectionTermStore = true,
CurrentNavigationTermSetName = currentNavigationGroup.Name,
GlobalNavigationSource = BuiltInStandardNavigationSources.TaxonomyProvider,
GlobalNavigationUseDefaultSiteCollectionTermStore = true,
GlobalNavigationTermSetName = globalNavigationGroup.Name,
DisplayShowHideRibbonAction = true
});
});
});
TestModel(siteModel, webModel);
}
private void Internal_TaxonomyFieldBinded_ById_Within_SiteCollectionGroup(bool isTermSet, bool isTerm)
{
var termSetName = Rnd.String();
var termName = Rnd.String();
var termSet1Id = Rnd.Guid();
var termSet2Id = Rnd.Guid();
var termSet3Id = Rnd.Guid();
var term1Id = Rnd.Guid();
var term2Id = Rnd.Guid();
var term3Id = Rnd.Guid();
// same same names
var termSet1 = new TaxonomyTermSetDefinition
{
Name = termSetName,
Description = Rnd.String(),
};
var termSet2 = new TaxonomyTermSetDefinition
{
Name = termSetName,
Id = termSet2Id,
Description = Rnd.String(),
};
var termSet3 = new TaxonomyTermSetDefinition
{
Name = termSetName,
Description = Rnd.String(),
};
var term1 = new TaxonomyTermDefinition
{
Name = termName,
Description = Rnd.String(),
Id = term1Id
};
var term2 = new TaxonomyTermDefinition
{
Name = termName,
Description = Rnd.String(),
Id = term2Id,
};
var term3 = new TaxonomyTermDefinition
{
Name = termName,
Description = Rnd.String(),
Id = term3Id
};
var termGroup1 = ModelGeneratorService.GetRandomDefinition <TaxonomyTermGroupDefinition>(def =>
{
});
var termGroup2 = ModelGeneratorService.GetRandomDefinition <TaxonomyTermGroupDefinition>(def =>
{
def.IsSiteCollectionGroup = true;
});
var termGroup3 = ModelGeneratorService.GetRandomDefinition <TaxonomyTermGroupDefinition>(def =>
{
});
// binding to the 2nd one
var taxField = ModelGeneratorService.GetRandomDefinition <TaxonomyFieldDefinition>(def =>
{
def.IsSiteCollectionGroup = true;
// these should be resolvbed as we are scoped to the 2nd group within site collection group
if (isTermSet)
{
def.TermSetId = termSet2.Id;
}
if (isTerm)
{
def.TermId = term2.Id;
}
});
var taxonomyModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddRandomTermStore(termStore =>
{
termStore.AddTaxonomyTermGroup(termGroup1, group =>
{
group.AddTaxonomyTermSet(termSet1, t =>
{
t.AddTaxonomyTerm(term1);
});
});
termStore.AddTaxonomyTermGroup(termGroup2, group =>
{
group.AddTaxonomyTermSet(termSet2, t =>
{
t.AddTaxonomyTerm(term2);
});
});
termStore.AddTaxonomyTermGroup(termGroup3, group =>
{
group.AddTaxonomyTermSet(termSet3, t =>
{
t.AddTaxonomyTerm(term3);
});
});
});
});
var fieldModel = SPMeta2Model
.NewSiteModel(site =>
{
site.AddTaxonomyField(taxField);
});
TestModels(new ModelNode[] { taxonomyModel, fieldModel });
}
public void BooleanFieldDefinition_ShouldCheck_DefaultValue()
{
// Enhance BooleanFieldDefinition - add DefaultValue property validation #792
// When creating a BooleanFieldDefinition you have to use "0" and "1" for DefaultValue
// else it won't work. Neither "false" nor false.ToString() work,
// so there should be an BuiltIn option for this.
var checksTrueResult = false;
var checksFalseResult = false;
var checks1Result = false;
var checks0Result = false;
var invalidData = new Dictionary <string, bool>();
invalidData.Add("true", false);
invalidData.Add("false", false);
invalidData.Add("-1", false);
invalidData.Add("-2", false);
var validData = new Dictionary <string, bool>();
validData.Add("1", false);
validData.Add("0", false);
// expected exception
foreach (var data in invalidData.Keys.ToArray())
{
var booleanFieldDef = ModelGeneratorService.GetRandomDefinition <BooleanFieldDefinition>(def =>
{
});
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddField(booleanFieldDef);
});
var hasException = false;
try
{
booleanFieldDef.DefaultValue = data;
TestModel(model);
}
catch (Exception ex)
{
hasException = true;
invalidData[data] = IsValidException(ex);
}
if (!hasException)
{
Assert.Fail(string.Format("Fail validating value:[{0}]", data));
}
}
// no exception
foreach (var data in validData.Keys.ToArray())
{
var booleanFieldDef = ModelGeneratorService.GetRandomDefinition <BooleanFieldDefinition>(def =>
{
});
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddField(booleanFieldDef);
});
var hasException = false;
try
{
booleanFieldDef.DefaultValue = data;
TestModel(model);
}
catch (Exception ex)
{
hasException = true;
}
if (hasException)
{
Assert.Fail(string.Format("Fail validating value:[{0}]", data));
}
validData[data] = true;
}
// sum up
Assert.IsTrue(validData.Values.All(v => v == true) &&
invalidData.Values.All(v => v == true));
}
public void CanPassTypedSyntax_SiteLevel()
{
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddSharePointDesignerSettings(new SharePointDesignerSettingsDefinition());
site.AddCoreProperty(new CorePropertyDefinition())
.AddCoreProperty(new CorePropertyDefinition(), property =>
{
property.AddProfileTypeProperty(new ProfileTypePropertyDefinition());
});
site.AddAuditSettings(new AuditSettingsDefinition());
site.AddImageRendition(new ImageRenditionDefinition());
site.AddRootWeb(new RootWebDefinition());
site.AddEventReceiver(new EventReceiverDefinition());
site
.AddProperty(new PropertyDefinition())
.AddProperty(new PropertyDefinition());
site.AddFeature(new FeatureDefinition());
site.AddSiteFeature(new FeatureDefinition());
site.AddSecurityGroup(new SecurityGroupDefinition(), group =>
{
group
.AddUser(new UserDefinition())
.AddUser(new UserDefinition());
// TODO
// .AddSecurityRoleLink() is missed on SecurityGroup #601
// https://github.com/SubPointSolutions/spmeta2/issues/601
group.AddSecurityRoleLink(new SecurityRoleLinkDefinition());
group.AddSecurityRoleLink(new SecurityRoleLinkDefinition());
});
site.AddSecurityRole(new SecurityRoleDefinition());
site.AddWeb(new WebDefinition());
site.AddField(new FieldDefinition());
site.AddContentType(new ContentTypeDefinition(), contentType =>
{
contentType
.AddContentTypeFieldLink(new ContentTypeFieldLinkDefinition())
.AddModuleFile(new ModuleFileDefinition())
.AddUniqueContentTypeFieldsOrder(new UniqueContentTypeFieldsOrderDefinition())
.AddHideContentTypeFieldLinks(new HideContentTypeFieldLinksDefinition())
.AddRemoveContentTypeFieldLinks(new RemoveContentTypeFieldLinksDefinition());
});
site.AddSandboxSolution(new SandboxSolutionDefinition());
site.AddTaxonomyTermStore(new TaxonomyTermStoreDefinition(), store =>
{
store.AddTaxonomyTermGroup(new TaxonomyTermGroupDefinition(), group =>
{
group.AddTaxonomyTermSet(new TaxonomyTermSetDefinition(), termSet =>
{
termSet.AddTaxonomyTerm(new TaxonomyTermDefinition(), term =>
{
term.AddTaxonomyTerm(new TaxonomyTermDefinition());
// .AddTaxonomyTermLabel() is missed on TaxonomyTermDefinition #602
// https://github.com/SubPointSolutions/spmeta2/issues/602
term.AddTaxonomyTermLabel(new TaxonomyTermLabelDefinition());
});
});
});
});
site.AddRootWeb(new RootWebDefinition());
site.AddWeb(new WebDefinition());
site.AddUserCustomAction(new UserCustomActionDefinition());
});
}
public void CanDeploy_Default_PublishingPageLayout_With_RequiredFieldValues()
{
var siteFeature = BuiltInSiteFeatures.SharePointServerPublishingInfrastructure.Inherit(f => f.Enable());
var webFeature = BuiltInWebFeatures.SharePointServerPublishing.Inherit(f => f.Enable());
var requiredText = RItemValues.GetRequiredTextField(ModelGeneratorService);
var text1 = RItemValues.GetRandomTextField(ModelGeneratorService);
var text2 = RItemValues.GetRandomTextField(ModelGeneratorService);
var contentTypeDef = ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>(def =>
{
def.ParentContentTypeId = BuiltInPublishingContentTypeId.PageLayout;
});
var publishingPageLayoutContentType = ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>(def =>
{
def.Name = string.Format("Required - {0}", Environment.TickCount);
def.Hidden = false;
def.ParentContentTypeId = BuiltInPublishingContentTypeId.PageLayout;
});
var itemDef = ModelGeneratorService.GetRandomDefinition <PublishingPageLayoutDefinition>(def =>
{
def.ContentTypeName = contentTypeDef.Name;
def.AssociatedContentTypeId = publishingPageLayoutContentType.GetContentTypeId();
def.DefaultValues.Add(new FieldValue()
{
FieldName = requiredText.InternalName,
Value = Rnd.String()
});
def.Values.Add(new FieldValue()
{
FieldName = text1.InternalName,
Value = Rnd.String()
});
def.Values.Add(new FieldValue()
{
FieldName = text2.InternalName,
Value = Rnd.String()
});
});
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddFeature(siteFeature);
site.AddField(requiredText);
site.AddField(text1);
site.AddField(text2);
site.AddContentType(contentTypeDef, contentType =>
{
contentType.AddContentTypeFieldLink(requiredText);
contentType.AddContentTypeFieldLink(text1);
contentType.AddContentTypeFieldLink(text2);
});
site.AddContentType(publishingPageLayoutContentType);
});
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddFeature(webFeature);
web.AddList(BuiltInListDefinitions.Catalogs.MasterPage.Inherit(d =>
{
d.ContentTypesEnabled = true;
}), list =>
{
list.AddContentTypeLink(contentTypeDef);
list.AddContentTypeLink(publishingPageLayoutContentType);
list.AddPublishingPageLayout(itemDef);
});
});
TestModels(new ModelNode[] { siteModel, webModel });
}
public void ShouldPass_On_Valid_Xml()
{
var model = SPMeta2Model.NewWebModel(web =>
{
web.AddHostList(BuiltInListDefinitions.SitePages, list =>
{
// #1, web part XML
list.AddRandomWebPartPage(page =>
{
// web parts v2
page.AddWebPart(new WebPartDefinition
{
WebpartXmlTemplate = BuiltInWebPartTemplates.ContentEditorWebPart
});
// web parts v3
page.AddWebPart(new WebPartDefinition
{
WebpartXmlTemplate = BuiltInWebPartTemplates.ScriptEditorWebPart
});
});
// #2.1, bit of CAML in list view
list.AddRandomListView();
// #2.2 views with custom CAML
list.AddListView(new ListViewDefinition
{
Title = "Custom View",
Query = @"<GroupBy Collapse='TRUE' GroupLimit='30'>
<FieldRef Name='STW_FAQCategory' />
<FieldRef Name='STW_FAQQuestion' />
</GroupBy>
<OrderBy>
<FieldRef Name='ID' />
<FieldRef Name='STW_FAQQuestion' />
</OrderBy>"
});
// #3.1, Raw field XML
list.AddField(new FieldDefinition
{
Id = Guid.NewGuid(),
InternalName = Guid.NewGuid().ToString(),
FieldType = BuiltInFieldTypes.Boolean,
RawXml = @"<Field ID='{060E50AC-E9C1-4D3C-B1F9-DE0BCAC300F6}'
Name='Amount'
DisplayName='Amount'
Type='Currency'
Decimals='2'
Min='0'
Required='FALSE'
Group='Financial Columns' />"
});
// #3.2, Raw field XML
list.AddField(new FieldDefinition
{
Id = Guid.NewGuid(),
InternalName = Guid.NewGuid().ToString(),
FieldType = BuiltInFieldTypes.Boolean,
RawXml = @"<Field ID='{943E7530-5E2B-4C02-8259-CCD93A9ECB18}'
Name='CostCenter'
DisplayName='Cost Center'
Type='Choice'
Required='FALSE'
Group='Financial Columns'>
<CHOICES>
<CHOICE>Administration</CHOICE>
<CHOICE>Information</CHOICE>
<CHOICE>Facilities</CHOICE>
<CHOICE>Operations</CHOICE>
<CHOICE>Sales</CHOICE>
<CHOICE>Marketing</CHOICE>
</CHOICES>
</Field>"
});
});
});
Service.DeployModel(null, model);
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeploySimpleTaxonomyTerms()
{
// define term store
var defaultSiteTermStore = new TaxonomyTermStoreDefinition
{
UseDefaultSiteCollectionTermStore = true
};
// define group
var clientsGroup = new TaxonomyTermGroupDefinition
{
Name = "Clients"
};
// define term sets
var smallBusiness = new TaxonomyTermSetDefinition
{
Name = "Small Business"
};
var mediumBusiness = new TaxonomyTermSetDefinition
{
Name = "Medium Business"
};
var enterpriseBusiness = new TaxonomyTermSetDefinition
{
Name = "Enterprise Business"
};
// define terms
var microsoft = new TaxonomyTermDefinition
{
Name = "Microsoft"
};
var apple = new TaxonomyTermDefinition
{
Name = "Apple"
};
var oracle = new TaxonomyTermDefinition
{
Name = "Oracle"
};
var subPointSolutions = new TaxonomyTermDefinition
{
Name = "SubPoint Solutions"
};
// setup the model
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddTaxonomyTermStore(defaultSiteTermStore, termStore =>
{
termStore.AddTaxonomyTermGroup(clientsGroup, group =>
{
group
.AddTaxonomyTermSet(smallBusiness, termSet =>
{
termSet.AddTaxonomyTerm(subPointSolutions);
})
.AddTaxonomyTermSet(mediumBusiness)
.AddTaxonomyTermSet(enterpriseBusiness, termSet =>
{
termSet
.AddTaxonomyTerm(microsoft)
.AddTaxonomyTerm(apple)
.AddTaxonomyTerm(oracle);
});
});
});
});
DeployModel(model);
}
public void OnModelProcessing_ProcessedModelNodeCount()
{
// ProcessedModelNodeCount is different for single provision operation #1066
// https://github.com/SubPointSolutions/spmeta2/issues/1066
var provisionService = new TestModelServiceBase();
var hasProcessingEventHit = false;
var hasProcessedEventHit = false;
var expectedProcessingReults = new Dictionary <int, int>()
{
{ 1, 3 },
{ 2, 3 },
{ 3, 3 }
};
var expectedProcessedReults = new Dictionary <int, int>()
{
{ 1, 3 },
{ 2, 3 },
{ 3, 3 }
};
var processingResults = new Dictionary <int, int>();
var processedResults = new Dictionary <int, int>();
provisionService.OnModelNodeProcessing += (s, e) =>
{
processingResults.Add(e.ProcessedModelNodeCount, e.TotalModelNodeCount);
hasProcessingEventHit = true;
};
provisionService.OnModelNodeProcessed += (s, e) =>
{
processedResults.Add(e.ProcessedModelNodeCount, e.TotalModelNodeCount);
hasProcessedEventHit = true;
};
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddRandomField();
site.AddRandomField();
});
provisionService.ModelHandlers.Add(typeof(SiteDefinition), new EmptyModelhandler());
provisionService.ModelHandlers.Add(typeof(FieldDefinition), new EmptyModelhandler());
provisionService.DeployModel(null, model);
// hits
Assert.IsTrue(hasProcessingEventHit);
Assert.IsTrue(hasProcessedEventHit);
// processing / processed results
foreach (var result in processingResults.Keys)
{
var resultTotal = processingResults[result];
Assert.IsTrue(expectedProcessedReults.ContainsKey(result));
Assert.IsTrue(expectedProcessedReults[result] == resultTotal);
}
foreach (var result in processedResults.Keys)
{
var resultTotal = processedResults[result];
Assert.IsTrue(processedResults.ContainsKey(result));
Assert.IsTrue(processedResults[result] == resultTotal);
}
}
public void CanDeploy_CanSetupUniqueContentTypeFieldsOrder_At_OOTB_List_Scope()
{
var fieldDef = ModelGeneratorService.GetRandomDefinition <FieldDefinition>(def =>
{
def.Hidden = false;
def.ShowInDisplayForm = true;
def.ShowInEditForm = true;
def.ShowInListSettings = true;
def.ShowInNewForm = true;
def.ShowInViewForms = true;
def.AddFieldOptions = BuiltInAddFieldOptions.AddToAllContentTypes
| BuiltInAddFieldOptions.AddFieldInternalNameHint;
});
var listDef = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
{
def.ContentTypesEnabled = false;
def.TemplateType = BuiltInListTemplateTypeId.GenericList;
});
var contentTypeLinkDef = new ContentTypeLinkDefinition
{
ContentTypeName = BuiltInContentTypeNames.Item,
ContentTypeId = BuiltInContentTypeId.Item
};
var webModel = SPMeta2Model.NewWebModel(web =>
{
// adding field first
web.AddList(listDef, list =>
{
list.AddField(fieldDef, field =>
{
});
});
// then working with the content type
web.AddList(listDef.Inherit(), list =>
{
list.AddContentTypeLink(contentTypeLinkDef, contenTypeLink =>
{
contenTypeLink.RegExcludeFromEventsValidation();
contenTypeLink.AddUniqueContentTypeFieldsOrder(new UniqueContentTypeFieldsOrderDefinition
{
Fields = new List <FieldLinkValue>
{
new FieldLinkValue {
InternalName = fieldDef.InternalName
},
new FieldLinkValue {
InternalName = "Title"
},
}
});
});
});
});
TestModel(webModel);
}
private ContentTypeEnvironment GetContentTypeLinksSandbox(
Action <ModelNode, ContentTypeEnvironment> siteModelConfig,
Action <ModelNode, ContentTypeEnvironment> webModelConfig,
Action <ModelNode, ContentTypeEnvironment> listModelConfig)
{
var result = new ContentTypeEnvironment();
// site model
ContentTypeDefinition ctFirst = null;
ContentTypeDefinition ctSecond = null;
ContentTypeDefinition ctThird = null;
var siteModel = SPMeta2Model
.NewSiteModel(site =>
{
site
.AddRandomContentType(ct => { ctFirst = ct.Value as ContentTypeDefinition; })
.AddRandomContentType(ct => { ctSecond = ct.Value as ContentTypeDefinition; })
.AddRandomContentType(ct => { ctThird = ct.Value as ContentTypeDefinition; });
});
ctFirst.Name = "first_" + ctFirst.Name;
ctSecond.Name = "second_" + ctSecond.Name;
ctThird.Name = "third_" + ctThird.Name;
result.First = ctFirst;
result.Second = ctSecond;
result.Third = ctThird;
result.SiteModel = siteModel;
if (siteModelConfig != null)
{
siteModelConfig(result.SiteModel, result);
}
// web model
var webModel = SPMeta2Model
.NewWebModel(web =>
{
web
.AddRandomList(list =>
{
list
.AddContentTypeLink(ctFirst, link =>
{
result.FirstLink = link;
link.Options.RequireSelfProcessing = link.Value.RequireSelfProcessing = true;
})
.AddContentTypeLink(ctSecond, link =>
{
result.SecondLink = link;
link.Options.RequireSelfProcessing = link.Value.RequireSelfProcessing = true;
})
.AddContentTypeLink(ctThird, link =>
{
result.ThirdLink = link;
link.Options.RequireSelfProcessing = link.Value.RequireSelfProcessing = true;
});
result.List = list.Value as ListDefinition;
if (listModelConfig != null)
{
listModelConfig(list, result);
}
});
});
result.WebModel = webModel;
if (webModelConfig != null)
{
webModelConfig(result.WebModel, result);
}
return(result);
}
public void CanDeploy_CanSetupUniqueContentTypeFieldsOrder_At_List_Scope()
{
// Support 'UniqueContentTypeFieldsOrderDefinition' at list level content types #742
// https://github.com/SubPointSolutions/spmeta2/issues/742
WithDisabledPropertyUpdateValidation(() =>
{
var first = string.Empty;
var second = string.Empty;
var env = GetContentTypeSandbox(
(siteModel, e) =>
{
},
(contentTypeModel, e) =>
{
first = e.First.InternalName;
second = e.Second.InternalName;
contentTypeModel
.AddUniqueContentTypeFieldsOrder(new UniqueContentTypeFieldsOrderDefinition
{
Fields = new List <FieldLinkValue>
{
new FieldLinkValue {
InternalName = e.Second.InternalName
},
new FieldLinkValue {
InternalName = e.First.InternalName
},
}
});
});
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddRandomList(list =>
{
(list.Value as ListDefinition).ContentTypesEnabled = true;
list.AddContentTypeLink(env.ContentType, contenTypeLink =>
{
contenTypeLink.AddUniqueContentTypeFieldsOrder(new UniqueContentTypeFieldsOrderDefinition
{
Fields = new List <FieldLinkValue>
{
new FieldLinkValue {
InternalName = first
},
new FieldLinkValue {
InternalName = second
},
}
});
});
});
});
TestModel(env.SiteModel, webModel);
});
}
public void CanDeploy_Default_WebPartPage_With_RequiredFieldValues()
{
var requiredText = RItemValues.GetRequiredTextField(ModelGeneratorService);
var text1 = RItemValues.GetRandomTextField(ModelGeneratorService);
var text2 = RItemValues.GetRandomTextField(ModelGeneratorService);
var contentTypeDef = ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>(def =>
{
def.ParentContentTypeId = BuiltInContentTypeId.Item;
});
var itemDef = ModelGeneratorService.GetRandomDefinition <WebPartPageDefinition>(def =>
{
def.ContentTypeName = contentTypeDef.Name;
def.DefaultValues.Add(new FieldValue()
{
FieldName = requiredText.InternalName,
Value = Rnd.String()
});
def.Values.Add(new FieldValue()
{
FieldName = text1.InternalName,
Value = Rnd.String()
});
def.Values.Add(new FieldValue()
{
FieldName = text2.InternalName,
Value = Rnd.String()
});
});
var listDef = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
{
def.ContentTypesEnabled = true;
def.TemplateType = BuiltInListTemplateTypeId.DocumentLibrary;
});
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddField(requiredText);
site.AddField(text1);
site.AddField(text2);
site.AddContentType(contentTypeDef, contentType =>
{
contentType.AddContentTypeFieldLink(requiredText);
contentType.AddContentTypeFieldLink(text1);
contentType.AddContentTypeFieldLink(text2);
});
});
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddHostList(BuiltInListDefinitions.SitePages.Inherit(d =>
{
d.ContentTypesEnabled = true;
}), list =>
{
list.AddContentTypeLink(contentTypeDef);
list.AddWebPartPage(itemDef);
});
});
TestModel(siteModel, webModel);
}
public void CanDeploy_ContentType_And_Rename()
{
// Enhance ContentTypeDefinition - support Name renaming #924
// https://github.com/SubPointSolutions/spmeta2/issues/924
// we should be able to deploy and then rename content types
// 3 waves of deployment: original, and two renames
// all should work, including model validations with the new Names
// we need to add content type field links to ensure two paths:
// 1) model handler provisions content types
// 2) model handler resolves content type to pass further to the provision flow
var originalContentTypes = new List <ContentTypeDefinition>();
originalContentTypes.Add(ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>());
originalContentTypes.Add(ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>());
var firstRenames = originalContentTypes.Select(d =>
{
return(d.Inherit(def =>
{
def.Name = Rnd.String();
}));
});
var secondRenames = originalContentTypes.Select(d =>
{
return(d.Inherit(def =>
{
def.Name = Rnd.String();
}));
});
// deploy and test original content types
var originalModel = SPMeta2Model.NewSiteModel(site =>
{
foreach (var ct in originalContentTypes)
{
site.AddContentType(ct, contentType =>
{
contentType.AddContentTypeFieldLink(BuiltInFieldId.Title);
});
}
});
TestModel(originalModel);
// deploy and test first renames
var firstRenamesModel = SPMeta2Model.NewSiteModel(site =>
{
foreach (var ct in firstRenames)
{
site.AddContentType(ct, contentType =>
{
contentType.AddContentTypeFieldLink(BuiltInFieldId.Title);
});
}
});
TestModel(firstRenamesModel);
// deploy and test first renames
var secondRenamesModel = SPMeta2Model.NewSiteModel(site =>
{
foreach (var ct in secondRenames)
{
site.AddContentType(ct, contentType =>
{
contentType.AddContentTypeFieldLink(BuiltInFieldId.Title);
});
}
});
TestModel(secondRenamesModel);
}
public void CanDeploy_DependentLookupField_OnList()
{
var masterList = ModelGeneratorService.GetRandomDefinition<ListDefinition>();
var childList = ModelGeneratorService.GetRandomDefinition<ListDefinition>();
var lookupField = ModelGeneratorService.GetRandomDefinition<LookupFieldDefinition>(def =>
{
def.ShowInNewForm = true;
def.ShowInDisplayForm = true;
def.ShowInEditForm = true;
def.ShowInListSettings = true;
def.ShowInViewForms = true;
def.Hidden = false;
def.Required = false;
def.AllowMultipleValues = false;
#pragma warning disable 618
def.LookupListUrl = masterList.GetListUrl();
#pragma warning restore 618
});
var dependentIdLookupField = ModelGeneratorService.GetRandomDefinition<DependentLookupFieldDefinition>(
def =>
{
def.LookupField = BuiltInInternalFieldNames.ID;
def.PrimaryLookupFieldId = lookupField.Id;
});
var dependentTitleLookupField = ModelGeneratorService.GetRandomDefinition<DependentLookupFieldDefinition>(
def =>
{
def.LookupField = BuiltInInternalFieldNames.Title;
def.PrimaryLookupFieldId = lookupField.Id;
});
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddList(masterList, list =>
{
for (var i = 0; i < 10; i++)
{
list.AddListItem(new ListItemDefinition
{
Title = string.Format("master item {0} - {1}", i, Rnd.String())
});
}
});
web.AddList(childList, list =>
{
list.AddField(lookupField);
});
});
TestModel(webModel);
// add dep field
var depWebModel = SPMeta2Model.NewWebModel(web =>
{
web.AddList(childList, list =>
{
list.AddField(dependentIdLookupField);
list.AddField(dependentTitleLookupField);
list.AddListView(new ListViewDefinition
{
Title = "Test View",
Fields = new Collection<string>
{
BuiltInInternalFieldNames.Edit,
BuiltInInternalFieldNames.ID,
BuiltInInternalFieldNames.Title,
lookupField.InternalName,
dependentIdLookupField.InternalName,
dependentTitleLookupField.InternalName
},
IsDefault = true
});
});
});
TestModel(depWebModel);
}
public void CanDeploy_WebpartToWikiPageContent_As_AddToPageContent()
{
// Some web part provision on wiki page give empty markup
// https://github.com/SubPointSolutions/spmeta2/issues/693
// web part ID, zone and AddToPageContent must be as such
// you can move these params into your web part definition
var listViewWebPartDef = new ListViewWebPartDefinition
{
Title = String.Format("ListViewWebPartDefinition - {0}", Rnd.String()),
Id = "g_" + Guid.NewGuid().ToString("D").Replace('-', '_'),
ZoneIndex = 10,
ZoneId = "wpz",
AddToPageContent = true,
ListUrl = BuiltInListDefinitions.SitePages.CustomUrl
};
var webModel = SPMeta2Model
.NewWebModel(web =>
{
web
.AddHostList(BuiltInListDefinitions.SitePages, list =>
{
list
.AddRandomWikiPage(page =>
{
page.RegExcludeFromValidation();
page
.AddListViewWebPart(listViewWebPartDef)
.AddRandomWebpart(wpNode =>
{
var wp = wpNode.Value as WebPartDefinition;
wp.Id = "g_" + Guid.NewGuid().ToString("D").Replace('-', '_');
wp.ZoneId = "wpz";
wp.AddToPageContent = true;
})
.AddRandomWebpart(wpNode =>
{
var wp = wpNode.Value as WebPartDefinition;
wp.Id = "g_" + Guid.NewGuid().ToString("D").Replace('-', '_');
wp.ZoneId = "wpz";
wp.AddToPageContent = true;
})
.AddRandomWebpart(wpNode =>
{
var wp = wpNode.Value as WebPartDefinition;
wp.Id = "g_" + Guid.NewGuid().ToString("D").Replace('-', '_');
wp.ZoneId = "wpz";
wp.AddToPageContent = true;
})
;
});
});
});
TestModel(webModel);
}
private ContentTypeEnvironment GetContentTypeSandbox(
Action <ModelNode, ContentTypeEnvironment> siteModelConfig,
Action <ModelNode, ContentTypeEnvironment> contentTypeModelConfig)
{
var result = new ContentTypeEnvironment();
// site model
FieldDefinition fldFirst = null;
FieldDefinition fldSecond = null;
FieldDefinition fldThird = null;
var siteModel = SPMeta2Model
.NewSiteModel(site =>
{
site
.AddRandomField(ct => { fldFirst = ct.Value as FieldDefinition; })
.AddRandomField(ct => { fldSecond = ct.Value as FieldDefinition; })
.AddRandomField(ct => { fldThird = ct.Value as FieldDefinition; })
.AddRandomContentType(contentType =>
{
fldFirst.Title = "first_" + fldFirst.Title;
fldSecond.Title = "second_" + fldSecond.Title;
fldThird.Title = "third_" + fldThird.Title;
result.First = fldFirst;
result.Second = fldSecond;
result.Third = fldThird;
result.ContentType = contentType.Value as ContentTypeDefinition;
contentType
.AddContentTypeFieldLink(fldFirst, link =>
{
result.FirstLink = link;
link.Options.RequireSelfProcessing = link.Value.RequireSelfProcessing = true;
})
.AddContentTypeFieldLink(fldSecond, link =>
{
result.SecondLink = link;
link.Options.RequireSelfProcessing = link.Value.RequireSelfProcessing = true;
})
.AddContentTypeFieldLink(fldThird, link =>
{
result.ThirdLink = link;
link.Options.RequireSelfProcessing = link.Value.RequireSelfProcessing = true;
});
if (contentTypeModelConfig != null)
{
contentTypeModelConfig(contentType, result);
}
});
});
result.SiteModel = siteModel;
if (siteModelConfig != null)
{
siteModelConfig(result.SiteModel, result);
}
return(result);
}
public void CanPassTypedSyntax_WebLevel()
{
var model = SPMeta2Model.NewWebModel(web =>
{
web.AddClearRecycleBin(new ClearRecycleBinDefinition());
web
.AddAnonymousAccessSettings(new AnonymousAccessSettingsDefinition())
.AddAnonymousAccessSettings(new AnonymousAccessSettingsDefinition());
web.AddAuditSettings(new AuditSettingsDefinition());
web.AddWebNavigationSettings(new WebNavigationSettingsDefinition());
web.AddPageLayoutAndSiteTemplateSettings(new PageLayoutAndSiteTemplateSettingsDefinition());
web.AddRootWeb(new RootWebDefinition());
web.AddComposedLookItemLink(new ComposedLookItemLinkDefinition());
web.AddTreeViewSettings(new TreeViewSettingsDefinition());
web.AddTopNavigationNode(new TopNavigationNodeDefinition());
web.AddQuickLaunchNavigationNode(new QuickLaunchNavigationNodeDefinition());
web.AddMasterPageSettings(new MasterPageSettingsDefinition());
web.AddRegionalSettings(new RegionalSettingsDefinition());
web.AddSP2013Workflow(new SP2013WorkflowDefinition());
web.AddWelcomePage(new WelcomePageDefinition());
web.AddEventReceiver(new EventReceiverDefinition());
web
.AddProperty(new PropertyDefinition())
.AddProperty(new PropertyDefinition());
web.AddFeature(new FeatureDefinition());
web.AddWebFeature(new FeatureDefinition());
//web.AddSecurityGroup(new SecurityGroupDefinition());
//web.AddSecurityRole(new SecurityRoleDefinition());
web.AddWeb(new WebDefinition());
web.AddField(new FieldDefinition());
web.AddContentType(new ContentTypeDefinition());
web.AddUserCustomAction(new UserCustomActionDefinition());
web.AddList(new ListDefinition(), list =>
{
list.AddDiscussionItem(new DiscussionItemDefinition(), item =>
{
item.AddDiscussionReplyItem(new DiscussionReplyItemDefinition());
});
list.AddDocumentSet(new DocumentSetDefinition());
list.AddAuditSettings(new AuditSettingsDefinition());
list.AddMasterPage(new MasterPageDefinition());
list.AddHtmlMasterPage(new HtmlMasterPageDefinition());
list
.AddProperty(new PropertyDefinition())
.AddProperty(new PropertyDefinition());
list.AddUniqueContentTypeOrder(new UniqueContentTypeOrderDefinition());
list.AddHideContentTypeLinks(new HideContentTypeLinksDefinition());
list.AddRemoveContentTypeLinks(new RemoveContentTypeLinksDefinition());
list.AddModuleFile(new ModuleFileDefinition(), moduleFile =>
{
moduleFile.AddSecurityGroupLink(new SecurityGroupDefinition(), group =>
{
group
.AddSecurityRoleLink(BuiltInSecurityRoleNames.Edit)
.AddSecurityRoleLink(BuiltInSecurityRoleNames.Design)
.AddSecurityRoleLink(BuiltInSecurityRoleNames.Approve);
});
});
list.AddUserCustomAction(new UserCustomActionDefinition());
list.AddReusableHTMLItem(new ReusableHTMLItemDefinition());
list.AddReusableTextItem(new ReusableTextItemDefinition());
list.AddPublishingPage(new PublishingPageDefinition());
list.AddPublishingPageLayout(new PublishingPageLayoutDefinition());
list.AddComposedLookItem(new ComposedLookItemDefinition());
list.AddWelcomePage(new WelcomePageDefinition());
list.AddEventReceiver(new EventReceiverDefinition());
list.AddField(new FieldDefinition());
list.AddContentTypeLink(new ContentTypeLinkDefinition());
list.AddListView(new ListViewDefinition(), listView =>
{
// Enhance 'WebPartDefinition' provision - enabne privision under list views #590
// https://github.com/SubPointSolutions/spmeta2/issues/590
listView.AddDeleteWebParts(new DeleteWebPartsDefinition());
listView.AddWebPart(new WebPartDefinition());
});
list.AddListItem(new ListItemDefinition(), listItem =>
{
listItem
.AddListItemFieldValue(new ListItemFieldValueDefinition())
.AddListItemFieldValues(new ListItemFieldValuesDefinition());
});
list.AddFolder(new FolderDefinition(), folder =>
{
folder
.AddProperty(new PropertyDefinition())
.AddProperty(new PropertyDefinition())
.AddDocumentSet(new DocumentSetDefinition())
.AddWelcomePage(new WelcomePageDefinition())
.AddFolder(new FolderDefinition())
.AddListItem(new ListItemDefinition());
});
list.AddWebPartPage(new WebPartPageDefinition(), page =>
{
page.AddDeleteWebParts(new DeleteWebPartsDefinition());
page.AddWebPart(new WebPartDefinition());
});
list.AddWikiPage(new WikiPageDefinition(), page =>
{
page.AddDeleteWebParts(new DeleteWebPartsDefinition());
page.AddWebPart(new WebPartDefinition());
});
list.AddPublishingPage(new PublishingPageDefinition(), page =>
{
page.AddDeleteWebParts(new DeleteWebPartsDefinition());
page.AddWebPart(new WebPartDefinition());
});
});
});
}
public void CanDeploy_WebpartToPublishingPageContent()
{
var webModel = SPMeta2Model
.NewWebModel(web =>
{
web
.AddHostList(BuiltInListDefinitions.Pages, list =>
{
list
.AddRandomPublishingPage(page =>
{
var id_1 = "g_" + Guid.NewGuid().ToString("D").Replace('-', '_');
var id_2 = "g_" + Guid.NewGuid().ToString("D").Replace('-', '_');
var id_3 = "g_" + Guid.NewGuid().ToString("D").Replace('-', '_');
var wpId11 = id_1
.Replace("g_", string.Empty)
.Replace("_", "-");
var wpId22 = id_2
.Replace("g_", string.Empty)
.Replace("_", "-");
var pageTemplate = new StringBuilder();
pageTemplate.AppendFormat("<div class='ms-rtestate-read ms-rte-wpbox' contentEditable='false'>");
pageTemplate.AppendFormat(" <div class='ms-rtestate-read {0}' id='div_{0}'>", wpId11);
pageTemplate.AppendFormat(" </div>");
pageTemplate.AppendFormat("</div>");
pageTemplate.AppendFormat("<div>");
pageTemplate.AppendFormat(" SPMeta2 publishing page.");
pageTemplate.AppendFormat("</div>");
pageTemplate.AppendFormat("<div class='ms-rtestate-read ms-rte-wpbox' contentEditable='false'>");
pageTemplate.AppendFormat(" <div class='ms-rtestate-read {0}' id='div_{0}'>", wpId22);
pageTemplate.AppendFormat(" </div>");
pageTemplate.AppendFormat("</div>");
(page.Value as PublishingPageDefinition).Content = pageTemplate.ToString();
page
.AddRandomWebpart(wpNode =>
{
var wp = wpNode.Value as WebPartDefinition;
wp.ZoneId = "wpz";
wp.Id = id_1;
wp.AddToPageContent = true;
})
.AddRandomWebpart(wpNode =>
{
var wp = wpNode.Value as WebPartDefinition;
wp.ZoneId = "wpz";
wp.Id = id_2;
wp.AddToPageContent = true;
})
.AddRandomWebpart(wpNode =>
{
var wp = wpNode.Value as WebPartDefinition;
wp.ZoneId = "wpz";
wp.Id = id_3;
wp.AddToPageContent = true;
});
});
});
});
TestModel(webModel);
}
protected virtual IEnumerable<Stream> CreateMetaPackPackages()
{
var result = new List<Stream>();
// pack model
var solutionPackage = GetSolutionPackageTemplate();
// update version and add model
solutionPackage.Version = "0.1.0-beta1";
var assemblyDirectoryPath = Path.GetDirectoryName(GetType().Assembly.Location);
var jQueryDirectoryPath = Path.Combine(assemblyDirectoryPath, "jQuery");
if (!Directory.Exists(jQueryDirectoryPath))
throw new Exception(string.Format("Cannot find directory:[{0}]", jQueryDirectoryPath));
var jQueryVersionFolderPaths = Directory.GetDirectories(jQueryDirectoryPath);
foreach (var versionFolderPath in jQueryVersionFolderPaths)
{
var jQueryVersion = Path.GetFileName(versionFolderPath);
var versionFolderName = (new DirectoryInfo(versionFolderPath)).Name;
var filePaths = Directory.GetFiles(versionFolderPath, "*.*");
// create model
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddHostList(BuiltInListDefinitions.StyleLibrary, list =>
{
list.AddFolder(new FolderDefinition { Name = "jQuery" }, jQueryFolder =>
{
jQueryFolder.AddFolder(new FolderDefinition { Name = versionFolderName }, folder =>
{
foreach (var filePath in filePaths)
{
folder.AddModuleFile(new ModuleFileDefinition
{
FileName = Path.GetFileName(filePath),
Content = File.ReadAllBytes(filePath)
});
}
});
});
});
});
// save solution to XML file
var xmlContext = SPMeta2Model.ToXML(webModel);
// create ModelContainerBase, put serialized model there
var modelContainer = new ModelContainerBase
{
Model = Encoding.UTF8.GetBytes(xmlContext),
};
modelContainer.AdditionalOptions.Add(new OptionValue
{
Name = "_metapack.model.id",
Value = string.Format("jQuery.{0}", jQueryVersion)
});
solutionPackage.AddModel(modelContainer);
}
// pack to NuGet package
var packageService = new SPMeta2SolutionPackageService();
var solutionPackageStream = packageService.Pack(solutionPackage);
// add to result strems
result.Add(solutionPackageStream);
return result;
}
