public static void DeployWeb(ModelNode model)
{
var clientContext = GetClientcontext();
var provisionService = new CSOMProvisionService();
provisionService.DeployWebModel(clientContext, model);
}
static void Main(string[] args)
{
// Step 1, define site field
var customerField = new FieldDefinition
{
Id = new Guid("26470917-fbbf-413b-9eb3-537f74797e4e"),
Title = "Customer Name",
InternalName = "cstm_CustomerName",
Description = "Name of the target customer.",
Group = "Hello SPMeta2",
FieldType = BuiltInFieldTypes.Text
};
// Step 2, define site model and artifact relationships - add field to the site
var siteModel = SPMeta2Model
.NewSiteModel(site =>
{
site.AddField(customerField);
});
// Step 3, deploy model via CSOM
using (var clientContext = new ClientContext(SampleConsts.CSOM_SiteUrl))
{
var csomProvisionService = new CSOMProvisionService();
csomProvisionService.DeployModel(SPMeta2.CSOM.ModelHosts.SiteModelHost.FromClientContext(clientContext), siteModel);
}
// Step 4, deploy model via SSOM
using (var site = new SPSite(SampleConsts.SSOM_SiteUrl))
{
var csomProvisionService = new SSOMProvisionService();
csomProvisionService.DeployModel(SPMeta2.SSOM.ModelHosts.SiteModelHost.FromSite(site), siteModel);
}
}
static void Main(string[] args)
{
var siteUrl = "http://portal";
var o365UserName = "******";
var o365UserPassword = "******";
var consoleUtils = new ConsoleUtils();
consoleUtils.WithO365Context(siteUrl, o365UserName, o365UserPassword, context =>
{
// replace it with your M2 models
var siteModel = default(ModelNode);
var rotWebModel = default(ModelNode);
// create a provision service - CSOMProvisionService or StandardCSOMProvisionService
var provisionService = new CSOMProvisionService();
// little nice thing, tracing the progress
consoleUtils.TraceDeploymentProgress(provisionService);
// deploy!
provisionService.DeploySiteModel(context, siteModel);
provisionService.DeployWebModel(context, rotWebModel);
});
}
private static void DeployAttachmentsLibrary(ClientContext clientContext, List targetList)
{
var csomProvisionService = new CSOMProvisionService();
var webModel = SPMeta2Model.NewWebModel();
webModel.AddList(Assets.listDefinition);
csomProvisionService.DeployWebModel(clientContext, webModel);
var attachmentsFieldDefinition = new LookupFieldDefinition
{
Title = "ParentItemID",
InternalName = "ParentItemID",
Group = "Angular",
Id = new Guid("FEF440A7-3228-4034-BB2A-FFD538D46A62"),
LookupListTitle = targetList.Title,
LookupWebId = clientContext.Web.Id,
LookupField = "ID",
RelationshipDeleteBehavior = "Cascade",
Indexed = true
};
var lookupFieldModel = SPMeta2Model.NewWebModel(web =>
{
web.AddField(attachmentsFieldDefinition);
});
webModel.AddList(Attachments.listDefinition, list => list.AddField(attachmentsFieldDefinition));
csomProvisionService.DeployWebModel(clientContext, webModel);
}
public static void DeploySite(ModelNode model)
{
var clientContext = GetClientcontext();
var provisionService = new CSOMProvisionService();
provisionService.RegisterModelHandlers(typeof(TaxonomyTermModelHandler).Assembly);
provisionService.DeploySiteModel(clientContext, model);
}
public static void ExecuteModel(this SiteModelNode Model, string url, ICredentials Credential = null)
{
SharePoint.Session(url, Credential, ctx =>
{
var provisionService = new CSOMProvisionService();
provisionService.DeployModel(SiteModelHost.FromClientContext(ctx), Model);
});
}
protected void DeployWebModelAsCSOM(ModelNode model)
{
using (var clientContext = new ClientContext(SampleConsts.CSOM_SiteUrl))
{
var csomProvisionService = new CSOMProvisionService();
csomProvisionService.DeployModel(SPMeta2.CSOM.ModelHosts.WebModelHost.FromClientContext(clientContext), model);
}
}
public static void Deploy(SPDeployOptions options)
{
SharePoint.Session(options.url, options.Credentials, ctx =>
{
var provisionService = new CSOMProvisionService();
provisionService.DeployModel(SiteModelHost.FromClientContext(ctx), DeployModel());
});
}
static void Main(string[] args)
{
var model = GoogleMapsModel.GetModel();
var siteUrl = "http://dev";
var context = new ClientContext(siteUrl);
var provisionService = new CSOMProvisionService();
provisionService.DeployWebModel(context, model);
}
public void CanDeployFieldsToSite()
{
WithO365Context(context =>
{
var model = new RegModel().GetSiteFields();
var provisionService = new CSOMProvisionService();
provisionService.DeployModel(SiteModelHost.FromClientContext(context), model);
});
}
public void CSOMConsoleAppSample(string[] args)
{
var siteUrl = "http://tesla-dev:31415/";
// define fields
var clientDescriptionField = new FieldDefinition
{
Title = "Client Description",
InternalName = "dcs_ClientDescription",
Group = "SPMeta2.Samples",
Id = new Guid("06975b67-01f5-47d7-9e2e-2702dfb8c217"),
FieldType = BuiltInFieldTypes.Note,
};
var clientNumberField = new FieldDefinition
{
Title = "Client Number",
InternalName = "dcs_ClientNumber",
Group = "SPMeta2.Samples",
Id = new Guid("22264486-7561-45ec-a6bc-591ba243693b"),
FieldType = BuiltInFieldTypes.Number,
};
// define content type
var customerAccountContentType = new ContentTypeDefinition
{
Name = "Customer Account",
Id = new Guid("ddc46a66-19a0-460b-a723-c84d7f60a342"),
ParentContentTypeId = BuiltInContentTypeId.Item,
Group = "SPMeta2.Samples",
};
// define relationships and the model
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
site
.AddField(clientDescriptionField)
.AddField(clientNumberField)
.AddContentType(customerAccountContentType, contentType =>
{
contentType
.AddContentTypeFieldLink(clientDescriptionField)
.AddContentTypeFieldLink(clientNumberField);
});
});
var clientContext = new ClientContext(siteUrl);
// deploy the model to the SharePoint site over CSOM
var csomProvisionService = new CSOMProvisionService();
csomProvisionService.DeploySiteModel(clientContext, siteModel);
}
public static void PreProvision(ClientContext context,
CSOMProvisionService provisioningService)
{
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddWeb(SubWeb, subweb => {
});
});
provisioningService.DeployWebModel(context, webModel);
}
public void EnsureCSOMModelHandlers()
{
var service = new CSOMProvisionService();
var modelHandlers = ReflectionUtils.GetTypesFromAssembly <ModelHandlerBase>(typeof(SPMeta2.CSOM.ModelHandlers.FieldModelHandler).Assembly);
foreach (var srcHandlerImplType in modelHandlers)
{
var dstHandlerImpl = service.ModelHandlers.Values.FirstOrDefault(h => h.GetType() == srcHandlerImplType);
Assert.IsNotNull(dstHandlerImpl);
}
}
public static void Provision(ClientContext context,
CSOMProvisionService provisioningService)
{
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddWeb(SubWeb, subweb => {
// this is not working this is the point to fix within the issue #11
setupWeb(subweb, true);
});
setupWeb(web, true);
});
provisioningService.DeployWebModel(context, webModel);
}
private void InitServices()
{
_provisionService = new CSOMProvisionService();
_validationService = new CSOMValidationService();
// TODO, setup a high level validation registration
_provisionService.PreDeploymentServices.Add(new DefaultRequiredPropertiesValidationService());
var csomStandartAsm = typeof(TaxonomyFieldModelHandler).Assembly;
foreach (var handlerType in ReflectionUtils.GetTypesFromAssembly <ModelHandlerBase>(csomStandartAsm))
{
_provisionService.RegisterModelHandler(Activator.CreateInstance(handlerType) as ModelHandlerBase);
}
var csomtandartValidationAsm = typeof(ClientTaxonomyFieldDefinitionValidator).Assembly;
foreach (var handlerType in ReflectionUtils.GetTypesFromAssembly <ModelHandlerBase>(csomtandartValidationAsm))
{
_validationService.RegisterModelHandler(Activator.CreateInstance(handlerType) as ModelHandlerBase);
}
_provisionService.OnModelNodeProcessing += (sender, args) =>
{
Trace.WriteLine(
string.Format("Processing: [{0}/{1}] - [{2:0} %] - [{3}] [{4}]",
new object[] {
args.ProcessedModelNodeCount,
args.TotalModelNodeCount,
100d * (double)args.ProcessedModelNodeCount / (double)args.TotalModelNodeCount,
args.CurrentNode.Value.GetType().Name,
args.CurrentNode.Value
}));
};
_provisionService.OnModelNodeProcessed += (sender, args) =>
{
Trace.WriteLine(
string.Format("Processed: [{0}/{1}] - [{2:0} %] - [{3}] [{4}]",
new object[] {
args.ProcessedModelNodeCount,
args.TotalModelNodeCount,
100d * (double)args.ProcessedModelNodeCount / (double)args.TotalModelNodeCount,
args.CurrentNode.Value.GetType().Name,
args.CurrentNode.Value
}));
};
}
public void RegisterCustomModelHandlerWithSyntax()
{
var csomProvisionService = new CSOMProvisionService();
csomProvisionService.RegisterModelHandler(new ChangeWebTitleAndDescriptionModelHandler());
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddChangeWebTitleAndDescription(new ChangeWebTitleAndDescriptionDefinition
{
Title = "A new name for the web",
Description = "Some changes done by ChangeWebTitleAndDescriptionDefinition"
});
});
using (var clientContext = new ClientContext(CSOMSiteUrl))
csomProvisionService.DeployWebModel(clientContext, webModel);
}
static void Main(string[] args)
{
try
{
ReadSettings();
using (ClientContext ctx = GetAuthenticatedContext())
{
ctx.Load(ctx.Web);
ctx.ExecuteQuery();
Console.WriteLine(ctx.Web.Url);
TraceHelper.TraceInformation("Configuring site");
var provisioningService = new CSOMProvisionService();
var siteModel = Model.BuildSiteModel();
var str1 = siteModel.ToDotGraph();
var str2 = siteModel.ToPrettyPrint();
Console.WriteLine(str2);
System.IO.File.WriteAllText("sitemode.txt", str1);
provisioningService.DeployModel(SiteModelHost.FromClientContext(ctx), siteModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
ctx.Load(ctx.Web);
ctx.ExecuteQuery();
Console.WriteLine(ctx.Web.Url);
TraceHelper.TraceInformation("Configuring web");
var provisioningService = new CSOMProvisionService();
var webModel = Model.BuilWebModel();
provisioningService.DeployModel(WebModelHost.FromClientContext(ctx), webModel);
}
}
catch (Exception ex)
{
TraceHelper.TraceError("an error has occured, message:{0}", ex.Message);
}
}
static void Main(string[] args)
{
using (ClientContext context = Support.Helpers.GetClientContext())
{
context.Load(context.Web);
context.ExecuteQuery();
var title = context.Web.Title;
var url = context.Web.Url;
Console.WriteLine("Connected to " + url);
var service = new CSOMProvisionService();
service.RegisterModelHandlers(typeof(NintexFormHandler).Assembly);
WebModel.Provision(context, service);
//service.PreDeploymentServices.Add(new DefaultRequiredPropertiesValidationService());
}
}
static void Main(string[] args)
{
CommandLineUtils.ApplyValuesFromcommandLine(args);
var targetSiteUrl = ConfigurationManager.AppSettings.Get("targetSiteUrl");
using (ClientContext context = new ClientContext(targetSiteUrl))
{
//context.RequestTimeout = Timeout.Infinite;
var username = ConfigurationManager.AppSettings.Get("sharePointUserName");
var password = ConfigurationManager.AppSettings.Get("sharePointPassword");
var securedPassword = new SecureString();
if (string.IsNullOrEmpty(password))
{
securedPassword = GetConsoleSecurePassword();
}
else
{
foreach (var c in password.ToCharArray())
{
securedPassword.AppendChar(c);
}
}
context.Credentials = new SharePointOnlineCredentials(username, securedPassword);
NintexApiSettings.ApiKey = ConfigurationManager.AppSettings.Get("nintexApiKey");
NintexApiSettings.WebServiceUrl = ConfigurationManager.AppSettings.Get("nintexServiceUrl");
NintexApiSettings.HttpRequestTimeout = TimeSpan.Parse(ConfigurationManager.AppSettings["nintexApiTimeout"]);
context.Load(context.Web, x => x.Title, x => x.Url);
context.ExecuteQuery();
Console.WriteLine("Provisioning to the site with");
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("\ttitle:url {0}:{1}", context.Web.Title, context.Web.Url);
Console.ForegroundColor = ConsoleColor.White;
var service = new CSOMProvisionService();
service.RegisterModelHandlers(typeof(NintexFormO365Handler).Assembly);
WebModel.PreProvision(context, service);
Console.WriteLine("please ensure that the subweb NintexTest has the nintex apps installed and then press any key");
WebModel.Provision(context, service);
}
}
private void InitServices()
{
_provisionService = new CSOMProvisionService();
_validationService = new CSOMValidationService();
var csomStandartAsm = typeof(TaxonomyFieldModelHandler).Assembly;
foreach (var handlerType in ReflectionUtils.GetTypesFromAssembly <ModelHandlerBase>(csomStandartAsm))
{
_provisionService.RegisterModelHandler(Activator.CreateInstance(handlerType) as ModelHandlerBase);
}
var csomtandartValidationAsm = typeof(ClientTaxonomyFieldDefinitionValidator).Assembly;
foreach (var handlerType in ReflectionUtils.GetTypesFromAssembly <ModelHandlerBase>(csomtandartValidationAsm))
{
_validationService.RegisterModelHandler(Activator.CreateInstance(handlerType) as ModelHandlerBase);
}
}
private static void BeforeDeployModel(bool Incremental, Action <CSOMProvisionService> Deploy)
{
var StartedDate = DateTime.Now;
var provisionService = new CSOMProvisionService();
if (Incremental)
{
var IncProvisionConfig = new IncrementalProvisionConfig();
IncProvisionConfig.AutoDetectSharePointPersistenceStorage = true;
provisionService.SetIncrementalProvisionMode(IncProvisionConfig);
}
provisionService.OnModelNodeProcessed += (sender, args) =>
{
ModelNodeProcessed(sender, args, Incremental);
};
Deploy(provisionService);
provisionService.SetDefaultProvisionMode();
var FinishedDate = DateTime.Now;
var DateDiff = (FinishedDate - StartedDate);
var TotalHrs = Math.Round(DateDiff.TotalHours);
var TotalMinutes = Math.Round(DateDiff.TotalMinutes);
var TotalSeconds = Math.Round(DateDiff.TotalSeconds);
if (TotalHrs == 0)
{
if (TotalMinutes == 0)
{
Console.WriteLine(String.Format("It took us {0} seconds", TotalSeconds.ToString()));
}
else
{
Console.WriteLine(String.Format("It took us {0} minutes", TotalMinutes.ToString()));
}
}
else
{
Console.WriteLine(String.Format("It took us {0} hours", TotalHrs.ToString()));
}
Console.WriteLine();
Console.WriteLine();
}
public void CanProvisionIntranet_SiteModel()
{
WithCSOMContext(context =>
{
var siteModel = new M2ProjectPrefixSiteModel();
var rootWebModel = new M2ProjectPrefixRootWebModel();
var provisionService = new CSOMProvisionService();
// site
provisionService.DeploySiteModel(context, siteModel.GetSiteFeaturesModel());
provisionService.DeploySiteModel(context, siteModel.GetUserCustomActionModel());
provisionService.DeploySiteModel(context, siteModel.GetSiteSecurityModel());
provisionService.DeploySiteModel(context, siteModel.GetFieldsAndContentTypesModel());
provisionService.DeploySiteModel(context, siteModel.GetSandboxSolutionsModel());
// root web
provisionService.DeployWebModel(context, rootWebModel.GetStyleLibraryModel());
provisionService.DeployWebModel(context, rootWebModel.GetModel());
});
}
public void Deploy_WebModel_CSOM()
{
// setup url
var webUrl = "";
// create you model
var webModel = SPMeta2Model.NewWebModel(web =>
{
});
// setup client context
using (var clientContext = new ClientContext(webUrl))
{
// deploy web model with SharePoint Foundation CSOM API
var foundationProvisionService = new CSOMProvisionService();
foundationProvisionService.DeployWebModel(clientContext, webModel);
// deploy web model with SharePoint Standard CSOM API
var standardProvisionService = new StandardCSOMProvisionService();
standardProvisionService.DeployWebModel(clientContext, webModel);
}
}
private void InitServices()
{
_provisionService = new CSOMProvisionService();
_validationService = new CSOMValidationService();
// TODO, setup a high level validation registration
_provisionService.PreDeploymentServices.Add(new DefaultRequiredPropertiesValidationService());
var csomStandartAsm = typeof(TaxonomyFieldModelHandler).Assembly;
foreach (var handlerType in ReflectionUtils.GetTypesFromAssembly <ModelHandlerBase>(csomStandartAsm))
{
_provisionService.RegisterModelHandler(Activator.CreateInstance(handlerType) as ModelHandlerBase);
}
var csomtandartValidationAsm = typeof(ClientTaxonomyFieldDefinitionValidator).Assembly;
foreach (var handlerType in ReflectionUtils.GetTypesFromAssembly <ModelHandlerBase>(csomtandartValidationAsm))
{
_validationService.RegisterModelHandler(Activator.CreateInstance(handlerType) as ModelHandlerBase);
}
}
/// <summary>
/// Creates the content for the web object. E.g. List, libraries, permissions etc.
/// </summary>
/// <param name="weburl">The url of the web object (sitecollection + url part)</param>
/// <param name="username">Username for authentication</param>
/// <param name="password">Password for authentication</param>
public static void CreateSharePointWebContent(string weburl, string username, string password)
{
using (var ctx = new ClientContext(weburl))
{
ctx.Credentials = new SharePointOnlineCredentials(username, GetSecurePassword(password));
//create a new SPMeta2 provisioning service
var provisionService = new CSOMProvisionService();
//deploy the model with SPMeta2
provisionService.DeployWebModel(ctx, GetListModel());
//delete the quick launch items
DeleteQuickLaunchNodes(ctx);
//then create the new quick launch items
provisionService.DeployWebModel(ctx, GetNavigationModel());
//set homepage
ctx.Web.RootFolder.WelcomePage = "General";
ctx.Web.RootFolder.Update();
ctx.ExecuteQuery();
}
}
private void BeforeDeployModel(Action <CSOMProvisionService> Deploy)
{
DateTime startedDate = DateTime.Now;
CSOMProvisionService provisionService = new CSOMProvisionService();
if (Incremental)
{
IncrementalProvisionConfig incProvisionConfig = new IncrementalProvisionConfig();
incProvisionConfig.AutoDetectSharePointPersistenceStorage = true;
provisionService.SetIncrementalProvisionMode(incProvisionConfig);
}
provisionService.OnModelNodeProcessed += (sender, args) =>
{
ModelNodeProcessed(sender, args);
};
Deploy(provisionService);
provisionService.SetDefaultProvisionMode();
DateTime finishedDate = DateTime.Now;
TimeSpan executionTime = (finishedDate - startedDate);
if (executionTime.Days > 0)
{
Logger(String.Format("It took us {3} days and {0}:{1}:{2} hours", executionTime.Hours, executionTime.Minutes, executionTime.Seconds, executionTime.Days));
}
else
{
Logger(String.Format("It took us {0}:{1}:{2} hours", executionTime.Hours, executionTime.Minutes, executionTime.Seconds));
}
Logger("");
Logger("");
}
public void RegisterCustomModelHandlerWithEvents()
{
var csomProvisionService = new CSOMProvisionService();
csomProvisionService.RegisterModelHandler(new ChangeWebTitleAndDescriptionModelHandler());
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddChangeWebTitleAndDescription(new ChangeWebTitleAndDescriptionDefinition
{
Title = "A new name for the web",
Description = "Some changes done by ChangeWebTitleAndDescriptionDefinition"
},
changeWebAndTitle =>
{
changeWebAndTitle.OnProvisioning <Web, ChangeWebTitleAndDescriptionDefinition>(cntx =>
{
var cntxWeb = cntx.Object;
var cntxDef = cntx.ObjectDefinition;
// do stuff
});
changeWebAndTitle.OnProvisioned <Web, ChangeWebTitleAndDescriptionDefinition>(cntx =>
{
var cntxWeb = cntx.Object;
var cntxDef = cntx.ObjectDefinition;
// do stuff
});
});
});
using (var clientContext = new ClientContext(CSOMSiteUrl))
csomProvisionService.DeployWebModel(clientContext, webModel);
}
public void ABigPictureSample(ClientContext clientContext)
{
// Step 1, create 'definitions' - a bunch of CSharp POCO objects
var clientDescriptionField = new FieldDefinition
{
Title = "Client Description",
InternalName = "dcs_ClientDescription",
Group = DocConsts.DefaulFieldsGroup,
Id = new Guid("06975b67-01f5-47d7-9e2e-2702dfb8c217"),
FieldType = BuiltInFieldTypes.Note,
};
var customerAccountContentType = new ContentTypeDefinition
{
Name = "Customer Account",
Id = new Guid("ddc46a66-19a0-460b-a723-c84d7f60a342"),
ParentContentTypeId = BuiltInContentTypeId.Item,
Group = DocConsts.DefaultContentTypeGroup
};
// step 2, define relationships between definitions
// we need to build a logical 'model tree'
// fields and content types live under site
// so use SiteModel and add fields/content types under site
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddField(clientDescriptionField);
site.AddContentType(customerAccountContentType);
});
// step 3, deploy site model via CSOM
var csomProvisionService = new CSOMProvisionService();
csomProvisionService.DeploySiteModel(clientContext, siteModel);
}
public static void Provision(ClientContext context, CSOMProvisionService provisioningService)
{
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddNintexWorkflow(webWorkflow, workflowModel =>
{
#region Events
workflowModel.OnProvisioning <Object>
(spMetaCtx =>
{
Console.WriteLine("About to provision the workflow on the web");
});
workflowModel.OnProvisioned <Object>
(spMetaCtx =>
{
Console.WriteLine("Provisioned the web workflow");
Console.WriteLine("The result is {0}", spMetaCtx.Object);
});
#endregion
});
web.AddList(TestList, list =>
{
// this refers to SPMeta2.NintexExt.Core.Syntax.Default;
list.AddNintexForm(form, formmodel => {
#region Events
formmodel.OnProvisioning <Object>
(spMetaCtx =>
{
Console.WriteLine("About to provision the form for {0}", ((NintexFormDefinition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
});
formmodel.OnProvisioned <string>
(spMetaCtx =>
{
Console.WriteLine("Provisoined the form for {0}", ((NintexFormDefinition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
Console.WriteLine("The result is {0}", spMetaCtx.Object);
});
#endregion
});
// if you do not use the syntax default, you can use the line below
//list.AddDefinitionNode(form);
list.AddNintexWorkflow(listWorkflow, workflowModel =>
{
#region Events
workflowModel.OnProvisioning <Object>
(spMetaCtx =>
{
Console.WriteLine("About to provision the workflow on the list");
});
workflowModel.OnProvisioned <Object>
(spMetaCtx =>
{
Console.WriteLine("Provisioned the workflow");
Console.WriteLine("The result is {0}", spMetaCtx.Object);
});
#endregion
});
});
// same here, same list, testing that it works when the list is already there
web.AddHostList(TestList, list =>
{
// this refers to SPMeta2.NintexExt.Core.Syntax.Default;
list.AddNintexForm(form, formmodel => {
#region Events
formmodel.OnProvisioning <Object>
(spMetaCtx =>
{
Console.WriteLine("About to provision the form for {0}", ((NintexFormDefinition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
});
formmodel.OnProvisioned <string>
(spMetaCtx =>
{
Console.WriteLine("Provisoined the form for {0}", ((NintexFormDefinition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
Console.WriteLine("The result is {0}", spMetaCtx.Object);
});
#endregion
});
// if you do not use the syntax default, you can use the line below
//list.AddDefinitionNode(form);
list.AddNintexWorkflow(listWorkflow, workflowModel =>
{
#region Events
workflowModel.OnProvisioning <Object>
(spMetaCtx =>
{
Console.WriteLine("About to provision the workflow on the list");
});
workflowModel.OnProvisioned <Object>
(spMetaCtx =>
{
Console.WriteLine("Provisioned the workflow");
Console.WriteLine("The result is {0}", spMetaCtx.Object);
});
#endregion
});
});
});
provisioningService.DeployWebModel(context, webModel);
}
static void Main(string[] args)
{
try
{
ReadSettings();
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Configuring managed metadata");
var provisioningService = new StandardCSOMProvisionService();
var siteModel = SiteModel.BuildTaxonomyModel();
Console.WriteLine(siteModel.ToPrettyPrint());
provisioningService.RegisterModelHandlers(typeof(TaxonomyGroupModelHandler).Assembly);
provisioningService.DeployModel(SiteModelHost.FromClientContext(ctx), siteModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Building site features");
var provisioningService = new CSOMProvisionService();
var siteModel = SiteModel.BuildSiteFeaturesModel();
Console.WriteLine(siteModel.ToPrettyPrint());
provisioningService.DeployModel(SiteModelHost.FromClientContext(ctx), siteModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Building site fields");
var provisioningService = new StandardCSOMProvisionService();
var siteModel = SiteModel.BuildFieldsModel();
Console.WriteLine(siteModel.ToPrettyPrint());
provisioningService.DeployModel(SiteModelHost.FromClientContext(ctx), siteModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Building site content types");
var provisioningService = new StandardCSOMProvisionService();
var siteModel = SiteModel.BuildContentTypesModel();
Console.WriteLine(siteModel.ToPrettyPrint());
provisioningService.DeployModel(SiteModelHost.FromClientContext(ctx), siteModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Building web root model ");
var provisioningService = new StandardCSOMProvisionService();
var webModel = SiteModel.BuildWebRootModel();
Console.WriteLine(webModel.ToPrettyPrint());
provisioningService.DeployModel(SiteModelHost.FromClientContext(ctx), webModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Building web root files and modules");
var provisioningService = new StandardCSOMProvisionService();
var webModel = Model.FIles.BuildFilesModel();
Console.WriteLine(webModel.ToPrettyPrint());
provisioningService.DeployModel(WebModelHost.FromClientContext(ctx), webModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Building pages");
var provisioningService = new StandardCSOMProvisionService();
var webModel = Model.Pages.BuildPagesModel();
Console.WriteLine(webModel.ToPrettyPrint());
provisioningService.DeployModel(WebModelHost.FromClientContext(ctx), webModel);
}
}
catch (Exception ex)
{
TraceHelper.TraceError("an error has occured, message:{0}", ex);
}
}
