public override TokenParser ProvisionObjects(Web web, ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateApplyingInformation applyingInformation)
{
using (var scope = new PnPMonitoredScope(this.Name))
{
// Get a reference to infrastructural services
var servicesManager = new WorkflowServicesManager(web.Context, web);
var deploymentService = servicesManager.GetWorkflowDeploymentService();
var subscriptionService = servicesManager.GetWorkflowSubscriptionService();
// Provision Workflow Definitions
foreach (var definition in template.Workflows.WorkflowDefinitions)
{
// Load the Workflow Definition XAML
Stream xamlStream = template.Connector.GetFileStream(definition.XamlPath);
System.Xml.Linq.XElement xaml = System.Xml.Linq.XElement.Load(xamlStream);
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowDefinition workflowDefinition =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowDefinition(web.Context)
{
AssociationUrl = definition.AssociationUrl,
Description = definition.Description,
DisplayName = definition.DisplayName,
FormField = definition.FormField,
DraftVersion = definition.DraftVersion,
Id = definition.Id,
InitiationUrl = definition.InitiationUrl,
RequiresAssociationForm = definition.RequiresAssociationForm,
RequiresInitiationForm = definition.RequiresInitiationForm,
RestrictToScope = parser.ParseString(definition.RestrictToScope),
RestrictToType = definition.RestrictToType != "Universal" ? definition.RestrictToType : null,
Xaml = xaml.ToString(),
};
//foreach (var p in definition.Properties)
//{
// workflowDefinition.SetProperty(p.Key, parser.ParseString(p.Value));
//}
// Save the Workflow Definition
var definitionId = deploymentService.SaveDefinition(workflowDefinition);
web.Context.Load(workflowDefinition);
web.Context.ExecuteQueryRetry();
// Let's publish the Workflow Definition, if needed
if (definition.Published)
{
deploymentService.PublishDefinition(definitionId.Value);
}
}
foreach (var subscription in template.Workflows.WorkflowSubscriptions)
{
#if CLIENTSDKV15
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription workflowSubscription =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription(web.Context)
{
DefinitionId = subscription.DefinitionId,
Enabled = subscription.Enabled,
EventSourceId = (!String.IsNullOrEmpty(subscription.EventSourceId)) ? Guid.Parse(parser.ParseString(subscription.EventSourceId)) : web.Id,
EventTypes = subscription.EventTypes,
ManualStartBypassesActivationLimit = subscription.ManualStartBypassesActivationLimit,
Name = subscription.Name,
StatusFieldName = subscription.StatusFieldName,
};
#else
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription workflowSubscription =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription(web.Context)
{
DefinitionId = subscription.DefinitionId,
Enabled = subscription.Enabled,
EventSourceId = (!String.IsNullOrEmpty(subscription.EventSourceId)) ? Guid.Parse(parser.ParseString(subscription.EventSourceId)) : web.Id,
EventTypes = subscription.EventTypes,
ManualStartBypassesActivationLimit = subscription.ManualStartBypassesActivationLimit,
Name = subscription.Name,
ParentContentTypeId = subscription.ParentContentTypeId,
StatusFieldName = subscription.StatusFieldName,
};
#endif
foreach (var p in subscription.PropertyDefinitions
.Where(d => d.Key == "TaskListId" || d.Key == "HistoryListId"))
{
workflowSubscription.SetProperty(p.Key, parser.ParseString(p.Value));
}
if (!String.IsNullOrEmpty(subscription.ListId))
{
// It is a List Workflow
Guid targetListId = Guid.Parse(parser.ParseString(subscription.ListId));
subscriptionService.PublishSubscriptionForList(workflowSubscription, targetListId);
}
else
{
// It is a Site Workflow
subscriptionService.PublishSubscription(workflowSubscription);
}
web.Context.ExecuteQueryRetry();
}
}
return parser;
}
public override TokenParser ProvisionObjects(Web web, ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateApplyingInformation applyingInformation)
{
using (var scope = new PnPMonitoredScope(this.Name))
{
// Get a reference to infrastructural services
WorkflowServicesManager servicesManager = null;
try
{
servicesManager = new WorkflowServicesManager(web.Context, web);
}
catch (ServerException)
{
// If there is no workflow service present in the farm this method will throw an error.
// Swallow the exception
}
if (servicesManager != null)
{
var deploymentService = servicesManager.GetWorkflowDeploymentService();
var subscriptionService = servicesManager.GetWorkflowSubscriptionService();
// Pre-load useful properties
web.EnsureProperty(w => w.Id);
// Provision Workflow Definitions
foreach (var definition in template.Workflows.WorkflowDefinitions)
{
// Load the Workflow Definition XAML
Stream xamlStream = template.Connector.GetFileStream(definition.XamlPath);
System.Xml.Linq.XElement xaml = System.Xml.Linq.XElement.Load(xamlStream);
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowDefinition workflowDefinition =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowDefinition(web.Context)
{
AssociationUrl = definition.AssociationUrl,
Description = definition.Description,
DisplayName = definition.DisplayName,
FormField = definition.FormField,
DraftVersion = definition.DraftVersion,
Id = definition.Id,
InitiationUrl = definition.InitiationUrl,
RequiresAssociationForm = definition.RequiresAssociationForm,
RequiresInitiationForm = definition.RequiresInitiationForm,
RestrictToScope = parser.ParseString(definition.RestrictToScope),
RestrictToType = definition.RestrictToType != "Universal" ? definition.RestrictToType : null,
Xaml = xaml.ToString(),
};
//foreach (var p in definition.Properties)
//{
// workflowDefinition.SetProperty(p.Key, parser.ParseString(p.Value));
//}
// Save the Workflow Definition
var definitionId = deploymentService.SaveDefinition(workflowDefinition);
web.Context.Load(workflowDefinition);
web.Context.ExecuteQueryRetry();
// Let's publish the Workflow Definition, if needed
if (definition.Published)
{
deploymentService.PublishDefinition(definitionId.Value);
}
}
// get existing subscriptions
var existingWorkflowSubscriptions = web.GetWorkflowSubscriptions();
foreach (var subscription in template.Workflows.WorkflowSubscriptions)
{
// Check if the subscription already exists before adding it, and
// if already exists a subscription with the same name and with the same DefinitionId,
// it is a duplicate
string subscriptionName;
if (subscription.PropertyDefinitions.TryGetValue("SharePointWorkflowContext.Subscription.Name", out subscriptionName) &&
existingWorkflowSubscriptions.Any(s => s.PropertyDefinitions["SharePointWorkflowContext.Subscription.Name"] == subscriptionName && s.DefinitionId == subscription.DefinitionId))
{
// Thus, skip it!
WriteWarning(string.Format("Workflow Subscription '{0}' already exists. Skipping...", subscription.Name), ProvisioningMessageType.Warning);
continue;
}
#if CLIENTSDKV15
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription workflowSubscription =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription(web.Context)
{
DefinitionId = subscription.DefinitionId,
Enabled = subscription.Enabled,
EventSourceId = (!String.IsNullOrEmpty(subscription.EventSourceId)) ? Guid.Parse(parser.ParseString(subscription.EventSourceId)) : web.Id,
EventTypes = subscription.EventTypes,
ManualStartBypassesActivationLimit = subscription.ManualStartBypassesActivationLimit,
Name = subscription.Name,
StatusFieldName = subscription.StatusFieldName,
};
#else
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription workflowSubscription =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription(web.Context)
{
DefinitionId = subscription.DefinitionId,
Enabled = subscription.Enabled,
EventSourceId = (!String.IsNullOrEmpty(subscription.EventSourceId)) ? Guid.Parse(parser.ParseString(subscription.EventSourceId)) : web.Id,
EventTypes = subscription.EventTypes,
ManualStartBypassesActivationLimit = subscription.ManualStartBypassesActivationLimit,
Name = subscription.Name,
ParentContentTypeId = subscription.ParentContentTypeId,
StatusFieldName = subscription.StatusFieldName,
};
#endif
foreach (var propertyDefinition in subscription.PropertyDefinitions
.Where(d => d.Key == "TaskListId" ||
d.Key == "HistoryListId" ||
d.Key == "SharePointWorkflowContext.Subscription.Id" ||
d.Key == "SharePointWorkflowContext.Subscription.Name" ||
d.Key == "CreatedBySPD"))
{
workflowSubscription.SetProperty(propertyDefinition.Key, parser.ParseString(propertyDefinition.Value));
}
if (!String.IsNullOrEmpty(subscription.ListId))
{
// It is a List Workflow
Guid targetListId = Guid.Parse(parser.ParseString(subscription.ListId));
subscriptionService.PublishSubscriptionForList(workflowSubscription, targetListId);
}
else
{
// It is a Site Workflow
subscriptionService.PublishSubscription(workflowSubscription);
}
web.Context.ExecuteQueryRetry();
}
}
}
return parser;
}
public override TokenParser ProvisionObjects(Web web, ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateApplyingInformation applyingInformation)
{
using (var scope = new PnPMonitoredScope(this.Name))
{
// Get a reference to infrastructural services
WorkflowServicesManager servicesManager = null;
try
{
servicesManager = new WorkflowServicesManager(web.Context, web);
}
catch (ServerException)
{
// If there is no workflow service present in the farm this method will throw an error.
// Swallow the exception
}
if (servicesManager != null)
{
var deploymentService = servicesManager.GetWorkflowDeploymentService();
var subscriptionService = servicesManager.GetWorkflowSubscriptionService();
// Pre-load useful properties
web.EnsureProperty(w => w.Id);
// Provision Workflow Definitions
foreach (var templateDefinition in template.Workflows.WorkflowDefinitions)
{
// Load the Workflow Definition XAML
Stream xamlStream = template.Connector.GetFileStream(templateDefinition.XamlPath);
System.Xml.Linq.XElement xaml = System.Xml.Linq.XElement.Load(xamlStream);
int retryCount = 5;
int retryAttempts = 1;
int delay = 2000;
while (retryAttempts <= retryCount)
{
try
{
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowDefinition workflowDefinition =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowDefinition(web.Context)
{
AssociationUrl = templateDefinition.AssociationUrl,
Description = templateDefinition.Description,
DisplayName = templateDefinition.DisplayName,
FormField = templateDefinition.FormField,
DraftVersion = templateDefinition.DraftVersion,
Id = templateDefinition.Id,
InitiationUrl = templateDefinition.InitiationUrl,
RequiresAssociationForm = templateDefinition.RequiresAssociationForm,
RequiresInitiationForm = templateDefinition.RequiresInitiationForm,
RestrictToScope = parser.ParseString(templateDefinition.RestrictToScope),
RestrictToType = templateDefinition.RestrictToType != "Universal" ? templateDefinition.RestrictToType : null,
Xaml = parser.ParseString(xaml.ToString()),
};
//foreach (var p in definition.Properties)
//{
// workflowDefinition.SetProperty(p.Key, parser.ParseString(p.Value));
//}
// Save the Workflow Definition
var newDefinition = deploymentService.SaveDefinition(workflowDefinition);
//web.Context.Load(workflowDefinition); //not needed
web.Context.ExecuteQueryRetry();
// Let's publish the Workflow Definition, if needed
if (templateDefinition.Published)
{
deploymentService.PublishDefinition(newDefinition.Value);
web.Context.ExecuteQueryRetry();
}
break; // no errors so exit loop
}
catch (Exception ex)
{
// check exception is due to connection closed issue
if (ex is ServerException && ((ServerException)ex).ServerErrorCode == -2130575223 &&
((ServerException)ex).ServerErrorTypeName.Equals("Microsoft.SharePoint.SPException", StringComparison.InvariantCultureIgnoreCase) &&
((ServerException)ex).Message.Contains("A connection that was expected to be kept alive was closed by the server.")
)
{
WriteWarning(String.Format("Connection closed whilst adding Workflow Definition, trying again in {0}ms", delay), ProvisioningMessageType.Warning);
Thread.Sleep(delay);
retryAttempts++;
delay = delay * 2; // double delay for next retry
}
else
{
throw;
}
}
}
}
// get existing subscriptions
var existingWorkflowSubscriptions = web.GetWorkflowSubscriptions();
foreach (var subscription in template.Workflows.WorkflowSubscriptions)
{
Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription workflowSubscription = null;
// Check if the subscription already exists before adding it, and
// if already exists a subscription with the same name and with the same DefinitionId,
// it is a duplicate and we just need to update it
string subscriptionName;
if (subscription.PropertyDefinitions.TryGetValue("SharePointWorkflowContext.Subscription.Name", out subscriptionName) &&
existingWorkflowSubscriptions.Any(s => s.PropertyDefinitions["SharePointWorkflowContext.Subscription.Name"] == subscriptionName && s.DefinitionId == subscription.DefinitionId))
{
// Thus, delete it before adding it again!
WriteWarning(string.Format("Workflow Subscription '{0}' already exists. It will be updated.", subscription.Name), ProvisioningMessageType.Warning);
workflowSubscription = existingWorkflowSubscriptions.FirstOrDefault((s => s.PropertyDefinitions["SharePointWorkflowContext.Subscription.Name"] == subscriptionName && s.DefinitionId == subscription.DefinitionId));
if (workflowSubscription != null)
{
subscriptionService.DeleteSubscription(workflowSubscription.Id);
web.Context.ExecuteQueryRetry();
}
}
#if ONPREMISES
// Create the WorkflowDefinition instance
workflowSubscription =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription(web.Context)
{
DefinitionId = subscription.DefinitionId,
Enabled = subscription.Enabled,
EventSourceId = (!String.IsNullOrEmpty(subscription.EventSourceId)) ? Guid.Parse(parser.ParseString(subscription.EventSourceId)) : web.Id,
EventTypes = subscription.EventTypes,
ManualStartBypassesActivationLimit = subscription.ManualStartBypassesActivationLimit,
Name = subscription.Name,
StatusFieldName = subscription.StatusFieldName,
};
#else
// Create the WorkflowDefinition instance
workflowSubscription =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription(web.Context)
{
DefinitionId = subscription.DefinitionId,
Enabled = subscription.Enabled,
EventSourceId = (!String.IsNullOrEmpty(subscription.EventSourceId)) ? Guid.Parse(parser.ParseString(subscription.EventSourceId)) : web.Id,
EventTypes = subscription.EventTypes,
ManualStartBypassesActivationLimit = subscription.ManualStartBypassesActivationLimit,
Name = subscription.Name,
ParentContentTypeId = subscription.ParentContentTypeId,
StatusFieldName = subscription.StatusFieldName,
};
#endif
if (workflowSubscription != null)
{
foreach (var propertyDefinition in subscription.PropertyDefinitions
.Where(d => d.Key == "TaskListId" ||
d.Key == "HistoryListId" ||
d.Key == "SharePointWorkflowContext.Subscription.Id" ||
d.Key == "SharePointWorkflowContext.Subscription.Name" ||
d.Key == "CreatedBySPD"))
{
workflowSubscription.SetProperty(propertyDefinition.Key, parser.ParseString(propertyDefinition.Value));
}
if (!String.IsNullOrEmpty(subscription.ListId))
{
// It is a List Workflow
Guid targetListId = Guid.Parse(parser.ParseString(subscription.ListId));
subscriptionService.PublishSubscriptionForList(workflowSubscription, targetListId);
}
else
{
// It is a Site Workflow
subscriptionService.PublishSubscription(workflowSubscription);
}
web.Context.ExecuteQueryRetry();
}
}
}
}
return(parser);
}
public override TokenParser ProvisionObjects(Web web, ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateApplyingInformation applyingInformation)
{
using (var scope = new PnPMonitoredScope(this.Name))
{
// Get a reference to infrastructural services
WorkflowServicesManager servicesManager = null;
try
{
servicesManager = new WorkflowServicesManager(web.Context, web);
}
catch (ServerException)
{
// If there is no workflow service present in the farm this method will throw an error.
// Swallow the exception
}
if (servicesManager != null)
{
var deploymentService = servicesManager.GetWorkflowDeploymentService();
var subscriptionService = servicesManager.GetWorkflowSubscriptionService();
// Pre-load useful properties
web.EnsureProperty(w => w.Id);
// Provision Workflow Definitions
foreach (var templateDefinition in template.Workflows.WorkflowDefinitions)
{
// Load the Workflow Definition XAML
Stream xamlStream = template.Connector.GetFileStream(templateDefinition.XamlPath);
System.Xml.Linq.XElement xaml = System.Xml.Linq.XElement.Load(xamlStream);
int retryCount = 5;
int retryAttempts = 1;
int delay = 2000;
while (retryAttempts <= retryCount)
{
try
{
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowDefinition workflowDefinition =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowDefinition(web.Context)
{
AssociationUrl = templateDefinition.AssociationUrl,
Description = templateDefinition.Description,
DisplayName = templateDefinition.DisplayName,
FormField = templateDefinition.FormField,
DraftVersion = templateDefinition.DraftVersion,
Id = templateDefinition.Id,
InitiationUrl = templateDefinition.InitiationUrl,
RequiresAssociationForm = templateDefinition.RequiresAssociationForm,
RequiresInitiationForm = templateDefinition.RequiresInitiationForm,
RestrictToScope = parser.ParseString(templateDefinition.RestrictToScope),
RestrictToType = templateDefinition.RestrictToType != "Universal" ? templateDefinition.RestrictToType : null,
Xaml = parser.ParseString(xaml.ToString()),
};
//foreach (var p in definition.Properties)
//{
// workflowDefinition.SetProperty(p.Key, parser.ParseString(p.Value));
//}
// Save the Workflow Definition
var newDefinition = deploymentService.SaveDefinition(workflowDefinition);
//web.Context.Load(workflowDefinition); //not needed
web.Context.ExecuteQueryRetry();
// Let's publish the Workflow Definition, if needed
if (templateDefinition.Published)
{
deploymentService.PublishDefinition(newDefinition.Value);
web.Context.ExecuteQueryRetry();
}
break; // no errors so exit loop
}
catch (Exception ex)
{
// check exception is due to connection closed issue
if (ex is ServerException && ((ServerException)ex).ServerErrorCode == -2130575223 &&
((ServerException)ex).ServerErrorTypeName.Equals("Microsoft.SharePoint.SPException", StringComparison.InvariantCultureIgnoreCase) &&
((ServerException)ex).Message.Contains("A connection that was expected to be kept alive was closed by the server.")
)
{
WriteWarning(String.Format("Connection closed whilst adding Workflow Definition, trying again in {0}ms", delay), ProvisioningMessageType.Warning);
Thread.Sleep(delay);
retryAttempts++;
delay = delay * 2; // double delay for next retry
}
else
{
throw;
}
}
}
}
// get existing subscriptions
var existingWorkflowSubscriptions = web.GetWorkflowSubscriptions();
foreach (var subscription in template.Workflows.WorkflowSubscriptions)
{
Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription workflowSubscription = null;
// Check if the subscription already exists before adding it, and
// if already exists a subscription with the same name and with the same DefinitionId,
// it is a duplicate and we just need to update it
string subscriptionName;
if (subscription.PropertyDefinitions.TryGetValue("SharePointWorkflowContext.Subscription.Name", out subscriptionName) &&
existingWorkflowSubscriptions.Any(s => s.PropertyDefinitions["SharePointWorkflowContext.Subscription.Name"] == subscriptionName && s.DefinitionId == subscription.DefinitionId))
{
// Thus, delete it before adding it again!
WriteWarning(string.Format("Workflow Subscription '{0}' already exists. It will be updated.", subscription.Name), ProvisioningMessageType.Warning);
workflowSubscription = existingWorkflowSubscriptions.FirstOrDefault((s => s.PropertyDefinitions["SharePointWorkflowContext.Subscription.Name"] == subscriptionName && s.DefinitionId == subscription.DefinitionId));
if (workflowSubscription != null)
{
subscriptionService.DeleteSubscription(workflowSubscription.Id);
web.Context.ExecuteQueryRetry();
}
}
#if ONPREMISES
// Create the WorkflowDefinition instance
workflowSubscription =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription(web.Context)
{
DefinitionId = subscription.DefinitionId,
Enabled = subscription.Enabled,
EventSourceId = (!String.IsNullOrEmpty(subscription.EventSourceId)) ? Guid.Parse(parser.ParseString(subscription.EventSourceId)) : web.Id,
EventTypes = subscription.EventTypes,
ManualStartBypassesActivationLimit = subscription.ManualStartBypassesActivationLimit,
Name = subscription.Name,
StatusFieldName = subscription.StatusFieldName,
};
#else
// Create the WorkflowDefinition instance
workflowSubscription =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription(web.Context)
{
DefinitionId = subscription.DefinitionId,
Enabled = subscription.Enabled,
EventSourceId = (!String.IsNullOrEmpty(subscription.EventSourceId)) ? Guid.Parse(parser.ParseString(subscription.EventSourceId)) : web.Id,
EventTypes = subscription.EventTypes,
ManualStartBypassesActivationLimit = subscription.ManualStartBypassesActivationLimit,
Name = subscription.Name,
ParentContentTypeId = subscription.ParentContentTypeId,
StatusFieldName = subscription.StatusFieldName,
};
#endif
if (workflowSubscription != null)
{
foreach (var propertyDefinition in subscription.PropertyDefinitions
.Where(d => d.Key == "TaskListId" ||
d.Key == "HistoryListId" ||
d.Key == "SharePointWorkflowContext.Subscription.Id" ||
d.Key == "SharePointWorkflowContext.Subscription.Name" ||
d.Key == "CreatedBySPD"))
{
workflowSubscription.SetProperty(propertyDefinition.Key, parser.ParseString(propertyDefinition.Value));
}
if (!String.IsNullOrEmpty(subscription.ListId))
{
// It is a List Workflow
Guid targetListId = Guid.Parse(parser.ParseString(subscription.ListId));
subscriptionService.PublishSubscriptionForList(workflowSubscription, targetListId);
}
else
{
// It is a Site Workflow
subscriptionService.PublishSubscription(workflowSubscription);
}
web.Context.ExecuteQueryRetry();
}
}
}
}
return parser;
}
public override TokenParser ProvisionObjects(Web web, ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateApplyingInformation applyingInformation)
{
using (var scope = new PnPMonitoredScope(this.Name))
{
// Get a reference to infrastructural services
WorkflowServicesManager servicesManager = null;
try
{
servicesManager = new WorkflowServicesManager(web.Context, web);
}
catch (ServerException)
{
// If there is no workflow service present in the farm this method will throw an error.
// Swallow the exception
}
if (servicesManager != null)
{
var deploymentService = servicesManager.GetWorkflowDeploymentService();
var subscriptionService = servicesManager.GetWorkflowSubscriptionService();
// Pre-load useful properties
web.EnsureProperty(w => w.Id);
// Provision Workflow Definitions
foreach (var definition in template.Workflows.WorkflowDefinitions)
{
// Load the Workflow Definition XAML
Stream xamlStream = template.Connector.GetFileStream(definition.XamlPath);
System.Xml.Linq.XElement xaml = System.Xml.Linq.XElement.Load(xamlStream);
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowDefinition workflowDefinition =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowDefinition(web.Context)
{
AssociationUrl = definition.AssociationUrl,
Description = definition.Description,
DisplayName = definition.DisplayName,
FormField = definition.FormField,
DraftVersion = definition.DraftVersion,
Id = definition.Id,
InitiationUrl = definition.InitiationUrl,
RequiresAssociationForm = definition.RequiresAssociationForm,
RequiresInitiationForm = definition.RequiresInitiationForm,
RestrictToScope = parser.ParseString(definition.RestrictToScope),
RestrictToType = definition.RestrictToType != "Universal" ? definition.RestrictToType : null,
Xaml = xaml.ToString(),
};
//foreach (var p in definition.Properties)
//{
// workflowDefinition.SetProperty(p.Key, parser.ParseString(p.Value));
//}
// Save the Workflow Definition
var definitionId = deploymentService.SaveDefinition(workflowDefinition);
web.Context.Load(workflowDefinition);
web.Context.ExecuteQueryRetry();
// Let's publish the Workflow Definition, if needed
if (definition.Published)
{
deploymentService.PublishDefinition(definitionId.Value);
}
}
// get existing subscriptions
var existingWorkflowSubscriptions = web.GetWorkflowSubscriptions();
foreach (var subscription in template.Workflows.WorkflowSubscriptions)
{
// Check if the subscription already exists before adding it, and
// if already exists a subscription with the same name and with the same DefinitionId,
// it is a duplicate
string subscriptionName;
if (subscription.PropertyDefinitions.TryGetValue("SharePointWorkflowContext.Subscription.Name", out subscriptionName) &&
existingWorkflowSubscriptions.Any(s => s.PropertyDefinitions["SharePointWorkflowContext.Subscription.Name"] == subscriptionName && s.DefinitionId == subscription.DefinitionId))
{
// Thus, skip it!
WriteWarning(string.Format("Workflow Subscription '{0}' already exists. Skipping...", subscription.Name), ProvisioningMessageType.Warning);
continue;
}
#if CLIENTSDKV15
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription workflowSubscription =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription(web.Context)
{
DefinitionId = subscription.DefinitionId,
Enabled = subscription.Enabled,
EventSourceId = (!String.IsNullOrEmpty(subscription.EventSourceId)) ? Guid.Parse(parser.ParseString(subscription.EventSourceId)) : web.Id,
EventTypes = subscription.EventTypes,
ManualStartBypassesActivationLimit = subscription.ManualStartBypassesActivationLimit,
Name = subscription.Name,
StatusFieldName = subscription.StatusFieldName,
};
#else
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription workflowSubscription =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription(web.Context)
{
DefinitionId = subscription.DefinitionId,
Enabled = subscription.Enabled,
EventSourceId = (!String.IsNullOrEmpty(subscription.EventSourceId)) ? Guid.Parse(parser.ParseString(subscription.EventSourceId)) : web.Id,
EventTypes = subscription.EventTypes,
ManualStartBypassesActivationLimit = subscription.ManualStartBypassesActivationLimit,
Name = subscription.Name,
ParentContentTypeId = subscription.ParentContentTypeId,
StatusFieldName = subscription.StatusFieldName,
};
#endif
foreach (var propertyDefinition in subscription.PropertyDefinitions
.Where(d => d.Key == "TaskListId" ||
d.Key == "HistoryListId" ||
d.Key == "SharePointWorkflowContext.Subscription.Id" ||
d.Key == "SharePointWorkflowContext.Subscription.Name"))
{
workflowSubscription.SetProperty(propertyDefinition.Key, parser.ParseString(propertyDefinition.Value));
}
if (!String.IsNullOrEmpty(subscription.ListId))
{
// It is a List Workflow
Guid targetListId = Guid.Parse(parser.ParseString(subscription.ListId));
subscriptionService.PublishSubscriptionForList(workflowSubscription, targetListId);
}
else
{
// It is a Site Workflow
subscriptionService.PublishSubscription(workflowSubscription);
}
web.Context.ExecuteQueryRetry();
}
}
}
return(parser);
}
public override TokenParser ProvisionObjects(Web web, ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateApplyingInformation applyingInformation)
{
using (var scope = new PnPMonitoredScope(this.Name))
{
// Get a reference to infrastructural services
var servicesManager = new WorkflowServicesManager(web.Context, web);
var deploymentService = servicesManager.GetWorkflowDeploymentService();
var subscriptionService = servicesManager.GetWorkflowSubscriptionService();
// Provision Workflow Definitions
foreach (var definition in template.Workflows.WorkflowDefinitions)
{
// Load the Workflow Definition XAML
Stream xamlStream = template.Connector.GetFileStream(definition.XamlPath);
System.Xml.Linq.XElement xaml = System.Xml.Linq.XElement.Load(xamlStream);
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowDefinition workflowDefinition =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowDefinition(web.Context)
{
AssociationUrl = definition.AssociationUrl,
Description = definition.Description,
DisplayName = definition.DisplayName,
FormField = definition.FormField,
DraftVersion = definition.DraftVersion,
Id = definition.Id,
InitiationUrl = definition.InitiationUrl,
RequiresAssociationForm = definition.RequiresAssociationForm,
RequiresInitiationForm = definition.RequiresInitiationForm,
RestrictToScope = parser.ParseString(definition.RestrictToScope),
RestrictToType = definition.RestrictToType != "Universal" ? definition.RestrictToType : null,
Xaml = xaml.ToString(),
};
//foreach (var p in definition.Properties)
//{
// workflowDefinition.SetProperty(p.Key, parser.ParseString(p.Value));
//}
// Save the Workflow Definition
var definitionId = deploymentService.SaveDefinition(workflowDefinition);
web.Context.Load(workflowDefinition);
web.Context.ExecuteQueryRetry();
// Let's publish the Workflow Definition, if needed
if (definition.Published)
{
deploymentService.PublishDefinition(definitionId.Value);
}
}
foreach (var subscription in template.Workflows.WorkflowSubscriptions)
{
#if CLIENTSDKV15
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription workflowSubscription =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription(web.Context)
{
DefinitionId = subscription.DefinitionId,
Enabled = subscription.Enabled,
EventSourceId = (!String.IsNullOrEmpty(subscription.EventSourceId)) ? Guid.Parse(parser.ParseString(subscription.EventSourceId)) : web.Id,
EventTypes = subscription.EventTypes,
ManualStartBypassesActivationLimit = subscription.ManualStartBypassesActivationLimit,
Name = subscription.Name,
StatusFieldName = subscription.StatusFieldName,
};
#else
// Create the WorkflowDefinition instance
Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription workflowSubscription =
new Microsoft.SharePoint.Client.WorkflowServices.WorkflowSubscription(web.Context)
{
DefinitionId = subscription.DefinitionId,
Enabled = subscription.Enabled,
EventSourceId = (!String.IsNullOrEmpty(subscription.EventSourceId)) ? Guid.Parse(parser.ParseString(subscription.EventSourceId)) : web.Id,
EventTypes = subscription.EventTypes,
ManualStartBypassesActivationLimit = subscription.ManualStartBypassesActivationLimit,
Name = subscription.Name,
ParentContentTypeId = subscription.ParentContentTypeId,
StatusFieldName = subscription.StatusFieldName,
};
#endif
foreach (var p in subscription.PropertyDefinitions
.Where(d => d.Key == "TaskListId" || d.Key == "HistoryListId"))
{
workflowSubscription.SetProperty(p.Key, parser.ParseString(p.Value));
}
if (!String.IsNullOrEmpty(subscription.ListId))
{
// It is a List Workflow
Guid targetListId = Guid.Parse(parser.ParseString(subscription.ListId));
subscriptionService.PublishSubscriptionForList(workflowSubscription, targetListId);
}
else
{
// It is a Site Workflow
subscriptionService.PublishSubscription(workflowSubscription);
}
web.Context.ExecuteQueryRetry();
}
}
return(parser);
}