protected virtual void MapProperties(WorkflowDefinition workflow, SP2013WorkflowDefinition definition)
        {
            if (!string.IsNullOrEmpty(definition.RestrictToType))
            {
                workflow.RestrictToType = definition.RestrictToType;
            }

            if (!string.IsNullOrEmpty(definition.RestrictToScope))
            {
                workflow.RestrictToScope = definition.RestrictToScope;
            }

            foreach (var prop in definition.Properties)
            {
                workflow.SetProperty(prop.Name, prop.Value);
            }
        }
        protected WorkflowDefinition GetCurrentWorkflowDefinition(Web web, SP2013WorkflowDefinition workflowDefinitionModel)
        {
            TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Resolving workflow definition by DisplayName: [{0}]", workflowDefinitionModel.DisplayName);

            var clientContext = web.Context;

            var workflowServiceManager    = new WorkflowServicesManager(clientContext, web);
            var workflowDeploymentService = workflowServiceManager.GetWorkflowDeploymentService();

            var publishedWorkflows = workflowDeploymentService.EnumerateDefinitions(false);

            clientContext.Load(publishedWorkflows, c => c.Include(
                                   w => w.DisplayName,
                                   w => w.Id,
                                   w => w.Published
                                   ));
            clientContext.ExecuteQueryWithTrace();

            return(publishedWorkflows.FirstOrDefault(w => w.DisplayName == workflowDefinitionModel.DisplayName));
        }
Example #3
0
        //[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
        public void CanDeploySimpleSP2013WorkflowSubscriptionToWeb()
        {
            var writeToHistoryListWorkflow = new SP2013WorkflowDefinition
            {
                DisplayName = "M2 - Write to history list",
                Override    = true,
                Xaml        = WorkflowTemplates.WriteToHistoryListWorkflow
            };

            var taskList = new ListDefinition
            {
                Title        = "Write To History List Tasks",
                TemplateType = BuiltInListTemplateTypeId.Tasks,
                Url          = "m2WriteToHistoryListTasks"
            };

            var historyList = new ListDefinition
            {
                Title        = "Write To History List History",
                TemplateType = BuiltInListTemplateTypeId.WorkflowHistory,
                Url          = "m2WriteToHistoryListHistory"
            };

            var model = SPMeta2Model.NewWebModel(web =>
            {
                web
                .AddSP2013Workflow(writeToHistoryListWorkflow)
                .AddList(historyList)
                .AddList(taskList)
                .AddSP2013WorkflowSubscription(new SP2013WorkflowSubscriptionDefinition
                {
                    Name = "Write To History Web Workflow",
                    WorkflowDisplayName = writeToHistoryListWorkflow.DisplayName,
                    HistoryListUrl      = historyList.GetListUrl(),
                    TaskListUrl         = taskList.GetListUrl()
                });
            });

            DeployModel(model);
        }
        private void DeployWorkflowDefinition(object host, SPWeb web, SP2013WorkflowDefinition workflowDefinitionModel)
        {
            var workflowServiceManager    = new WorkflowServicesManager(web);
            var workflowDeploymentService = workflowServiceManager.GetWorkflowDeploymentService();

            var currentWorkflowDefinition = GetCurrentWorkflowDefinition(web, workflowDefinitionModel);

            InvokeOnModelEvent(this, new ModelEventArgs
            {
                CurrentModelNode = null,
                Model            = null,
                EventType        = ModelEventType.OnProvisioning,
                Object           = currentWorkflowDefinition,
                ObjectType       = typeof(WorkflowDefinition),
                ObjectDefinition = workflowDefinitionModel,
                ModelHost        = host
            });

            if (currentWorkflowDefinition == null)
            {
                TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new SP2013 workflow definition");

                var workflowDefinition = new WorkflowDefinition()
                {
                    Xaml        = workflowDefinitionModel.Xaml,
                    DisplayName = workflowDefinitionModel.DisplayName
                };

                MapProperties(workflowDefinition, workflowDefinitionModel);

                TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Calling SaveDefinition()");
                var wfId = workflowDeploymentService.SaveDefinition(workflowDefinition);

                InvokeOnModelEvent(this, new ModelEventArgs
                {
                    CurrentModelNode = null,
                    Model            = null,
                    EventType        = ModelEventType.OnProvisioned,
                    Object           = workflowDefinition,
                    ObjectType       = typeof(WorkflowDefinition),
                    ObjectDefinition = workflowDefinitionModel,
                    ModelHost        = host
                });

                TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Calling PublishDefinition()");
                workflowDeploymentService.PublishDefinition(wfId);
            }
            else
            {
                TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing SP2013 workflow definition");

                if (workflowDefinitionModel.Override)
                {
                    TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Override = true. Overriding workflow definition");

                    currentWorkflowDefinition.Xaml = workflowDefinitionModel.Xaml;

                    MapProperties(currentWorkflowDefinition, workflowDefinitionModel);

                    InvokeOnModelEvent(this, new ModelEventArgs
                    {
                        CurrentModelNode = null,
                        Model            = null,
                        EventType        = ModelEventType.OnProvisioned,
                        Object           = currentWorkflowDefinition,
                        ObjectType       = typeof(WorkflowDefinition),
                        ObjectDefinition = workflowDefinitionModel,
                        ModelHost        = host
                    });

                    TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Calling SaveDefinition()");
                    var wfId = workflowDeploymentService.SaveDefinition(currentWorkflowDefinition);

                    TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Calling PublishDefinition()");
                    workflowDeploymentService.PublishDefinition(wfId);
                }
                else
                {
                    TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Override = false. Skipping workflow definition");

                    MapProperties(currentWorkflowDefinition, workflowDefinitionModel);

                    InvokeOnModelEvent(this, new ModelEventArgs
                    {
                        CurrentModelNode = null,
                        Model            = null,
                        EventType        = ModelEventType.OnProvisioned,
                        Object           = currentWorkflowDefinition,
                        ObjectType       = typeof(WorkflowDefinition),
                        ObjectDefinition = workflowDefinitionModel,
                        ModelHost        = host
                    });

                    TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Calling PublishDefinition()");
                    workflowDeploymentService.PublishDefinition(currentWorkflowDefinition.Id);
                }
            }
        }
 public static ModelNode AddSP2013Workflow(this ModelNode model, SP2013WorkflowDefinition definition, Action <ModelNode> action)
 {
     return(model.AddDefinitionNode(definition, action));
 }
 public static ModelNode AddSP2013Workflow(this ModelNode model, SP2013WorkflowDefinition definition)
 {
     return(AddSP2013Workflow(model, definition, null));
 }
Example #7
0
 public static TModelNode AddSP2013Workflow <TModelNode>(this TModelNode model, SP2013WorkflowDefinition definition,
                                                         Action <SP2013WorkflowModelNode> action)
     where TModelNode : ModelNode, IWebModelNode, new()
 {
     return(model.AddTypedDefinitionNode(definition, action));
 }
Example #8
0
 public static TModelNode AddSP2013Workflow <TModelNode>(this TModelNode model, SP2013WorkflowDefinition definition)
     where TModelNode : ModelNode, IWebModelNode, new()
 {
     return(AddSP2013Workflow(model, definition, null));
 }
        private void DeployWorkflowDefinition(WebModelHost host,
                                              Web web,
                                              SP2013WorkflowDefinition workflowDefinitionModel)
        {
            var clientContext = web.Context;

            var workflowServiceManager    = new WorkflowServicesManager(clientContext, web);
            var workflowDeploymentService = workflowServiceManager.GetWorkflowDeploymentService();

            var publishedWorkflows = workflowDeploymentService.EnumerateDefinitions(false);

            clientContext.Load(publishedWorkflows, c => c.Include(
                                   w => w.DisplayName,
                                   w => w.Id,
                                   w => w.Published
                                   ));
            clientContext.ExecuteQuery();

            var currentWorkflowDefinition = publishedWorkflows.FirstOrDefault(w => w.DisplayName == workflowDefinitionModel.DisplayName);

            InvokeOnModelEvent(this, new ModelEventArgs
            {
                CurrentModelNode = null,
                Model            = null,
                EventType        = ModelEventType.OnProvisioning,
                Object           = currentWorkflowDefinition,
                ObjectType       = typeof(WorkflowDefinition),
                ObjectDefinition = workflowDefinitionModel,
                ModelHost        = host
            });

            if (currentWorkflowDefinition == null)
            {
                var workflowDefinition = new WorkflowDefinition(clientContext)
                {
                    Xaml        = workflowDefinitionModel.Xaml,
                    DisplayName = workflowDefinitionModel.DisplayName
                };

                clientContext.Load(workflowDefinition);
                workflowDeploymentService.SaveDefinition(workflowDefinition);

                InvokeOnModelEvent(this, new ModelEventArgs
                {
                    CurrentModelNode = null,
                    Model            = null,
                    EventType        = ModelEventType.OnProvisioned,
                    Object           = workflowDefinition,
                    ObjectType       = typeof(WorkflowDefinition),
                    ObjectDefinition = workflowDefinitionModel,
                    ModelHost        = host
                });

                workflowDeploymentService.PublishDefinition(workflowDefinition.Id);
                clientContext.ExecuteQuery();
            }
            else
            {
                if (workflowDefinitionModel.Override)
                {
                    currentWorkflowDefinition.Xaml = workflowDefinitionModel.Xaml;

                    InvokeOnModelEvent(this, new ModelEventArgs
                    {
                        CurrentModelNode = null,
                        Model            = null,
                        EventType        = ModelEventType.OnProvisioned,
                        Object           = currentWorkflowDefinition,
                        ObjectType       = typeof(WorkflowDefinition),
                        ObjectDefinition = workflowDefinitionModel,
                        ModelHost        = host
                    });

                    workflowDeploymentService.SaveDefinition(currentWorkflowDefinition);
                    workflowDeploymentService.PublishDefinition(currentWorkflowDefinition.Id);

                    clientContext.ExecuteQuery();
                }
                else
                {
                    InvokeOnModelEvent(this, new ModelEventArgs
                    {
                        CurrentModelNode = null,
                        Model            = null,
                        EventType        = ModelEventType.OnProvisioned,
                        Object           = currentWorkflowDefinition,
                        ObjectType       = typeof(WorkflowDefinition),
                        ObjectDefinition = workflowDefinitionModel,
                        ModelHost        = host
                    });

                    workflowDeploymentService.PublishDefinition(currentWorkflowDefinition.Id);
                    clientContext.ExecuteQuery();
                }
            }
        }
        private void DeployWorkflowDefinition(object host, SPWeb web, SP2013WorkflowDefinition workflowDefinitionModel)
        {
            var workflowServiceManager    = new WorkflowServicesManager(web);
            var workflowDeploymentService = workflowServiceManager.GetWorkflowDeploymentService();

            var publishedWorkflows        = workflowDeploymentService.EnumerateDefinitions(false);
            var currentWorkflowDefinition = publishedWorkflows.FirstOrDefault(w => w.DisplayName == workflowDefinitionModel.DisplayName);

            InvokeOnModelEvent(this, new ModelEventArgs
            {
                CurrentModelNode = null,
                Model            = null,
                EventType        = ModelEventType.OnProvisioning,
                Object           = currentWorkflowDefinition,
                ObjectType       = typeof(WorkflowDefinition),
                ObjectDefinition = workflowDefinitionModel,
                ModelHost        = host
            });

            if (currentWorkflowDefinition == null)
            {
                var workflowDefinition = new WorkflowDefinition()
                {
                    Xaml        = workflowDefinitionModel.Xaml,
                    DisplayName = workflowDefinitionModel.DisplayName
                };

                workflowDeploymentService.SaveDefinition(workflowDefinition);

                InvokeOnModelEvent(this, new ModelEventArgs
                {
                    CurrentModelNode = null,
                    Model            = null,
                    EventType        = ModelEventType.OnProvisioned,
                    Object           = workflowDefinition,
                    ObjectType       = typeof(WorkflowDefinition),
                    ObjectDefinition = workflowDefinitionModel,
                    ModelHost        = host
                });

                workflowDeploymentService.PublishDefinition(workflowDefinition.Id);
            }
            else
            {
                if (workflowDefinitionModel.Override)
                {
                    currentWorkflowDefinition.Xaml = workflowDefinitionModel.Xaml;

                    InvokeOnModelEvent(this, new ModelEventArgs
                    {
                        CurrentModelNode = null,
                        Model            = null,
                        EventType        = ModelEventType.OnProvisioned,
                        Object           = currentWorkflowDefinition,
                        ObjectType       = typeof(WorkflowDefinition),
                        ObjectDefinition = workflowDefinitionModel,
                        ModelHost        = host
                    });

                    workflowDeploymentService.SaveDefinition(currentWorkflowDefinition);
                    workflowDeploymentService.PublishDefinition(currentWorkflowDefinition.Id);
                }
                else
                {
                    InvokeOnModelEvent(this, new ModelEventArgs
                    {
                        CurrentModelNode = null,
                        Model            = null,
                        EventType        = ModelEventType.OnProvisioned,
                        Object           = currentWorkflowDefinition,
                        ObjectType       = typeof(WorkflowDefinition),
                        ObjectDefinition = workflowDefinitionModel,
                        ModelHost        = host
                    });

                    workflowDeploymentService.PublishDefinition(currentWorkflowDefinition.Id);
                }
            }
        }