public void CanDeploy_Simple_Site_UnderRandomManagedPath()
{
// /some-path/some-site
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var managedPath = ModelGeneratorService.GetRandomDefinition <PrefixDefinition>(def =>
{
def.PrefixType = "WildcardInclusion";
});
var site = ModelGeneratorService.GetRandomDefinition <SiteDefinition>(def =>
{
def.PrefixName = managedPath.Path;
});
var model = SPMeta2Model.NewWebApplicationModel(webApplication =>
{
webApplication.AddPrefix(managedPath);
webApplication.AddSite(site);
});
TestModel(model);
});
}
public void CanDeploy_Simple_Site_UnderRandomManagedPath_AsRoot()
{
// /some-path/
// Enhance SiteDefinition provision - enable provision under the managed path #853
// https://github.com/SubPointSolutions/spmeta2/issues/853
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var managedPath = ModelGeneratorService.GetRandomDefinition <PrefixDefinition>(def =>
{
def.PrefixType = BuiltInPrefixTypes.ExplicitInclusion;
});
var site = ModelGeneratorService.GetRandomDefinition <SiteDefinition>(def =>
{
def.Url = "/";
def.PrefixName = managedPath.Path;
});
var model = SPMeta2Model.NewWebApplicationModel(webApplication =>
{
webApplication.AddPrefix(managedPath);
webApplication.AddSite(site);
});
TestModel(model);
});
}
public void CanDeploy_Job_UnderWebApplication()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
// OOTB job with 2 parameters for the constructor
var webAppJobDefinition = new JobDefinition
{
Name = Rnd.String(),
Title = Rnd.String(),
ScheduleString = "yearly at jan 1 09:00:00",
JobType = "Microsoft.SharePoint.Administration.SPDeadSiteDeleteJobDefinition, Microsoft.SharePoint",
ConstructorParams = new Collection <JobDefinitionCtorParams>()
{
JobDefinitionCtorParams.JobName,
JobDefinitionCtorParams.WebApplication
}
};
var model = SPMeta2Model
.NewWebApplicationModel(webApp =>
{
webApp.AddJob(webAppJobDefinition);
});
TestModel(model);
});
}
public void CanDeploy_WebConfigModification_As_EnsureChildNode()
{
if (!TestOptions.EnablWebConfigModificationTest)
{
return;
}
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var childNodeConfig = ModelGeneratorService.GetRandomDefinition <WebConfigModificationDefinition>(def =>
{
var key = string.Format("key{0}", Rnd.String(8));
var value = string.Format("value{0}", Rnd.String(8));
def.Path = string.Format("configuration/appSettings");
def.Name = string.Format("add[@key='{0}']", key);
def.Sequence = Rnd.UInt(100);
def.Owner = string.Format("WebConfigModifications{0}", Rnd.String(8));
def.Type = BuiltInWebConfigModificationType.EnsureChildNode;
def.Value = string.Format(@"<add key=""{0}"" value=""{1}"" />", key, value);
});
var model = SPMeta2Model
.NewWebApplicationModel(webApp =>
{
webApp.AddWebConfigModification(childNodeConfig);
});
TestModel(model);
});
}
public void CanDeploy_WebConfigModification_As_EnsureAttribute()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var attributeNodeConfig =
ModelGeneratorService.GetRandomDefinition <WebConfigModificationDefinition>(def =>
{
var key = string.Format("key{0}", Rnd.String(8));
var value = string.Format("value{0}", Rnd.String(8));
def.Path = string.Format("configuration/appSettings");
def.Name = string.Format("{0}", key);
def.Sequence = Rnd.UInt(100);
def.Owner = string.Format("WebConfigModifications{0}", Rnd.String(8));
def.Type = BuiltInWebConfigModificationType.EnsureAttribute;
def.Value = string.Format(@"{0}", value);
});
var model = SPMeta2Model
.NewWebApplicationModel(webApp =>
{
webApp.AddWebConfigModification(attributeNodeConfig);
});
TestModel(model);
});
}
public void CanDeploy_JobDefinition_WithProps()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var jobDef = ModelGeneratorService.GetRandomDefinition <JobDefinition>(def =>
{
def.Properties.Add(new JobDefinitionProperty
{
Key = string.Format("string_prop_{0}", Rnd.String()),
Value = string.Format("value_{0}", Rnd.String()),
});
def.Properties.Add(new JobDefinitionProperty
{
Key = string.Format("int_prop_{0}", Rnd.String()),
Value = Rnd.Int()
});
def.Properties.Add(new JobDefinitionProperty
{
Key = string.Format("double_prop_{0}", Rnd.String()),
Value = Math.Floor(Rnd.Double())
});
});
var model = SPMeta2Model.NewWebApplicationModel(webApp =>
{
webApp.AddJob(jobDef);
});
TestModel(model);
});
}
public void CanPassTypedSyntax_WebApplicationLevel()
{
var model = SPMeta2Model.NewWebApplicationModel(webApplication =>
{
webApplication
.AddProperty(new PropertyDefinition())
.AddProperty(new PropertyDefinition());
webApplication.AddFeature(new FeatureDefinition());
webApplication.AddWebApplicationFeature(new FeatureDefinition());
webApplication.AddAlternateUrl(new AlternateUrlDefinition());
webApplication.AddSite(new SiteDefinition());
webApplication.AddPrefix(new PrefixDefinition());
webApplication.AddContentDatabase(new ContentDatabaseDefinition());
webApplication.AddOfficialFileHost(new OfficialFileHostDefinition());
webApplication.AddSuiteBar(new SuiteBarDefinition());
webApplication.AddFarmSolution(new FarmSolutionDefinition());
});
}
public void CanDeploy_WebConfigModification_As_EnsureSection()
{
if (!TestOptions.EnablWebConfigModificationTest)
{
return;
}
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var ensureSectionNodeConfig =
ModelGeneratorService.GetRandomDefinition <WebConfigModificationDefinition>(def =>
{
def.Path = string.Format("configuration/appSettings");
def.Name = string.Format("testSection{0}", Rnd.String(8));
def.Sequence = Rnd.UInt(100);
def.Owner = string.Format("WebConfigModifications{0}", Rnd.String(8));
def.Type = BuiltInWebConfigModificationType.EnsureSection;
});
var model = SPMeta2Model
.NewWebApplicationModel(webApp =>
{
webApp.AddWebConfigModification(ensureSectionNodeConfig);
});
TestModel(model);
});
}
protected virtual void TestFarmSolutionModel(FarmSolutionDefinition solutionDef, bool isWebApplicationLevel)
{
var newSolutiondef = solutionDef.Inherit();
if (isWebApplicationLevel)
{
var originalModel = SPMeta2Model.NewWebApplicationModel(webApp =>
{
webApp.AddFarmSolution(solutionDef);
});
var newModel = SPMeta2Model.NewWebApplicationModel(farm =>
{
farm.AddFarmSolution(newSolutiondef);
});
TestModel(originalModel);
TestModel(newModel);
}
else
{
var originalModel = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddFarmSolution(solutionDef);
});
var newModel = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddFarmSolution(newSolutiondef);
});
TestModel(originalModel);
TestModel(newModel);
}
}
public void CanDeploy_WebApplicationModel()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var model = SPMeta2Model.NewWebApplicationModel(m => { });
TestModel(model);
});
}
public void Should_Pass_On_Valid_SSOM_Invalid_CSOM()
{
var model = SPMeta2Model.NewWebApplicationModel(webApp =>
{
webApp.AddSite(ModelGeneratorService.GetRandomDefinition <SiteDefinition>());
});
// - CSOM / + SSOM
Assert.IsFalse(SPMeta2Model.IsCSOMCompatible(model));
Assert.IsTrue(SPMeta2Model.IsSSOMCompatible(model));
}
public void CanDeploy_PropertyBag_OnWebApplication()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var model = SPMeta2Model
.NewWebApplicationModel(webApp =>
{
webApp.AddRandomPropertyBag();
});
TestModel(model);
});
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeploySimplePrefixDefinition()
{
var prefixDef = new PrefixDefinition
{
Path = "projects",
PrefixType = BuiltInPrefixTypes.WildcardInclusion
};
var model = SPMeta2Model.NewWebApplicationModel(webApp =>
{
webApp.AddPrefix(prefixDef);
});
DeployModel(model);
}
public void CanDeploy_Simple_Site()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var site = ModelGeneratorService.GetRandomDefinition <SiteDefinition>();
site.PrefixName = string.Empty;
var model = SPMeta2Model.NewWebApplicationModel(webApplication =>
{
webApplication.AddSite(site);
});
TestModel(model);
});
}
public void CanDeploy_Simple_Site_UnderSitesManagedPath()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var site = ModelGeneratorService.GetRandomDefinition <SiteDefinition>(def =>
{
def.PrefixName = "sites";
});
var model = SPMeta2Model.NewWebApplicationModel(webApplication =>
{
webApplication.AddSite(site);
});
TestModel(model);
});
}
public void SPMeta2Model_NewWebAppModel_Contract()
{
var expectedType = typeof(WebApplicationModelNode);
var newDefinition = new WebApplicationDefinition();
// new
Assert.IsTrue(SPMeta2Model.NewWebApplicationModel().GetType() == expectedType);
// new with callback
Assert.IsTrue(SPMeta2Model.NewWebApplicationModel(model => { }).GetType() == expectedType);
// new definition
Assert.IsTrue(SPMeta2Model.NewWebApplicationModel(newDefinition).GetType() == expectedType);
// new definition with callback
Assert.IsTrue(SPMeta2Model.NewWebApplicationModel(newDefinition, farm => { }).GetType() == expectedType);
}
public void CanPassTypedSyntax_WebApplicationLevel()
{
var model = SPMeta2Model.NewWebApplicationModel(webApplication =>
{
webApplication.AddProperty(new PropertyDefinition());
webApplication.AddFeature(new FeatureDefinition());
webApplication.AddWebApplicationFeature(new FeatureDefinition());
webApplication.AddAlternateUrl(new AlternateUrlDefinition());
webApplication.AddSite(new SiteDefinition());
webApplication.AddPrefix(new PrefixDefinition());
webApplication.AddContentDatabase(new ContentDatabaseDefinition());
});
}
public void CanDeploy_WebApplicationFeature()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var model = SPMeta2Model
.NewWebApplicationModel(webApp =>
{
webApp.AddFeature(new FeatureDefinition
{
Enable = true,
ForceActivate = true,
Id = BuiltInWebApplicationFeatures.DocumentSetsMetadataSynchronization.Id,
Scope = FeatureDefinitionScope.WebApplication
});
});
TestModel(model);
});
}
public void CanDeploy_Simple_Site_WithNullableSecondaryContactLogin()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var site = ModelGeneratorService.GetRandomDefinition <SiteDefinition>();
//site.PrefixName = string.Empty;
site.SecondaryContactEmail = null;
site.SecondaryContactLogin = null;
site.SecondaryContactName = null;
var model = SPMeta2Model.NewWebApplicationModel(webApplication =>
{
webApplication.AddSite(site);
});
TestModel(model);
});
}
public void Deploy_WebApplicationModel_SSOM()
{
// setup url
var webAppUrl = "";
// create you model
var webAppModel = SPMeta2Model.NewWebApplicationModel(webApp =>
{
});
var spWebApp = SPWebApplication.Lookup(new Uri(webAppUrl));
// deploy site model with SharePoint Foundation SSOM API
var foundationProvisionService = new SSOMProvisionService();
foundationProvisionService.DeployWebApplicationModel(spWebApp, webAppModel);
// deploy site model with SharePoint Standard SSOM API
var standardProvisionService = new StandardSSOMProvisionService();
standardProvisionService.DeployWebApplicationModel(spWebApp, webAppModel);
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeploySimpleAlternateUrlDefinition()
{
var internalDef = new AlternateUrlDefinition
{
Url = "http://the-portal",
UrlZone = BuiltInUrlZone.Intranet
};
var intranetDef = new AlternateUrlDefinition
{
Url = "http://my-intranet.com.au",
UrlZone = BuiltInUrlZone.Internet
};
var model = SPMeta2Model.NewWebApplicationModel(webApp =>
{
webApp.AddAlternateUrl(internalDef);
webApp.AddAlternateUrl(intranetDef);
});
DeployModel(model);
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeploySimpleContentDatabaseDefinition()
{
var contentDb1 = new ContentDatabaseDefinition
{
ServerName = "localhost",
DbName = "intranet_content_db1"
};
var contentDb2 = new ContentDatabaseDefinition
{
ServerName = "localhost",
DbName = "intranet_content_db2"
};
var model = SPMeta2Model.NewWebApplicationModel(webApp =>
{
webApp
.AddContentDatabase(contentDb1)
.AddContentDatabase(contentDb2);
});
DeployModel(model);
}
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);
}
});
});
}
public ModelNode GenerateModelTreeForDefinition(Type definitionType, SPObjectModelType objectModelType)
{
ModelNode result = null;
var rootHostType = GetRootHostType(definitionType, objectModelType);
var parentHostType = GetParentHostType(definitionType, objectModelType);
var currentDefinition = GetRandomDefinition(definitionType);
var expectManyInstancesAttr = definitionType.GetCustomAttribute <ExpectManyInstances>(false);
var manyInstances = new List <DefinitionBase>();
if (expectManyInstancesAttr != null)
{
var maxCount = expectManyInstancesAttr.MinInstancesCount +
Rnd.Int(expectManyInstancesAttr.MaxInstancesCount -
expectManyInstancesAttr.MinInstancesCount);
for (int i = 0; i < maxCount; i++)
{
manyInstances.Add(GetRandomDefinition(definitionType));
}
}
CurrentDefinitions.Clear();
CurrentDefinitions.Add(currentDefinition);
CurrentDefinitions.AddRange(manyInstances);
//CurrentDefinition = currentDefinition;
var defs = new List <GeneratedNodes>();
LookupModelTree(rootHostType, definitionType, defs, objectModelType);
if (defs.Count > 0)
{
defs.Reverse();
var rootHost = defs[0].ModelNode;
parentHostType = rootHost.Value.GetType();
defs.RemoveAt(0);
ModelNode model = null;
if (parentHostType == typeof(FarmDefinition))
{
model = SPMeta2Model.NewFarmModel();
}
if (parentHostType == typeof(WebApplicationDefinition))
{
model = SPMeta2Model.NewWebApplicationModel();
}
if (parentHostType == typeof(SiteDefinition))
{
model = SPMeta2Model.NewSiteModel();
}
if (parentHostType == typeof(WebDefinition))
{
model = SPMeta2Model.NewWebModel();
}
var _m = model;
foreach (var def in defs)
{
_m.ChildModels.Add(def.ModelNode);
_m = def.ModelNode;
}
_m.AddDefinitionNode(currentDefinition);
foreach (var manyDef in manyInstances)
{
_m.AddDefinitionNode(manyDef);
}
result = model;
}
else
{
ModelNode resultModel = null;
if (currentDefinition.GetType() == typeof(FarmDefinition))
{
resultModel = SPMeta2Model.NewFarmModel();
}
if (currentDefinition.GetType() == typeof(WebApplicationDefinition))
{
resultModel = SPMeta2Model.NewWebApplicationModel();
}
if (currentDefinition.GetType() == typeof(SiteDefinition))
{
resultModel = SPMeta2Model.NewSiteModel();
}
if (currentDefinition.GetType() == typeof(WebDefinition))
{
resultModel = SPMeta2Model.NewWebModel();
}
if (resultModel == null)
{
throw new SPMeta2NotImplementedException(string.Format("Cannot find host model for type:[{0}]. Ensure correct RootHostAttribute/ParentHostAttribute/SPObjectTypeAttribute attributes.", definitionType.AssemblyQualifiedName));
}
resultModel.Value = currentDefinition;
result = resultModel;
}
// ProcessAdditionalArtifacts(result, defs);
return(result);
}
protected virtual SolutionPackageBase CreateNewSolutionPackage(
NuGetSolutionPackageService service,
Action <SolutionPackageBase> action,
RegressinModelLevel modelLevel)
{
var knownPackageType = false;
SolutionPackageBase solutionPackage = null;
if (service is SPMeta2SolutionPackageService)
{
var m2package = new SolutionPackageBase();
m2package.Name = "SPMeta2 CI Package Name";
m2package.Title = "SPMeta2 CI Package Title";
m2package.Description = "SPMeta2 CI Package description";
m2package.Id = "MetaPack.SPMeta2.CI";
m2package.Authors = "SubPoint Solutions Authors";
m2package.Company = "SubPoint Solutions Company";
m2package.Version = "1.0.0.0";
m2package.Owners = "SubPoint Solutions Owners";
m2package.ReleaseNotes = "ReleaseNotes";
m2package.Summary = "Summary";
m2package.ProjectUrl = "https://github.com/SubPointSolutions/metapack";
m2package.IconUrl = "https://github.com/SubPointSolutions/metapack/metapack.png";
m2package.LicenseUrl = "https://opensource.org/licenses/MIT";
m2package.Copyright = "Some copyright here";
m2package.Tags = "CI SPMeta2 MetaPack Tags";
var models = new List <ModelNode>();
switch (modelLevel)
{
case RegressinModelLevel.Farm:
models.Add(SPMeta2Model.NewFarmModel(farm => { }));
break;
case RegressinModelLevel.WebApplication:
models.Add(SPMeta2Model.NewWebApplicationModel(webApp => { }));
break;
case RegressinModelLevel.Site:
models.Add(SPMeta2Model.NewSiteModel(site => { }));
models.Add(SPMeta2Model.NewWebModel(web => { }));
break;
case RegressinModelLevel.Web:
models.Add(SPMeta2Model.NewWebModel(web => { }));
break;
case RegressinModelLevel.Subweb:
models.Add(SPMeta2Model.NewWebModel(web => { }));
break;
default:
throw new NotImplementedException(string.Format(
"Unsupported model level:[{0}] for model genaration",
modelLevel));
}
var index = 0;
foreach (var model in models)
{
index++;
var xmlContext = SPMeta2Model.ToXML(model);
var modelContainer = new ModelContainerBase
{
Model = Encoding.UTF8.GetBytes(xmlContext),
};
modelContainer.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.Model.Order.Id,
Value = index.ToString()
});
m2package.AddModel(modelContainer);
}
m2package.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.SolutionToolPackage.PackageId.Id,
Value = "MetaPack.SPMeta2"
});
solutionPackage = m2package;
}
if (service is SharePointPnPSolutionPackageService)
{
var pnpPackage = new SolutionPackageBase();
pnpPackage.Name = "SharePointPnP CI Package Name";
pnpPackage.Title = "SharePointPnP Package Title";
pnpPackage.Description = "SPMeta2 CI Package description";
pnpPackage.Id = "MetaPack.SharePointPnP.CI";
pnpPackage.Authors = "SubPoint Solutions Authors";
pnpPackage.Company = "SubPoint Solutions Company";
pnpPackage.Version = "1.0.0.0";
pnpPackage.Owners = "SubPoint Solutions Owners";
pnpPackage.ReleaseNotes = "ReleaseNotes";
pnpPackage.Summary = "Summary";
pnpPackage.ProjectUrl = "https://github.com/SubPointSolutions/metapack";
pnpPackage.IconUrl = "https://github.com/SubPointSolutions/metapack/metapack.png";
pnpPackage.LicenseUrl = "https://opensource.org/licenses/MIT";
pnpPackage.Copyright = "Some copyright here";
pnpPackage.Tags = "CI SPMeta2 MetaPack Tags";
// TODO
// Zip up and set the model type
var asmFolder = Path.GetDirectoryName(GetType().Assembly.Location);
var foldersPath = Path.Combine(asmFolder, @"Data/PnPTemplates/Folders");
var openXmlFolderPath = Path.Combine(asmFolder, @"Data/PnPTemplates/OpenXML");
foreach (var templateFolder in Directory.GetDirectories(foldersPath))
{
// package up into zip
var templateFolderZipFile = GetTempZipFilePath();
ZipFile.CreateFromDirectory(templateFolder, templateFolderZipFile);
var modelContainer = new ModelContainerBase
{
Model = System.IO.File.ReadAllBytes(templateFolderZipFile),
};
modelContainer.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.Model.Type.Id,
Value = "SharePointPnP.FolderZip"
});
pnpPackage.AddModel(modelContainer);
}
var openXmlPackages = Directory.GetFiles(openXmlFolderPath, "*.pnp");
foreach (var file in openXmlPackages)
{
var modelContainer = new ModelContainerBase
{
Model = System.IO.File.ReadAllBytes(file),
};
modelContainer.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.Model.Type.Id,
Value = "SharePointPnP.OpenXml"
});
pnpPackage.AddModel(modelContainer);
}
pnpPackage.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.SolutionToolPackage.PackageId.Id,
Value = "MetaPack.SharePointPnP"
});
solutionPackage = pnpPackage;
}
if (solutionPackage == null)
{
throw new NotImplementedException(string.Format(
"Unknown service type:[{0}]", service.GetType()));
}
if (action != null)
{
action(solutionPackage);
}
return(solutionPackage);
}
public ModelNode GenerateModelTreeForDefinition <TDefinition>(SPObjectModelType objectModelType)
where TDefinition : DefinitionBase, new()
{
ModelNode result = null;
var rootHostType = GetRootHostType <TDefinition>(objectModelType);
var parentHostType = GetParentHostType <TDefinition>(objectModelType);
var currentDefinition = GetRandomDefinition <TDefinition>();
CurrentDefinition = currentDefinition;
var defs = new List <GeneratedArtifact>();
LookupModelTree <TDefinition>(rootHostType, defs, objectModelType);
if (defs.Count > 0)
{
defs.Reverse();
var rootHost = defs[0].Definition;
parentHostType = rootHost.GetType();
defs.RemoveAt(0);
ModelNode model = null;
if (parentHostType == typeof(FarmDefinition))
{
model = SPMeta2Model.NewFarmModel();
}
if (parentHostType == typeof(WebApplicationDefinition))
{
model = SPMeta2Model.NewWebApplicationModel();
}
if (parentHostType == typeof(SiteDefinition))
{
model = SPMeta2Model.NewSiteModel();
}
if (parentHostType == typeof(WebDefinition))
{
model = SPMeta2Model.NewWebModel();
}
var _m = model;
foreach (var def in defs)
{
_m
.AddDefinitionNode(def.Definition, currentDef =>
{
currentDef.Options.RequireSelfProcessing = def.Definition.RequireSelfProcessing;
_m = currentDef;
});
}
_m.AddDefinitionNode(currentDefinition);
result = model;
}
else
{
ModelNode resultModel = null;
if (currentDefinition.GetType() == typeof(FarmDefinition))
{
resultModel = SPMeta2Model.NewFarmModel();
}
if (currentDefinition.GetType() == typeof(WebApplicationDefinition))
{
resultModel = SPMeta2Model.NewWebApplicationModel();
}
if (currentDefinition.GetType() == typeof(SiteDefinition))
{
resultModel = SPMeta2Model.NewSiteModel();
}
if (currentDefinition.GetType() == typeof(WebDefinition))
{
resultModel = SPMeta2Model.NewWebModel();
}
if (resultModel == null)
{
throw new SPMeta2NotImplementedException(string.Format("Cannot find host model for type:[{0}]. Ensure correct RootHostAttribute/ParentHostAttribute/SPObjectTypeAttribute attributes.", typeof(TDefinition).AssemblyQualifiedName));
}
resultModel.Value = currentDefinition;
result = resultModel;
}
// ProcessAdditionalArtifacts(result, defs);
return(result);
}
