示例#1
0
 public WorkflowFileInfo(string title, bool isDirty, WorkflowType workflowType, string filePath)
 {
     Title = title;
     IsDirty = isDirty;
     WorkflowType = workflowType;
     FilePath = filePath;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="WorkflowInfo" /> class.
 /// </summary>
 /// <param name="Mapping">The mapping.</param>
 /// <param name="Function">The function.</param>
 /// <param name="Version">The version.</param>
 /// <param name="ReturnValues">The return values.</param>
 public WorkflowInfo(string Mapping, WorkflowType Function, int Version, dynamic ReturnValues)
 {
     this.Mapping = Mapping;
     this.Function = Function;
     this.Version = Version;
     this.ReturnValues = ReturnValues;
     this.Continue = true;
 }
示例#3
0
 public WorkItem(int jobId, int? parentId, int order, WorkflowType type, string path)
 {
     JobId = jobId;
     ParentId = parentId;
     Order = order;
     Type = type;
     WorkflowPath = path;
     Status = WorkItemStatus.Created;
 }
示例#4
0
        /// <summary>
        /// Activates a new <see cref="Rock.Model.Workflow"/> instance.
        /// </summary>
        /// <param name="workflowType">The <see cref="Rock.Model.WorkflowType"/> to be activated.</param>
        /// <param name="name">A <see cref="System.String"/> representing the name of the <see cref="Rock.Model.Workflow"/> instance.</param>
        /// <param name="currentPersonId">A <see cref="System.Int32"/> representing the PersonId of the <see cref="Rock.Model.Person"/> who is activating the 
        /// <see cref="Rock.Model.Workflow"/> instance; this will be null if it was completed by the anonymous user.</param>
        /// <returns>The activated <see cref="Rock.Model.Workflow"/> instance</returns>
        public Workflow Activate( WorkflowType workflowType, string name, int? currentPersonId )
        {
            var workflow = Workflow.Activate( workflowType, name );
            
            this.Add( workflow, currentPersonId );
            this.Save( workflow, currentPersonId );

            return workflow;
        }
示例#5
0
        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            try
            {
                var htmlContentItemID = -1;
                var htmlContent       = _htmlTextController.GetTopHtmlText(ModuleId, false, WorkflowID);

                if ((htmlContent != null))
                {
                    htmlContentItemID = htmlContent.ItemID;
                }

                if (!Page.IsPostBack)
                {
                    var workflowStates = _workflowStateController.GetWorkflowStates(WorkflowID);
                    var maxVersions    = _htmlTextController.GetMaximumVersionHistory(PortalId);
                    var userCanEdit    = UserInfo.IsSuperUser || PortalSecurity.IsInRole(PortalSettings.AdministratorRoleName) || UserInfo.UserID == LockedByUserID;

                    lblMaxVersions.Text = maxVersions.ToString();
                    dgVersions.PageSize = Math.Min(Math.Max(maxVersions, 5), 10); //min 5, max 10

                    switch (workflowStates.Count)
                    {
                    case 1:
                        CurrentWorkflowType = WorkflowType.DirectPublish;
                        break;

                    case 2:
                        CurrentWorkflowType = WorkflowType.ContentStaging;
                        break;
                    }

                    if (htmlContentItemID != -1)
                    {
                        DisplayContent(htmlContent);
                        DisplayPreview(htmlContent);
                    }
                    else
                    {
                        DisplayInitialContent(workflowStates[0] as WorkflowStateInfo);
                    }

                    divPublish.Visible = CurrentWorkflowType != WorkflowType.DirectPublish;
                    DisplayVersions();
                }
            }
            catch (Exception exc)
            {
                Exceptions.ProcessModuleLoadException(this, exc);
            }
        }
示例#6
0
 /// <summary>
 /// Creates a new workflow state instance.
 /// </summary>
 /// <param name="stateId">The (unique) id of the new state.</param>
 /// <param name="name">A human-readable name for the new state.</param>
 /// <param name="displayLabel">A human-readable label to be used in the GUI for the new state.</param>
 /// <param name="isTemporary">If set to <c>true</c>, this workflow state will only be temporary located on the
 /// workflow navigation stack, until another workflow state of type <see cref="Workflow.WorkflowType.Workflow"/>
 /// is pushed onto it.</param>
 /// <param name="mainScreen">For states of type <see cref="Workflow.WorkflowType.Workflow"/>, this is the name of the
 /// automatically loaded starting screen of this workflow state. For states of type <see cref="Workflow.WorkflowType.Dialog"/>,
 /// this is the name of the dialog to be shown.</param>
 /// <param name="inheritMenu">Whether the menu items should be inherited from the last workflow state.</param>
 /// <param name="isTransient">Whether the new state is a transient state. See the docs of the
 /// <see cref="IsTransient"/> property.</param>
 /// <param name="workflowModelId">The id of the workflow model which attends the workflow state.</param>
 /// <param name="type">The type of the new workflow state.</param>
 public WorkflowState(Guid stateId, string name, string displayLabel, bool isTemporary, string mainScreen, bool inheritMenu, bool isTransient,
     Guid? workflowModelId, WorkflowType type)
 {
   _stateId = stateId;
   _name = name;
   _displayLabel = displayLabel;
   _isTemporary = isTemporary;
   _mainScreen = mainScreen;
   _inheritMenu = inheritMenu;
   _isTransient = isTransient;
   _workflowModelId = workflowModelId;
   _type = type;
 }
        public void Can_Get_Past_Tense_Type_Description(WorkflowType type, int?days, string expected)
        {
            DateTime?date = null;

            if (days.HasValue)
            {
                date = DateTime.Now.AddDays(days.Value);
            }

            string description = type.DescriptionPastTense(date);

            Assert.StartsWith(expected, description);
        }
示例#8
0
        /// <summary>
        /// Returns breadcrumbs specific to the block that should be added to navigation
        /// based on the current page reference.  This function is called during the page's
        /// oninit to load any initial breadcrumbs.
        /// </summary>
        /// <param name="pageReference">The <see cref="Rock.Web.PageReference" />.</param>
        /// <returns>
        /// A <see cref="System.Collections.Generic.List{BreadCrumb}" /> of block related <see cref="Rock.Web.UI.BreadCrumb">BreadCrumbs</see>.
        /// </returns>
        public override List<BreadCrumb> GetBreadCrumbs( Rock.Web.PageReference pageReference )
        {
            var breadCrumbs = new List<BreadCrumb>();

            var workflowTypeId = PageParameter( "WorkflowTypeId" ).AsInteger();
            _workflowType = new WorkflowTypeService( new RockContext() ).Get( workflowTypeId );
            if ( _workflowType != null )
            {
                breadCrumbs.Add( new BreadCrumb( _workflowType.Name, pageReference ) );
            }

            return breadCrumbs;
        }
示例#9
0
 /// <summary>
 /// Creates a new workflow state instance.
 /// </summary>
 /// <param name="stateId">The (unique) id of the new state.</param>
 /// <param name="name">A human-readable name for the new state.</param>
 /// <param name="displayLabel">A human-readable label to be used in the GUI for the new state.</param>
 /// <param name="isTemporary">If set to <c>true</c>, this workflow state will only be temporary located on the
 /// workflow navigation stack, until another workflow state of type <see cref="Workflow.WorkflowType.Workflow"/>
 /// is pushed onto it.</param>
 /// <param name="mainScreen">For states of type <see cref="Workflow.WorkflowType.Workflow"/>, this is the name of the
 /// automatically loaded starting screen of this workflow state. For states of type <see cref="Workflow.WorkflowType.Dialog"/>,
 /// this is the name of the dialog to be shown.</param>
 /// <param name="inheritMenu">Whether the menu items should be inherited from the last workflow state.</param>
 /// <param name="isTransient">Whether the new state is a transient state. See the docs of the
 /// <see cref="IsTransient"/> property.</param>
 /// <param name="workflowModelId">The id of the workflow model which attends the workflow state.</param>
 /// <param name="type">The type of the new workflow state.</param>
 public WorkflowState(Guid stateId, string name, string displayLabel, bool isTemporary, string mainScreen, bool inheritMenu, bool isTransient,
                      Guid?workflowModelId, WorkflowType type)
 {
     _stateId         = stateId;
     _name            = name;
     _displayLabel    = displayLabel;
     _isTemporary     = isTemporary;
     _mainScreen      = mainScreen;
     _inheritMenu     = inheritMenu;
     _isTransient     = isTransient;
     _workflowModelId = workflowModelId;
     _type            = type;
 }
示例#10
0
 public ActionResult CreateWorkflowType(WorkflowType workflowtype)
 {
     if (ModelState.IsValid)
     {
         ViewData["WorkflowTypeID"] = workflowtype.WorkflowTypeID;
         ViewData["Name"]           = workflowtype.Name;
         ViewData["requirements"]   = workflowtype.Requirements;
         db.Types.Add(workflowtype);
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View());
 }
示例#11
0
        /// <summary>
        /// Raises the <see cref="E:System.Web.UI.Control.Init" /> event.
        /// </summary>
        /// <param name="e">An <see cref="T:System.EventArgs" /> object that contains the event data.</param>
        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);

            int workflowTypeId = 0;

            workflowTypeId = PageParameter("WorkflowTypeId").AsInteger();
            _workflowType  = new WorkflowTypeService(new RockContext()).Get(workflowTypeId);

            if (_workflowType != null)
            {
                pnlWorkflowTypeSelect.Visible   = false;
                gfWorkflows.ApplyFilterClick   += gfWorkflows_ApplyFilterClick;
                gfWorkflows.DisplayFilterValue += gfWorkflows_DisplayFilterValue;

                // this event gets fired after block settings are updated. it's nice to repaint the screen if these settings would alter it
                this.BlockUpdated += Block_BlockUpdated;
                this.AddConfigurationUpdateTrigger(upnlSettings);

                gWorkflows.DataKeyNames = new string[] { "Id" };
                gWorkflows.GridRebind  += gWorkflows_GridRebind;

                gWorkflows.Actions.ShowExcelExport   = false;
                gWorkflows.Actions.ShowMergeTemplate = false;

                LinkButton btnBulk = new LinkButton
                {
                    Text     = "<i class='fa fa-truck fa-fw'></i>",
                    CssClass = "btn-bulk-update btn btn-default btn-sm"
                };
                btnBulk.Click += Actions_BulkUpdateClick;
                gWorkflows.Actions.Controls.Add(btnBulk);

                if (!string.IsNullOrWhiteSpace(_workflowType.WorkTerm))
                {
                    gWorkflows.RowItemText = _workflowType.WorkTerm;
                    lGridTitle.Text        = _workflowType.WorkTerm.Pluralize();
                }

                RockPage.PageTitle = _workflowType.Name;

                if (!string.IsNullOrWhiteSpace(_workflowType.IconCssClass))
                {
                    lHeadingIcon.Text = string.Format("<i class='{0}'></i>", _workflowType.IconCssClass);
                }
            }
            else
            {
                pnlWorkflowList.Visible = false;
            }
        }
示例#12
0
        public ActionResult DeleteWorkflowType(string id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            WorkflowType type = db.Types.Find(id);

            if (type == null)
            {
                return(HttpNotFound());
            }
            return(View(type));
        }
示例#13
0
        public EditWorkflow(MainWindow pMainWindow)
        {
            InitializeComponent();

            this._MainWindow                    = pMainWindow;
            this._MainWindow.ErrorOnPage        = false;
            this._MainWindow.RedoFlowRequired   = false;
            this._MainWindow.Policy._PolicyType = WDAC_Policy.PolicyType.Edit;
            this.Policy = this._MainWindow.Policy;
            this.Log    = this._MainWindow.Log;
            this.Log.AddInfoMsg("==== Edit Workflow Page Initialized ====");
            this.Workflow      = WorkflowType.Edit; // Edit xml is default in the UI
            this.SelectedLevel = RuleLevel.None;
        }
示例#14
0
        /// <summary>
        /// Returns breadcrumbs specific to the block that should be added to navigation
        /// based on the current page reference.  This function is called during the page's
        /// oninit to load any initial breadcrumbs.
        /// </summary>
        /// <param name="pageReference">The <see cref="Rock.Web.PageReference" />.</param>
        /// <returns>
        /// A <see cref="System.Collections.Generic.List{BreadCrumb}" /> of block related <see cref="Rock.Web.UI.BreadCrumb">BreadCrumbs</see>.
        /// </returns>
        public override List <BreadCrumb> GetBreadCrumbs(Rock.Web.PageReference pageReference)
        {
            var breadCrumbs = new List <BreadCrumb>();

            var workflowTypeId = PageParameter("WorkflowTypeId").AsInteger();

            _workflowType = new WorkflowTypeService(new RockContext()).Get(workflowTypeId);
            if (_workflowType != null)
            {
                breadCrumbs.Add(new BreadCrumb(_workflowType.Name, pageReference));
            }

            return(breadCrumbs);
        }
示例#15
0
        /// <summary>
        /// Initializes a new instance of the <see cref="WorkflowNavigationWorkflowType" /> class.
        /// </summary>
        /// <param name="workflowType">Type of the workflow.</param>
        /// <param name="canManage">if set to <c>true</c> [can manage].</param>
        /// <param name="canViewList">if set to <c>true</c> [can view list].</param>
        public WorkflowNavigationWorkflowType(WorkflowType workflowType, bool canManage, bool canViewList)
        {
            Id             = workflowType.Id;
            Name           = workflowType.Name;
            Description    = workflowType.Description;
            IconCssClass   = workflowType.IconCssClass;
            WorkTerm       = workflowType.WorkTerm;
            HasForms       = workflowType.HasActiveForms;
            HighlightColor = string.Empty;
            CanManage      = canManage;
            CanViewList    = canViewList;

            IsActive = workflowType.IsActive == true;
        }
        public List <object> GetItems(string folder, string name)
        {
            List <object> retVal = new List <object>();

            if (String.IsNullOrEmpty(name))
            {
                retVal = new List <object>(Configuration.GetInstance().WorkflowTypes.Cast <object>());
            }
            else
            {
                retVal.Add(WorkflowType.GetByName(name));
            }

            return(retVal);
        }
示例#17
0
        public async Task DeleteAsync(WorkflowType workflowType)
        {
            // Delete workflows first.
            var workflows = await _session.Query <Workflow, WorkflowIndex>(x => x.WorkflowTypeId == workflowType.WorkflowTypeId).ListAsync();

            foreach (var workflow in workflows)
            {
                _session.Delete(workflow);
            }

            // Then delete the workflow type.
            _session.Delete(workflowType);
            var context = new WorkflowTypeDeletedContext(workflowType);
            await _handlers.InvokeAsync((handler, context) => handler.DeletedAsync(context), context, _logger);
        }
        /// <summary>
        /// Tries to acquire a lock before starting an instance of this workflow type, if it is
        /// a singleton or if the event is exclusive, otherwise returns true with a null locker.
        /// </summary>
        public static Task <(ILocker locker, bool locked)> TryAcquireWorkflowTypeLockAsync(
            this IDistributedLock distributedLock,
            WorkflowType workflowType,
            bool isExclusiveEvent = false)
        {
            if (workflowType.IsSingleton || isExclusiveEvent)
            {
                return(distributedLock.TryAcquireLockAsync(
                           "WFT_" + workflowType.WorkflowTypeId + "_LOCK",
                           TimeSpan.FromMilliseconds(20_000),
                           TimeSpan.FromMilliseconds(20_000)));
            }

            return(Task.FromResult <(ILocker, bool)>((null, true)));
        }
示例#19
0
        public async Task <WorkflowType> Get(long Id)
        {
            WorkflowType WorkflowType = await DataContext.WorkflowType.Where(x => x.Id == Id).Select(x => new WorkflowType()
            {
                Id   = x.Id,
                Code = x.Code,
                Name = x.Name,
            }).AsNoTracking().FirstOrDefaultAsync();

            if (WorkflowType == null)
            {
                return(null);
            }

            return(WorkflowType);
        }
        public static IEnumerable <WorkflowRoutesEntry> GetWorkflowTypeRoutesEntries(WorkflowType workflowType, IActivityLibrary activityLibrary)
        {
            return(workflowType.Activities.Where(x => x.IsStart && x.Name == HttpRequestFilterEvent.EventName).Select(x =>
            {
                var activity = activityLibrary.InstantiateActivity <HttpRequestFilterEvent>(x);
                var entry = new WorkflowRoutesEntry
                {
                    WorkflowId = workflowType.Id.ToString(),
                    ActivityId = x.ActivityId,
                    HttpMethod = activity.HttpMethod,
                    RouteValues = activity.RouteValues
                };

                return entry;
            }));
        }
        public IRequest Marshall(DescribeWorkflowTypeRequest describeWorkflowTypeRequest)
        {
            IRequest request = new DefaultRequest(describeWorkflowTypeRequest, "AmazonSimpleWorkflow");
            string   target  = "SimpleWorkflowService.DescribeWorkflowType";

            request.Headers["X-Amz-Target"] = target;
            request.Headers["Content-Type"] = "application/x-amz-json-1.0";

            using (StringWriter stringWriter = new StringWriter())
            {
                JsonWriter writer = new JsonWriter(stringWriter);
                writer.WriteObjectStart();

                if (describeWorkflowTypeRequest != null && describeWorkflowTypeRequest.IsSetDomain())
                {
                    writer.WritePropertyName("domain");
                    writer.Write(describeWorkflowTypeRequest.Domain);
                }

                if (describeWorkflowTypeRequest != null)
                {
                    WorkflowType workflowType = describeWorkflowTypeRequest.WorkflowType;
                    if (workflowType != null)
                    {
                        writer.WritePropertyName("workflowType");
                        writer.WriteObjectStart();
                        if (workflowType != null && workflowType.IsSetName())
                        {
                            writer.WritePropertyName("name");
                            writer.Write(workflowType.Name);
                        }
                        if (workflowType != null && workflowType.IsSetVersion())
                        {
                            writer.WritePropertyName("version");
                            writer.Write(workflowType.Version);
                        }
                        writer.WriteObjectEnd();
                    }
                }

                writer.WriteObjectEnd();

                string snippet = stringWriter.ToString();
                request.Content = System.Text.Encoding.UTF8.GetBytes(snippet);
                return(request);
            }
        }
示例#22
0
        private void LoadWorkflowType()
        {
            if (_rockContext == null)
            {
                _rockContext = new RockContext();
            }

            if (_workflowService == null)
            {
                _workflowService = new WorkflowService(_rockContext);
            }

            if (_workflowTypeService == null)
            {
                _workflowTypeService = new WorkflowTypeService(_rockContext);
            }

            // Get the workflow type id (initial page request)
            if (!WorkflowTypeId.HasValue)
            {
                // Get workflow type set by attribute value
                Guid workflowTypeguid = GetAttributeValue("WorkflowType").AsGuid();
                if (!workflowTypeguid.IsEmpty())
                {
                    _workflowType = _workflowTypeService.Get(workflowTypeguid);
                }

                // If an attribute value was not provided, check for query/route value
                if (_workflowType != null)
                {
                    WorkflowTypeId = _workflowType.Id;
                    ConfiguredType = true;
                }
                else
                {
                    WorkflowTypeId = PageParameter("WorkflowTypeId").AsIntegerOrNull();
                    ConfiguredType = false;
                }
            }

            // Get the workflow type
            if (_workflowType == null && WorkflowTypeId.HasValue)
            {
                _workflowType = _workflowTypeService.Get(WorkflowTypeId.Value);
            }
        }
示例#23
0
        public Task SaveAsync(WorkflowType workflowType)
        {
            var isNew = workflowType.Id == 0;

            _session.Save(workflowType);

            if (isNew)
            {
                var context = new WorkflowTypeCreatedContext(workflowType);
                return(_handlers.InvokeAsync((handler, context) => handler.CreatedAsync(context), context, _logger));
            }
            else
            {
                var context = new WorkflowTypeUpdatedContext(workflowType);
                return(_handlers.InvokeAsync((handler, context) => handler.UpdatedAsync(context), context, _logger));
            }
        }
示例#24
0
        public Workflow NewWorkflow(WorkflowType workflowType, string correlationId = null)
        {
            var workflow = new Workflow
            {
                WorkflowTypeId = workflowType.WorkflowTypeId,
                Status         = WorkflowStatus.Idle,
                State          = JObject.FromObject(new WorkflowState
                {
                    ActivityStates = workflowType.Activities.Select(x => x).ToDictionary(x => x.ActivityId, x => x.Properties)
                }),
                CorrelationId = correlationId,
                CreatedUtc    = _clock.UtcNow
            };

            workflow.WorkflowId = _workflowIdGenerator.GenerateUniqueId(workflow);
            return(workflow);
        }
示例#25
0
        public async Task SaveAsync(WorkflowType workflowType)
        {
            var isNew = workflowType.Id == 0;

            _session.Save(workflowType);

            if (isNew)
            {
                var context = new WorkflowTypeCreatedContext(workflowType);
                await _handlers.InvokeAsync(async x => await x.CreatedAsync(context), _logger);
            }
            else
            {
                var context = new WorkflowTypeUpdatedContext(workflowType);
                await _handlers.InvokeAsync(async x => await x.UpdatedAsync(context), _logger);
            }
        }
示例#26
0
        public async Task DeleteAsync(WorkflowType workflowType)
        {
            // TODO: Remove this when versioning is implemented.

            // Delete workflows first.
            var workflows = await _session.Query <Workflow, WorkflowIndex>(x => x.WorkflowTypeId == workflowType.WorkflowTypeId).ListAsync();

            foreach (var workflow in workflows)
            {
                _session.Delete(workflow);
            }

            // Then delete the workflow type.
            _session.Delete(workflowType);
            var context = new WorkflowTypeDeletedContext(workflowType);
            await _handlers.InvokeAsync(async x => await x.DeletedAsync(context), _logger);
        }
示例#27
0
        public Response MakeRequest(WorkflowType selection)
        {
            string section = "Remove Order(s)";

            Console.Clear();
            Console.Title = $"{Utilities.ProgramTitle} - {section}";
            Utilities.GenerateSeparator('=', Console.WindowWidth, ConsoleColor.Red);
            Console.SetCursorPosition((Console.WindowWidth - section.Length) / 2, Console.CursorTop);
            Console.WriteLine(section.Color("White"));
            Utilities.GenerateSeparator('=', Console.WindowWidth, ConsoleColor.Red);

            var request = new Request
            {
                Type        = WorkflowType.Remove,
                Date        = Utilities.GetDate("Order Date", false),
                OrderNumber = Utilities.GetNumber <int>("Order Number", new Regex(@"^\d{1,5}$"))
            };

            IWorkflow flow     = WorkflowFactory.Create(WorkflowType.Find);
            Response  response = flow.Execute(request);

            if (response.Success)
            {
                Order removalTarget = response.Order;

                Utilities.PrintOrderDetails(removalTarget, WorkflowType.Remove);
                Console.WriteLine("Please confirm that you want to remove this order.");

                string polarOption = Utilities.GetString("(Y)es or (N)o",
                                                         new Regex(@"^Y(es)?$|^N(o)?$", RegexOptions.IgnoreCase), false).ToUpper();

                if (polarOption == "Y" || polarOption == "YES")
                {
                    flow     = WorkflowFactory.Create(selection);
                    response = flow.Execute(request);
                }
                else
                {
                    response.Success = false;
                    response.Message = $"Order #{removalTarget.OrderNumber} removal cancelled. Ending workflow...";
                    return(response);
                }
            }
            return(response);
        }
        public async Task <IActionResult> EditProperties(WorkflowTypePropertiesViewModel viewModel, int?id)
        {
            if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageWorkflows))
            {
                return(Forbid());
            }

            if (!ModelState.IsValid)
            {
                return(View(viewModel));
            }

            var isNew        = id == null;
            var workflowType = default(WorkflowType);

            if (isNew)
            {
                workflowType = new WorkflowType();
                workflowType.WorkflowTypeId = _workflowTypeIdGenerator.GenerateUniqueId(workflowType);
            }
            else
            {
                workflowType = await _session.GetAsync <WorkflowType>(id.Value);

                if (workflowType == null)
                {
                    return(NotFound());
                }
            }

            workflowType.Name                    = viewModel.Name?.Trim();
            workflowType.IsEnabled               = viewModel.IsEnabled;
            workflowType.IsSingleton             = viewModel.IsSingleton;
            workflowType.LockTimeout             = viewModel.LockTimeout;
            workflowType.LockExpiration          = viewModel.LockExpiration;
            workflowType.DeleteFinishedWorkflows = viewModel.DeleteFinishedWorkflows;

            await _workflowTypeStore.SaveAsync(workflowType);

            return(isNew
                ? RedirectToAction(nameof(Edit), new { workflowType.Id })
                : Url.IsLocalUrl(viewModel.ReturnUrl)
                   ? (IActionResult)this.Redirect(viewModel.ReturnUrl, true)
                   : RedirectToAction(nameof(Index)));
        }
示例#29
0
        /// <summary>
        /// Populate the ddlSettingsSubmissionAttribute drop down with the Attributes available in
        /// the specified WorkflowType.
        /// </summary>
        /// <param name="workflowType">The WorkflowType whose Attributes should be populated.</param>
        protected void LoadSubmissionWorkflowAttributes(WorkflowType workflowType)
        {
            ddlSettingsSubmissionAttribute.Items.Clear();
            ddlSettingsSubmissionAttribute.Items.Add(string.Empty);

            if (workflowType != null)
            {
                new AttributeService(new RockContext())
                .GetByEntityTypeId(new Workflow().TypeId).AsQueryable()
                .Where(a =>
                       a.EntityTypeQualifierColumn.Equals("WorkflowTypeId", StringComparison.OrdinalIgnoreCase) &&
                       a.EntityTypeQualifierValue.Equals(workflowType.Id.ToString()))
                .OrderBy(a => a.Order)
                .ThenBy(a => a.Name)
                .ToList()
                .ForEach(a => ddlSettingsSubmissionAttribute.Items.Add(a.Name));
            }
        }
示例#30
0
        internal static IEnumerable <WorkflowRoutesEntry> GetWorkflowRoutesEntries(WorkflowType workflowType, Workflow workflow, IActivityLibrary activityLibrary)
        {
            var awaitingActivityIds = workflow.BlockingActivities.Select(x => x.ActivityId).ToDictionary(x => x);

            return(workflowType.Activities.Where(x => x.Name == HttpRequestFilterEvent.EventName && awaitingActivityIds.ContainsKey(x.ActivityId)).Select(x =>
            {
                var activity = activityLibrary.InstantiateActivity <HttpRequestFilterEvent>(x);
                var entry = new WorkflowRoutesEntry
                {
                    WorkflowId = workflow.WorkflowId,
                    ActivityId = x.ActivityId,
                    HttpMethod = activity.HttpMethod,
                    RouteValues = activity.RouteValues,
                };

                return entry;
            }));
        }
        /// <summary>
        /// Creates the control(s) necessary for prompting user for a new value
        /// </summary>
        /// <param name="configurationValues">The configuration values.</param>
        /// <param name="id"></param>
        /// <returns>
        /// The control
        /// </returns>
        public override Control EditControl(Dictionary <string, ConfigurationValue> configurationValues, string id)
        {
            ListControl editControl;

            editControl = new Rock.Web.UI.Controls.RockDropDownList {
                ID = id
            };
            editControl.Items.Add(new ListItem());

            IEnumerable <WorkflowActivityType> activityTypes = null;

            Guid?workflowTypeGuid = configurationValues != null && configurationValues.ContainsKey(WORKFLOW_TYPE_KEY) ? configurationValues[WORKFLOW_TYPE_KEY].Value.AsGuidOrNull() : null;

            WorkflowType workflowType = null;

            if (workflowTypeGuid.HasValue)
            {
                var workflowTypeService = new WorkflowTypeService(new RockContext());
                workflowType = workflowTypeService.Get(workflowTypeGuid.Value);
            }

            if (workflowType == null)
            {
                workflowType = GetContextWorkflowType();
            }

            if (workflowType != null)
            {
                activityTypes = workflowType.ActivityTypes;

                if (activityTypes != null && activityTypes.Any())
                {
                    foreach (var activityType in activityTypes.OrderBy(a => a.Order))
                    {
                        editControl.Items.Add(new ListItem(activityType.Name ?? "[New Activity]", activityType.Guid.ToString().ToUpper()));
                    }
                }

                return(editControl);
            }

            return(null);
        }
示例#32
0
        /// <summary>
        /// Sets the value. ( as Guid )
        /// </summary>
        /// <param name="control">The control.</param>
        /// <param name="configurationValues"></param>
        /// <param name="value">The value.</param>
        public override void SetEditValue(Control control, Dictionary <string, ConfigurationValue> configurationValues, string value)
        {
            var picker = control as WorkflowTypePicker;

            if (picker != null)
            {
                WorkflowType item = null;
                Guid?        guid = value.AsGuidOrNull();

                // get the item (or null) and set it
                if (guid.HasValue)
                {
                    var rockContext = new RockContext();
                    item = new WorkflowTypeService(rockContext).GetNoTracking(guid.Value);
                }

                picker.SetValue(item);
            }
        }
        public Workflow NewWorkflow(WorkflowType workflowType, string correlationId = null)
        {
            var workflow = new Workflow
            {
                Id             = Guid.NewGuid(),
                WorkflowTypeId = workflowType.WorkflowTypeId,
                Status         = WorkflowStatus.Idle,
                State          = JObject.FromObject(new WorkflowState
                {
                    ActivityStates = workflowType.Activities.Select(x => x)
                                     .ToDictionary(x => x.ActivityId, x => x.Properties)
                }),
                CorrelationId = correlationId,
                CreatedUtc    = _dateTimeProvider.Now,
                WorkflowId    = RandomHelper.Generate26UniqueId()
            };

            return(workflow);
        }
示例#34
0
        protected void AddAttributeColumns(WorkflowType workflowType)
        {
            // Remove attribute columns
            foreach (var column in gWorkflows.Columns.OfType <AttributeField>().ToList())
            {
                gWorkflows.Columns.Remove(column);
            }

            if (workflowType != null)
            {
                // Add attribute columns
                int    entityTypeId = new Workflow().TypeId;
                string qualifier    = workflowType.Id.ToString();
                foreach (var attribute in new AttributeService(new RockContext()).Queryable()
                         .Where(a =>
                                a.EntityTypeId == entityTypeId &&
                                a.IsGridColumn &&
                                a.EntityTypeQualifierColumn.Equals("WorkflowTypeId", StringComparison.OrdinalIgnoreCase) &&
                                a.EntityTypeQualifierValue.Equals(qualifier))
                         .OrderBy(a => a.Order)
                         .ThenBy(a => a.Name))
                {
                    string dataFieldExpression = attribute.Key;
                    bool   columnExists        = gWorkflows.Columns.OfType <AttributeField>().FirstOrDefault(a => a.DataField.Equals(dataFieldExpression)) != null;
                    if (!columnExists)
                    {
                        AttributeField boundField = new AttributeField();
                        boundField.DataField      = dataFieldExpression;
                        boundField.HeaderText     = attribute.Name;
                        boundField.SortExpression = string.Empty;

                        var attributeCache = Rock.Web.Cache.AttributeCache.Read(attribute.Id);
                        if (attributeCache != null)
                        {
                            boundField.ItemStyle.HorizontalAlign = attributeCache.FieldType.Field.AlignValue;
                        }

                        gWorkflows.Columns.Add(boundField);
                    }
                }
            }
        }
示例#35
0
        protected void AddAttributeColumns( WorkflowType workflowType )
        {
            // Remove attribute columns
            foreach ( var column in gWorkflows.Columns.OfType<AttributeField>().ToList() )
            {
                gWorkflows.Columns.Remove( column );
            }

            if ( workflowType != null )
            {
                // Add attribute columns
                int entityTypeId = new Workflow().TypeId;
                string qualifier = workflowType.Id.ToString();
                foreach ( var attribute in new AttributeService( new RockContext() ).Queryable()
                    .Where( a =>
                        a.EntityTypeId == entityTypeId &&
                        a.IsGridColumn &&
                        a.EntityTypeQualifierColumn.Equals( "WorkflowTypeId", StringComparison.OrdinalIgnoreCase ) &&
                        a.EntityTypeQualifierValue.Equals( qualifier ) )
                    .OrderBy( a => a.Order )
                    .ThenBy( a => a.Name ) )
                {
                    string dataFieldExpression = attribute.Key;
                    bool columnExists = gWorkflows.Columns.OfType<AttributeField>().FirstOrDefault( a => a.DataField.Equals( dataFieldExpression ) ) != null;
                    if ( !columnExists )
                    {
                        AttributeField boundField = new AttributeField();
                        boundField.DataField = dataFieldExpression;
                        boundField.AttributeId = attribute.Id;
                        boundField.HeaderText = attribute.Name;

                        var attributeCache = Rock.Web.Cache.AttributeCache.Read( attribute.Id );
                        if ( attributeCache != null )
                        {
                            boundField.ItemStyle.HorizontalAlign = attributeCache.FieldType.Field.AlignValue;
                        }

                        gWorkflows.Columns.Add( boundField );
                    }
                }
            }
        }
示例#36
0
        /// <summary>
        /// Initializes a new instance of the <see cref="WorkflowNavigationWorkflowType"/> class.
        /// </summary>
        /// <param name="workflowType">Type of the workflow.</param>
        public WorkflowNavigationWorkflowType(WorkflowType workflowType, bool canManage)
        {
            Id             = workflowType.Id;
            Name           = workflowType.Name;
            Description    = workflowType.Description;
            IconCssClass   = workflowType.IconCssClass;
            WorkTerm       = workflowType.WorkTerm;
            HasForms       = workflowType.HasActiveForms;
            HighlightColor = string.Empty;
            CanManage      = canManage;

            if (workflowType.IsActive.HasValue)
            {
                IsActive = workflowType.IsActive.Value;
            }
            else
            {
                IsActive = true;
            }
        }
示例#37
0
        private void button_Parse_LogFile_Click(object sender, EventArgs e)
        {
            if (this.SelectedLevel == RuleLevel.None)
            {
                this.Log.AddWarningMsg("Selected Level is null. Level must be selected before Parse_LogEvent_Click");
                this.label_Error.Text    = "Rule level must be selected before event log file parsing can begin";
                this.label_Error.Visible = true;
                this.label_Error.BringToFront();
                return;
            }

            if (this.runspace == null)
            {
                this.runspace = RunspaceFactory.CreateRunspace();
                this.runspace.Open();
            }

            string        dspTitle      = "Choose event logs to convert to policy";
            List <string> eventLogPaths = Helper.BrowseForMultiFiles(dspTitle, Helper.BrowseFileType.EventLog);

            // Prep UI
            this.textBox_EventLogFilePath.Text        = eventLogPaths[0];
            this.panel_Progress.Visible               = true;
            this.label_Error.Visible                  = false;
            this.eventLogParsing_Result_Panel.Visible = false;
            this.Workflow = WorkflowType.ArbitraryEventLog;


            this.DriverFiles = Helper.ReadArbitraryEventLogs(eventLogPaths);

            // TODO: handle 0 case
            this.NumberRules         = this.DriverFiles.Count;
            this.label_Progress.Text = String.Format("0 / {0} Rules from Event Log Created", this.NumberRules);


            // Create background worker to display updates to UI
            if (!this.backgroundWorker.IsBusy)
            {
                this.backgroundWorker.RunWorkerAsync();
            }
        }
        /// <summary>
        /// Sets the value.
        /// </summary>
        /// <param name="workflowType">The Workflow Type.</param>
        public void SetValue( WorkflowType workflowType )
        {
            if ( workflowType != null )
            {
                ItemId = workflowType.Id.ToString();

                string parentCategoryIds = string.Empty;
                var parentCategory = workflowType.Category;
                while ( parentCategory != null )
                {
                    parentCategoryIds = parentCategory.Id + "," + parentCategoryIds;
                    parentCategory = parentCategory.ParentCategory;
                }

                InitialItemParentIds = parentCategoryIds.TrimEnd( new[] { ',' } );
                ItemName = workflowType.Name;
            }
            else
            {
                ItemId = Constants.None.IdValue;
                ItemName = Constants.None.TextHtml;
            }
        }
示例#39
0
        public WorkflowFileViewModel(WorkflowType workflowType, uint dirtyCounter)
            : base(string.Concat(workflowType, dirtyCounter))
        {
            InitializeWorkflowFileViewModel();

            WorkflowType = workflowType;
            IsDirty = true;
            IsSaved = true;

            Title = string.Format(
                "{0} {1}",
                workflowType == WorkflowType.Activity ? "Activity" : "WorkflowService",
                dirtyCounter);

            FilePath = string.Concat(
                Title,
                workflowType == WorkflowType.Activity ? ".xaml" : ".xamlx");

            var resourcePath = workflowType == WorkflowType.Activity
                ? "FlowStudio.DefaultActivity.xaml"
                : "FlowStudio.DefaultWorkflowService.xamlx";

            using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourcePath))
            {
                if (stream != null)
                {
                    using (var reader = new StreamReader(stream))
                    {
                        WorkflowDesigner.Text = reader.ReadToEnd();
                    }
                }
            }

            WorkflowDesigner.Load();

            FinalizeWorkflowFileViewModel();
        }
示例#40
0
        private void LoadWorkflowType()
        {
            if ( _rockContext == null )
            {
                _rockContext = new RockContext();
            }

            if ( _workflowService == null )
            {
                _workflowService = new WorkflowService( _rockContext );
            }

            if ( _workflowTypeService == null )
            {
                _workflowTypeService = new WorkflowTypeService( _rockContext );
            }

            // Get the workflow type id (initial page request)
            if ( !WorkflowTypeId.HasValue )
            {
                // Get workflow type set by attribute value
                Guid workflowTypeguid = GetAttributeValue( "WorkflowType" ).AsGuid();
                if ( !workflowTypeguid.IsEmpty() )
                {
                    _workflowType = _workflowTypeService.Get( workflowTypeguid );
                }

                // If an attribute value was not provided, check for query/route value
                if ( _workflowType != null )
                {
                    WorkflowTypeId = _workflowType.Id;
                    ConfiguredType = true;
                }
                else
                {
                    WorkflowTypeId = PageParameter( "WorkflowTypeId" ).AsIntegerOrNull();
                    ConfiguredType = false;
                }
            }

            // Get the workflow type
            if ( _workflowType == null && WorkflowTypeId.HasValue )
            {
                _workflowType = _workflowTypeService.Get( WorkflowTypeId.Value );
            }
        }
        /// <summary>
        /// Shows the edit details.
        /// </summary>
        /// <param name="workflowType">Type of the workflow.</param>
        /// <param name="rockContext">The rock context.</param>
        private void ShowEditDetails( WorkflowType workflowType, RockContext rockContext )
        {
            ExpandedActivities = new List<Guid>();
            ExpandedActivityAttributes = new List<Guid>();
            ExpandedActions = new List<Guid>();

            if ( workflowType.Id == 0 )
            {
                lReadOnlyTitle.Text = ActionTitle.Add( WorkflowType.FriendlyTypeName ).FormatAsHtmlTitle();
                foreach( var activity in workflowType.ActivityTypes)
                {
                    ExpandedActivities.Add( activity.Guid );
                }
                hlInactive.Visible = false;
            }
            else
            {
                pwDetails.Expanded = false;
            }

            SetEditMode( true );

            LoadDropDowns();

            cbIsActive.Checked = workflowType.IsActive ?? false;
            tbName.Text = workflowType.Name;
            tbDescription.Text = workflowType.Description;
            cpCategory.SetValue( workflowType.CategoryId );
            tbWorkTerm.Text = workflowType.WorkTerm;
            tbProcessingInterval.Text = workflowType.ProcessingIntervalSeconds != null ? workflowType.ProcessingIntervalSeconds.ToString() : string.Empty;
            cbIsPersisted.Checked = workflowType.IsPersisted;
            ddlLoggingLevel.SetValue( (int)workflowType.LoggingLevel );
            tbIconCssClass.Text = workflowType.IconCssClass;

            BindAttributesGrid();

            BuildControls( true );
        }
示例#42
0
        /// <summary>
        /// Shows the edit details.
        /// </summary>
        /// <param name="workflowType">Type of the workflow.</param>
        /// <param name="rockContext">The rock context.</param>
        private void ShowEditDetails( WorkflowType workflowType, RockContext rockContext )
        {
            ExpandedActivities = new List<Guid>();
            ExpandedActivityAttributes = new List<Guid>();
            ExpandedActions = new List<Guid>();

            if ( workflowType.Id == 0 )
            {
                lReadOnlyTitle.Text = ActionTitle.Add( WorkflowType.FriendlyTypeName ).FormatAsHtmlTitle();
                foreach( var activity in workflowType.ActivityTypes)
                {
                    ExpandedActivities.Add( activity.Guid );
                }
                hlInactive.Visible = false;
            }
            else
            {
                pwDetails.Expanded = false;
            }

            SetEditMode( true );

            cbIsActive.Checked = workflowType.IsActive ?? false;
            tbName.Text = workflowType.Name;
            tbDescription.Text = workflowType.Description;
            cpCategory.SetValue( workflowType.CategoryId );
            tbWorkTerm.Text = workflowType.WorkTerm;
            tbNumberPrefix.Text = workflowType.WorkflowIdPrefix;

            if ( workflowType.ProcessingIntervalSeconds.HasValue )
            {
                int mins = workflowType.ProcessingIntervalSeconds.Value / 60;
                tbProcessingInterval.Text = mins.ToString( "N0" );
            }
            else
            {
                tbProcessingInterval.Text = string.Empty;
            }
            cbIsPersisted.Checked = workflowType.IsPersisted;
            ddlLoggingLevel.SetValue( (int)workflowType.LoggingLevel );
            tbIconCssClass.Text = workflowType.IconCssClass;
            ceSummaryViewText.Text = workflowType.SummaryViewText;
            ceNoActionMessage.Text = workflowType.NoActionMessage;

            BindAttributesGrid();

            BuildControls( true );
        }
示例#43
0
        /// <summary>
        /// Handles the Click event of the btnSave control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
        protected void btnSave_Click( object sender, EventArgs e )
        {
            ParseControls( true );

            var rockContext = new RockContext();
            var service = new WorkflowTypeService( rockContext );

            WorkflowType workflowType = null;

            int? workflowTypeId = hfWorkflowTypeId.Value.AsIntegerOrNull();
            if ( workflowTypeId.HasValue )
            {
                workflowType = service.Get( workflowTypeId.Value );
            }

            if ( workflowType == null )
            {
                workflowType = new WorkflowType();
            }

            var validationErrors = new List<string>();

            // check for unique prefix
            string prefix = tbNumberPrefix.UntrimmedText;
            if ( !string.IsNullOrWhiteSpace( prefix ) &&
                prefix.ToUpper() != ( workflowType.WorkflowIdPrefix ?? string.Empty ).ToUpper() )
            {
                if ( service.Queryable().AsNoTracking()
                    .Any( w =>
                        w.Id != workflowType.Id &&
                        w.WorkflowIdPrefix == prefix ) )
                {
                    validationErrors.Add( "Workflow Number Prefix is already being used by another workflow type.  Please use a unique prefix." );
                }
                else
                {
                    workflowType.WorkflowIdPrefix = prefix;
                }
            }
            else
            {
                workflowType.WorkflowIdPrefix = prefix;
            }

            workflowType.IsActive = cbIsActive.Checked;
            workflowType.Name = tbName.Text;
            workflowType.Description = tbDescription.Text;
            workflowType.CategoryId = cpCategory.SelectedValueAsInt();
            workflowType.WorkTerm = tbWorkTerm.Text;
            workflowType.ModifiedByPersonAliasId = CurrentPersonAliasId;
            workflowType.ModifiedDateTime = RockDateTime.Now;

            int? mins = tbProcessingInterval.Text.AsIntegerOrNull();
            if ( mins.HasValue )
            {
                workflowType.ProcessingIntervalSeconds = mins.Value * 60;
            }
            else
            {
                workflowType.ProcessingIntervalSeconds = null;
            }

            workflowType.IsPersisted = cbIsPersisted.Checked;
            workflowType.LoggingLevel = ddlLoggingLevel.SelectedValueAsEnum<WorkflowLoggingLevel>();
            workflowType.IconCssClass = tbIconCssClass.Text;
            workflowType.SummaryViewText = ceSummaryViewText.Text;
            workflowType.NoActionMessage = ceNoActionMessage.Text;

            if ( validationErrors.Any() )
            {
                nbValidationError.Text = string.Format( "Please Correct the Following<ul><li>{0}</li></ul>",
                    validationErrors.AsDelimited( "</li><li>" ) );
                nbValidationError.Visible = true;

                return;
            }

            if ( !Page.IsValid || !workflowType.IsValid )
            {
                return;
            }

            foreach(var activityType in ActivityTypesState)
            {
                if (!activityType.IsValid)
                {
                    return;
                }
                foreach(var actionType in activityType.ActionTypes)
                {
                    if ( !actionType.IsValid )
                    {
                        return;
                    }
                }
            }

            rockContext.WrapTransaction( () =>
            {
                // Save the entity field changes to workflow type
                if ( workflowType.Id.Equals( 0 ) )
                {
                    service.Add( workflowType );
                }
                rockContext.SaveChanges();

                // Save the workflow type attributes
                SaveAttributes( new Workflow().TypeId, "WorkflowTypeId", workflowType.Id.ToString(), AttributesState, rockContext );

                WorkflowActivityTypeService workflowActivityTypeService = new WorkflowActivityTypeService( rockContext );
                WorkflowActivityService workflowActivityService = new WorkflowActivityService( rockContext );
                WorkflowActionService workflowActionService = new WorkflowActionService( rockContext );
                WorkflowActionTypeService workflowActionTypeService = new WorkflowActionTypeService( rockContext );
                WorkflowActionFormService workflowFormService = new WorkflowActionFormService( rockContext );
                WorkflowActionFormAttributeService workflowFormAttributeService = new WorkflowActionFormAttributeService( rockContext );

                // delete WorkflowActionTypes that aren't assigned in the UI anymore
                List<WorkflowActionType> actionTypesInDB = workflowActionTypeService.Queryable().Where( a => a.ActivityType.WorkflowTypeId.Equals( workflowType.Id ) ).ToList();
                List<WorkflowActionType> actionTypesInUI = new List<WorkflowActionType>();

                foreach ( var workflowActivity in ActivityTypesState )
                {
                    foreach ( var workflowAction in workflowActivity.ActionTypes )
                    {
                        actionTypesInUI.Add( workflowAction );
                    }
                }

                var deletedActionTypes = from actionType in actionTypesInDB
                                         where !actionTypesInUI.Select( u => u.Guid ).Contains( actionType.Guid )
                                         select actionType;
                foreach ( var actionType in deletedActionTypes.ToList() )
                {
                    if ( actionType.WorkflowForm != null )
                    {
                        workflowFormService.Delete( actionType.WorkflowForm );
                    }

                    // Delete any workflow actions of this type
                    int loopCounter = 0;
                    foreach ( var action in workflowActionService.Queryable().Where( a => a.ActionTypeId == actionType.Id ) )
                    {
                        workflowActionService.Delete( action );
                        loopCounter++;
                        if ( loopCounter > 100 )
                        {
                            rockContext.SaveChanges();
                            loopCounter = 0;
                        }
                    }
                    rockContext.SaveChanges();

                    workflowActionTypeService.Delete( actionType );
                }
                rockContext.SaveChanges();

                // delete WorkflowActivityTypes that aren't assigned in the UI anymore
                List<WorkflowActivityType> activityTypesInDB = workflowActivityTypeService.Queryable().Where( a => a.WorkflowTypeId.Equals( workflowType.Id ) ).ToList();
                var deletedActivityTypes = from activityType in activityTypesInDB
                                           where !ActivityTypesState.Select( u => u.Guid ).Contains( activityType.Guid )
                                           select activityType;
                foreach ( var activityType in deletedActivityTypes.ToList() )
                {
                    // Delete any workflow activities of this type
                    int loopCounter = 0;
                    foreach ( var activity in workflowActivityService.Queryable().Where( a => a.ActivityTypeId == activityType.Id ) )
                    {
                        workflowActivityService.Delete( activity );
                        loopCounter++;
                        if ( loopCounter > 100 )
                        {
                            rockContext.SaveChanges();
                            loopCounter = 0;
                        }
                    }
                    rockContext.SaveChanges();

                    workflowActivityTypeService.Delete( activityType );
                }
                rockContext.SaveChanges();

                // add or update WorkflowActivityTypes(and Actions) that are assigned in the UI
                int workflowActivityTypeOrder = 0;
                foreach ( var editorWorkflowActivityType in ActivityTypesState )
                {
                    // Add or Update the activity type
                    WorkflowActivityType workflowActivityType = workflowType.ActivityTypes.FirstOrDefault( a => a.Guid.Equals( editorWorkflowActivityType.Guid ) );
                    if ( workflowActivityType == null )
                    {
                        workflowActivityType = new WorkflowActivityType();
                        workflowActivityType.Guid = editorWorkflowActivityType.Guid;
                        workflowType.ActivityTypes.Add( workflowActivityType );
                    }
                    workflowActivityType.IsActive = editorWorkflowActivityType.IsActive;
                    workflowActivityType.Name = editorWorkflowActivityType.Name;
                    workflowActivityType.Description = editorWorkflowActivityType.Description;
                    workflowActivityType.IsActivatedWithWorkflow = editorWorkflowActivityType.IsActivatedWithWorkflow;
                    workflowActivityType.Order = workflowActivityTypeOrder++;

                    // Save Activity Type
                    rockContext.SaveChanges();

                    // Save ActivityType Attributes
                    if ( ActivityAttributesState.ContainsKey( workflowActivityType.Guid ) )
                    {
                        SaveAttributes( new WorkflowActivity().TypeId, "ActivityTypeId", workflowActivityType.Id.ToString(), ActivityAttributesState[workflowActivityType.Guid], rockContext );
                    }

                    // Because the SaveAttributes above may have flushed the cached entity attribute cache, and it would get loaded again with
                    // a different context, manually reload the cache now with our context to prevent a database lock conflict (when database is
                    // configured without snapshot isolation turned on)
                    AttributeCache.LoadEntityAttributes( rockContext );

                    int workflowActionTypeOrder = 0;
                    foreach ( var editorWorkflowActionType in editorWorkflowActivityType.ActionTypes )
                    {
                        WorkflowActionType workflowActionType = workflowActivityType.ActionTypes.FirstOrDefault( a => a.Guid.Equals( editorWorkflowActionType.Guid ) );
                        if ( workflowActionType == null )
                        {
                            // New action
                            workflowActionType = new WorkflowActionType();
                            workflowActionType.Guid = editorWorkflowActionType.Guid;
                            workflowActivityType.ActionTypes.Add( workflowActionType );
                        }
                        workflowActionType.CriteriaAttributeGuid = editorWorkflowActionType.CriteriaAttributeGuid;
                        workflowActionType.CriteriaComparisonType = editorWorkflowActionType.CriteriaComparisonType;
                        workflowActionType.CriteriaValue = editorWorkflowActionType.CriteriaValue;
                        workflowActionType.Name = editorWorkflowActionType.Name;
                        workflowActionType.EntityTypeId = editorWorkflowActionType.EntityTypeId;
                        workflowActionType.IsActionCompletedOnSuccess = editorWorkflowActionType.IsActionCompletedOnSuccess;
                        workflowActionType.IsActivityCompletedOnSuccess = editorWorkflowActionType.IsActivityCompletedOnSuccess;
                        workflowActionType.Attributes = editorWorkflowActionType.Attributes;
                        workflowActionType.AttributeValues = editorWorkflowActionType.AttributeValues;
                        workflowActionType.Order = workflowActionTypeOrder++;

                        if ( workflowActionType.WorkflowForm != null && editorWorkflowActionType.WorkflowForm == null )
                        {
                            // Form removed
                            workflowFormService.Delete( workflowActionType.WorkflowForm );
                            workflowActionType.WorkflowForm = null;
                        }

                        if ( editorWorkflowActionType.WorkflowForm != null )
                        {
                            if ( workflowActionType.WorkflowForm == null )
                            {
                                workflowActionType.WorkflowForm = new WorkflowActionForm();
                            }

                            workflowActionType.WorkflowForm.NotificationSystemEmailId = editorWorkflowActionType.WorkflowForm.NotificationSystemEmailId;
                            workflowActionType.WorkflowForm.IncludeActionsInNotification = editorWorkflowActionType.WorkflowForm.IncludeActionsInNotification;
                            workflowActionType.WorkflowForm.AllowNotes = editorWorkflowActionType.WorkflowForm.AllowNotes;
                            workflowActionType.WorkflowForm.Header = editorWorkflowActionType.WorkflowForm.Header;
                            workflowActionType.WorkflowForm.Footer = editorWorkflowActionType.WorkflowForm.Footer;
                            workflowActionType.WorkflowForm.Actions = editorWorkflowActionType.WorkflowForm.Actions;
                            workflowActionType.WorkflowForm.ActionAttributeGuid = editorWorkflowActionType.WorkflowForm.ActionAttributeGuid;

                            var editorGuids = editorWorkflowActionType.WorkflowForm.FormAttributes
                                .Select( a => a.Attribute.Guid )
                                .ToList();

                            foreach ( var formAttribute in workflowActionType.WorkflowForm.FormAttributes
                                .Where( a => !editorGuids.Contains( a.Attribute.Guid ) ).ToList() )
                            {
                                workflowFormAttributeService.Delete( formAttribute );
                            }

                            int attributeOrder = 0;
                            foreach ( var editorAttribute in editorWorkflowActionType.WorkflowForm.FormAttributes.OrderBy( a => a.Order ) )
                            {
                                int attributeId = AttributeCache.Read( editorAttribute.Attribute.Guid, rockContext ).Id;

                                var formAttribute = workflowActionType.WorkflowForm.FormAttributes
                                    .Where( a => a.AttributeId == attributeId )
                                    .FirstOrDefault();

                                if ( formAttribute == null )
                                {
                                    formAttribute = new WorkflowActionFormAttribute();
                                    formAttribute.Guid = editorAttribute.Guid;
                                    formAttribute.AttributeId = attributeId;
                                    workflowActionType.WorkflowForm.FormAttributes.Add( formAttribute );
                                }

                                formAttribute.Order = attributeOrder++;
                                formAttribute.IsVisible = editorAttribute.IsVisible;
                                formAttribute.IsReadOnly = editorAttribute.IsReadOnly;
                                formAttribute.IsRequired = editorAttribute.IsRequired;
                                formAttribute.HideLabel = editorAttribute.HideLabel;
                                formAttribute.PreHtml = editorAttribute.PreHtml;
                                formAttribute.PostHtml = editorAttribute.PostHtml;
                            }
                        }
                    }
                }

                rockContext.SaveChanges();

                foreach ( var activityType in workflowType.ActivityTypes )
                {
                    foreach ( var workflowActionType in activityType.ActionTypes )
                    {
                        workflowActionType.SaveAttributeValues( rockContext );
                    }
                }

            } );

            var qryParams = new Dictionary<string, string>();
            qryParams["workflowTypeId"] = workflowType.Id.ToString();
            NavigateToPage( RockPage.Guid, qryParams );
        }
示例#44
0
        /// <summary>
        /// Returns breadcrumbs specific to the block that should be added to navigation
        /// based on the current page reference.  This function is called during the page's
        /// oninit to load any initial breadcrumbs.
        /// </summary>
        /// <param name="pageReference">The <see cref="Rock.Web.PageReference" />.</param>
        /// <returns>
        /// A <see cref="System.Collections.Generic.List{BreadCrumb}" /> of block related <see cref="Rock.Web.UI.BreadCrumb">BreadCrumbs</see>.
        /// </returns>
        public override List<BreadCrumb> GetBreadCrumbs( Rock.Web.PageReference pageReference )
        {
            var breadCrumbs = new List<BreadCrumb>();

            if (!string.IsNullOrWhiteSpace(GetAttributeValue("DefaultWorkflowType"))) {
                Guid workflowTypeGuid = Guid.Empty;
                Guid.TryParse( GetAttributeValue( "DefaultWorkflowType" ), out workflowTypeGuid );
                _workflowType = new WorkflowTypeService( new RockContext() ).Get( workflowTypeGuid );
            } else {
                int workflowTypeId = 0;
                workflowTypeId = PageParameter( "WorkflowTypeId" ).AsInteger();
                _workflowType = new WorkflowTypeService( new RockContext() ).Get( workflowTypeId );
            }

            if ( _workflowType != null )
            {
                breadCrumbs.Add( new BreadCrumb( _workflowType.Name, pageReference ) );
            }

            return breadCrumbs;
        }
        /// <summary>
        /// Handles the Click event of the btnSave control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
        protected void btnSave_Click( object sender, EventArgs e )
        {
            ParseControls( true );

            var rockContext = new RockContext();
            var service = new WorkflowTypeService( rockContext );

            WorkflowType workflowType = null;

            int? workflowTypeId = hfWorkflowTypeId.Value.AsIntegerOrNull();
            if ( workflowTypeId.HasValue )
            {
                workflowType = service.Get( workflowTypeId.Value );
            }

            if ( workflowType == null )
            {
                workflowType = new WorkflowType();
            }

            workflowType.IsActive = cbIsActive.Checked;
            workflowType.Name = tbName.Text;
            workflowType.Description = tbDescription.Text;
            workflowType.CategoryId = cpCategory.SelectedValueAsInt();
            workflowType.Order = 0;
            workflowType.WorkTerm = tbWorkTerm.Text;
            workflowType.ProcessingIntervalSeconds = tbProcessingInterval.Text.AsIntegerOrNull();
            workflowType.IsPersisted = cbIsPersisted.Checked;
            workflowType.LoggingLevel = ddlLoggingLevel.SelectedValueAsEnum<WorkflowLoggingLevel>();
            workflowType.IconCssClass = tbIconCssClass.Text;

            if ( !Page.IsValid || !workflowType.IsValid )
            {
                return;
            }

            foreach(var activityType in ActivityTypesState)
            {
                if (!activityType.IsValid)
                {
                    return;
                }
                foreach(var actionType in activityType.ActionTypes)
                {
                    if ( !actionType.IsValid )
                    {
                        return;
                    }
                }
            }

            rockContext.WrapTransaction( () =>
            {
                // Save the entity field changes to workflow type
                if ( workflowType.Id.Equals( 0 ) )
                {
                    service.Add( workflowType );
                }
                rockContext.SaveChanges();

                // Save the workflow type attributes
                SaveAttributes( new Workflow().TypeId, "WorkflowTypeId", workflowType.Id.ToString(), AttributesState, rockContext );

                WorkflowActivityTypeService workflowActivityTypeService = new WorkflowActivityTypeService( rockContext );
                WorkflowActionTypeService workflowActionTypeService = new WorkflowActionTypeService( rockContext );
                WorkflowActionFormService workflowFormService = new WorkflowActionFormService( rockContext );
                WorkflowActionFormAttributeService workflowFormAttributeService = new WorkflowActionFormAttributeService( rockContext );

                // delete WorkflowActionTypes that aren't assigned in the UI anymore
                List<WorkflowActionType> actionTypesInDB = workflowActionTypeService.Queryable().Where( a => a.ActivityType.WorkflowTypeId.Equals( workflowType.Id ) ).ToList();
                List<WorkflowActionType> actionTypesInUI = new List<WorkflowActionType>();

                foreach ( var workflowActivity in ActivityTypesState )
                {
                    foreach ( var workflowAction in workflowActivity.ActionTypes )
                    {
                        actionTypesInUI.Add( workflowAction );
                    }
                }

                var deletedActionTypes = from actionType in actionTypesInDB
                                         where !actionTypesInUI.Select( u => u.Guid ).Contains( actionType.Guid )
                                         select actionType;
                deletedActionTypes.ToList().ForEach( actionType =>
                {
                    if ( actionType.WorkflowForm != null )
                    {
                        workflowFormService.Delete( actionType.WorkflowForm );
                    }
                    workflowActionTypeService.Delete( actionType );
                } );
                rockContext.SaveChanges();

                // delete WorkflowActivityTypes that aren't assigned in the UI anymore
                List<WorkflowActivityType> activityTypesInDB = workflowActivityTypeService.Queryable().Where( a => a.WorkflowTypeId.Equals( workflowType.Id ) ).ToList();
                var deletedActivityTypes = from activityType in activityTypesInDB
                                           where !ActivityTypesState.Select( u => u.Guid ).Contains( activityType.Guid )
                                           select activityType;
                deletedActivityTypes.ToList().ForEach( activityType =>
                {
                    workflowActivityTypeService.Delete( activityType );
                } );
                rockContext.SaveChanges();

                // add or update WorkflowActivityTypes(and Actions) that are assigned in the UI
                int workflowActivityTypeOrder = 0;
                foreach ( var editorWorkflowActivityType in ActivityTypesState )
                {
                    // Add or Update the activity type
                    WorkflowActivityType workflowActivityType = workflowType.ActivityTypes.FirstOrDefault( a => a.Guid.Equals( editorWorkflowActivityType.Guid ) );
                    if ( workflowActivityType == null )
                    {
                        workflowActivityType = new WorkflowActivityType();
                        workflowActivityType.Guid = editorWorkflowActivityType.Guid;
                        workflowType.ActivityTypes.Add( workflowActivityType );
                    }
                    workflowActivityType.IsActive = editorWorkflowActivityType.IsActive;
                    workflowActivityType.Name = editorWorkflowActivityType.Name;
                    workflowActivityType.Description = editorWorkflowActivityType.Description;
                    workflowActivityType.IsActivatedWithWorkflow = editorWorkflowActivityType.IsActivatedWithWorkflow;
                    workflowActivityType.Order = workflowActivityTypeOrder++;

                    // Save Activity Type
                    rockContext.SaveChanges();

                    // Save ActivityType Attributes
                    if ( ActivityAttributesState.ContainsKey( workflowActivityType.Guid ) )
                    {
                        SaveAttributes( new WorkflowActivity().TypeId, "ActivityTypeId", workflowActivityType.Id.ToString(), ActivityAttributesState[workflowActivityType.Guid], rockContext );
                    }

                    int workflowActionTypeOrder = 0;
                    foreach ( var editorWorkflowActionType in editorWorkflowActivityType.ActionTypes )
                    {
                        WorkflowActionType workflowActionType = workflowActivityType.ActionTypes.FirstOrDefault( a => a.Guid.Equals( editorWorkflowActionType.Guid ) );
                        if ( workflowActionType == null )
                        {
                            // New action
                            workflowActionType = new WorkflowActionType();
                            workflowActionType.Guid = editorWorkflowActionType.Guid;
                            workflowActivityType.ActionTypes.Add( workflowActionType );
                        }
                        workflowActionType.CriteriaAttributeGuid = editorWorkflowActionType.CriteriaAttributeGuid;
                        workflowActionType.CriteriaComparisonType = editorWorkflowActionType.CriteriaComparisonType;
                        workflowActionType.CriteriaValue = editorWorkflowActionType.CriteriaValue;
                        workflowActionType.Name = editorWorkflowActionType.Name;
                        workflowActionType.EntityTypeId = editorWorkflowActionType.EntityTypeId;
                        workflowActionType.IsActionCompletedOnSuccess = editorWorkflowActionType.IsActionCompletedOnSuccess;
                        workflowActionType.IsActivityCompletedOnSuccess = editorWorkflowActionType.IsActivityCompletedOnSuccess;
                        workflowActionType.Attributes = editorWorkflowActionType.Attributes;
                        workflowActionType.AttributeValues = editorWorkflowActionType.AttributeValues;
                        workflowActionType.Order = workflowActionTypeOrder++;

                        if ( workflowActionType.WorkflowForm != null && editorWorkflowActionType.WorkflowForm == null )
                        {
                            // Form removed
                            workflowFormService.Delete( workflowActionType.WorkflowForm );
                            workflowActionType.WorkflowForm = null;
                        }

                        if ( editorWorkflowActionType.WorkflowForm != null )
                        {
                            if ( workflowActionType.WorkflowForm == null )
                            {
                                workflowActionType.WorkflowForm = new WorkflowActionForm();
                            }

                            workflowActionType.WorkflowForm.NotificationSystemEmailId = editorWorkflowActionType.WorkflowForm.NotificationSystemEmailId;
                            workflowActionType.WorkflowForm.IncludeActionsInNotification = editorWorkflowActionType.WorkflowForm.IncludeActionsInNotification;
                            workflowActionType.WorkflowForm.AllowNotes = editorWorkflowActionType.WorkflowForm.AllowNotes;
                            workflowActionType.WorkflowForm.Header = editorWorkflowActionType.WorkflowForm.Header;
                            workflowActionType.WorkflowForm.Footer = editorWorkflowActionType.WorkflowForm.Footer;
                            workflowActionType.WorkflowForm.Actions = editorWorkflowActionType.WorkflowForm.Actions;
                            workflowActionType.WorkflowForm.ActionAttributeGuid = editorWorkflowActionType.WorkflowForm.ActionAttributeGuid;

                            var editorGuids = editorWorkflowActionType.WorkflowForm.FormAttributes
                                .Select( a => a.Attribute.Guid )
                                .ToList();

                            foreach ( var formAttribute in workflowActionType.WorkflowForm.FormAttributes
                                .Where( a => !editorGuids.Contains( a.Attribute.Guid ) ).ToList() )
                            {
                                workflowFormAttributeService.Delete( formAttribute );
                            }

                            int attributeOrder = 0;
                            foreach ( var editorAttribute in editorWorkflowActionType.WorkflowForm.FormAttributes.OrderBy( a => a.Order ) )
                            {
                                int attributeId = AttributeCache.Read( editorAttribute.Attribute.Guid, rockContext ).Id;

                                var formAttribute = workflowActionType.WorkflowForm.FormAttributes
                                    .Where( a => a.AttributeId == attributeId )
                                    .FirstOrDefault();

                                if ( formAttribute == null )
                                {
                                    formAttribute = new WorkflowActionFormAttribute();
                                    formAttribute.Guid = editorAttribute.Guid;
                                    formAttribute.AttributeId = attributeId;
                                    workflowActionType.WorkflowForm.FormAttributes.Add( formAttribute );
                                }

                                formAttribute.Order = attributeOrder++;
                                formAttribute.IsVisible = editorAttribute.IsVisible;
                                formAttribute.IsReadOnly = editorAttribute.IsReadOnly;
                                formAttribute.IsRequired = editorAttribute.IsRequired;
                                formAttribute.HideLabel = editorAttribute.HideLabel;
                                formAttribute.PreHtml = editorAttribute.PreHtml;
                                formAttribute.PostHtml = editorAttribute.PostHtml;
                            }
                        }
                    }
                }

                rockContext.SaveChanges();

                foreach ( var activityType in workflowType.ActivityTypes )
                {
                    foreach ( var workflowActionType in activityType.ActionTypes )
                    {
                        workflowActionType.SaveAttributeValues( rockContext );
                    }
                }

            } );

            var qryParams = new Dictionary<string, string>();
            qryParams["workflowTypeId"] = workflowType.Id.ToString();
            NavigateToPage( RockPage.Guid, qryParams );
        }
        /// <summary>
        /// Shows the readonly details.
        /// </summary>
        /// <param name="workflowType">Type of the workflow.</param>
        private void ShowReadonlyDetails( WorkflowType workflowType )
        {
            SetEditMode( false );
            hfWorkflowTypeId.SetValue( workflowType.Id );
            lReadOnlyTitle.Text = workflowType.Name.FormatAsHtmlTitle();
            hlInactive.Visible = workflowType.IsActive == false;
            lblActivitiesReadonlyHeaderLabel.Text = string.Format( "<strong>Activities</strong> ({0})", workflowType.ActivityTypes.Count() );

            if ( workflowType.Category != null )
            {
                hlType.Visible = true;
                hlType.Text = workflowType.Category.Name;
            }
            else
            {
                hlType.Visible = false;
            }

            lWorkflowTypeDescription.Text = workflowType.Description;

            if ( workflowType.ActivityTypes.Count > 0 )
            {
                // Activities
                lblWorkflowActivitiesReadonly.Text = @"
            <div>
            <ol>";

                foreach ( var activityType in workflowType.ActivityTypes.OrderBy( a => a.Order ) )
                {
                    string activityTypeTextFormat = @"
            <li>
            <strong>{0}</strong>
            {1}
            <br />
            {2}
            <ol>
                {3}
            </ol>
            </li>
            ";

                    string actionTypeText = string.Empty;

                    foreach ( var actionType in activityType.ActionTypes.OrderBy( a => a.Order ) )
                    {
                        actionTypeText += string.Format( "<li>{0}</li>" + Environment.NewLine, actionType.Name );
                    }

                    string actionsTitle = activityType.ActionTypes.Count > 0 ? "Actions:" : "No Actions";

                    lblWorkflowActivitiesReadonly.Text += string.Format( activityTypeTextFormat, activityType.Name, activityType.Description, actionsTitle, actionTypeText );
                }

                lblWorkflowActivitiesReadonly.Text += @"
            </ol>
            </div>
            ";
            }
            else
            {
                lblWorkflowActivitiesReadonly.Text = "<div>" + None.TextHtml + "</div>";
            }
        }
        /// <summary>
        /// Handles the Click event of the btnSave control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
        protected void btnSave_Click( object sender, EventArgs e )
        {
            var rockContext = new RockContext();

            WorkflowType workflowType;
            WorkflowTypeService service = new WorkflowTypeService( rockContext );

            int workflowTypeId = int.Parse( hfWorkflowTypeId.Value );

            if ( workflowTypeId == 0 )
            {
                workflowType = new WorkflowType();
                workflowType.IsSystem = false;
                workflowType.Name = string.Empty;
            }
            else
            {
                workflowType = service.Get( workflowTypeId );
            }

            workflowType.Name = tbName.Text;
            workflowType.Description = tbDescription.Text;
            workflowType.CategoryId = cpCategory.SelectedValueAsInt();
            workflowType.Order = 0;
            workflowType.WorkTerm = tbWorkTerm.Text;
            if ( !string.IsNullOrWhiteSpace( tbProcessingInterval.Text ) )
            {
                workflowType.ProcessingIntervalSeconds = int.Parse( tbProcessingInterval.Text );
            }

            workflowType.IsPersisted = cbIsPersisted.Checked;
            workflowType.LoggingLevel = ddlLoggingLevel.SelectedValueAsEnum<WorkflowLoggingLevel>();
            workflowType.IsActive = cbIsActive.Checked;

            if ( !Page.IsValid )
            {
                return;
            }

            if ( !workflowType.IsValid )
            {
                // Controls will render the error messages
                return;
            }

            RockTransactionScope.WrapTransaction( () =>
            {
                // Save the entity field changes to workflow type
                if ( workflowType.Id.Equals( 0 ) )
                {
                    service.Add( workflowType );
                }
                rockContext.SaveChanges();

                // Save the attributes
                SaveAttributes( new Workflow().TypeId, "WorkflowTypeId", workflowType.Id.ToString(), AttributesState, rockContext );

                WorkflowActivityTypeService workflowActivityTypeService = new WorkflowActivityTypeService( rockContext );
                WorkflowActionTypeService workflowActionTypeService = new WorkflowActionTypeService( rockContext );
                WorkflowActionFormService workflowFormService = new WorkflowActionFormService( rockContext );
                WorkflowActionFormAttributeService workflowFormAttributeService = new WorkflowActionFormAttributeService( rockContext );

                // delete WorkflowActionTypes that aren't assigned in the UI anymore
                List<WorkflowActivityEditor> workflowActivityTypeEditorList = phActivities.Controls.OfType<WorkflowActivityEditor>().ToList();
                List<WorkflowActionType> actionTypesInDB = workflowActionTypeService.Queryable().Where( a => a.ActivityType.WorkflowTypeId.Equals( workflowType.Id ) ).ToList();
                List<WorkflowActionType> actionTypesInUI = new List<WorkflowActionType>();
                foreach ( WorkflowActivityEditor workflowActivityTypeEditor in workflowActivityTypeEditorList )
                {
                    foreach ( WorkflowActionEditor editor in workflowActivityTypeEditor.Controls.OfType<WorkflowActionEditor>() )
                    {
                        actionTypesInUI.Add( editor.WorkflowActionType );
                    }
                }
                var deletedActionTypes = from actionType in actionTypesInDB
                                         where !actionTypesInUI.Select( u => u.Guid ).Contains( actionType.Guid )
                                         select actionType;
                deletedActionTypes.ToList().ForEach( actionType =>
                {
                    if (actionType.WorkflowForm != null)
                    {
                        workflowFormService.Delete( actionType.WorkflowForm );
                    }
                    workflowActionTypeService.Delete( actionType );
                } );
                rockContext.SaveChanges();

                // delete WorkflowActivityTypes that aren't assigned in the UI anymore
                List<WorkflowActivityType> activityTypesInDB = workflowActivityTypeService.Queryable().Where( a => a.WorkflowTypeId.Equals( workflowType.Id ) ).ToList();
                List<WorkflowActivityType> activityTypesInUI = workflowActivityTypeEditorList.Select( a => a.GetWorkflowActivityType() ).ToList();
                var deletedActivityTypes = from activityType in activityTypesInDB
                                           where !activityTypesInUI.Select( u => u.Guid ).Contains( activityType.Guid )
                                           select activityType;
                deletedActivityTypes.ToList().ForEach( activityType =>
                {
                    workflowActivityTypeService.Delete( activityType );
                } );
                rockContext.SaveChanges();

                // add or update WorkflowActivityTypes(and Actions) that are assigned in the UI
                int workflowActivityTypeOrder = 0;
                foreach ( WorkflowActivityEditor workflowActivityTypeEditor in workflowActivityTypeEditorList )
                {
                    // Add or Update the activity type
                    WorkflowActivityType editorWorkflowActivityType = workflowActivityTypeEditor.GetWorkflowActivityType();
                    WorkflowActivityType workflowActivityType = workflowType.ActivityTypes.FirstOrDefault( a => a.Guid.Equals( editorWorkflowActivityType.Guid ) );
                    if ( workflowActivityType == null )
                    {
                        workflowActivityType = new WorkflowActivityType();
                        workflowType.ActivityTypes.Add( workflowActivityType );

                    }
                    workflowActivityType.IsActive = editorWorkflowActivityType.IsActive;
                    workflowActivityType.Name = editorWorkflowActivityType.Name;
                    workflowActivityType.Description = editorWorkflowActivityType.Description;
                    workflowActivityType.IsActivatedWithWorkflow = editorWorkflowActivityType.IsActivatedWithWorkflow;
                    workflowActivityType.Order = workflowActivityTypeOrder++;

                    int workflowActionTypeOrder = 0;
                    foreach ( WorkflowActionEditor workflowActionTypeEditor in workflowActivityTypeEditor.Controls.OfType<WorkflowActionEditor>() )
                    {
                        WorkflowActionType editorWorkflowActionType = workflowActionTypeEditor.WorkflowActionType;
                        WorkflowActionType workflowActionType = workflowActivityType.ActionTypes.FirstOrDefault( a => a.Guid.Equals( editorWorkflowActionType.Guid ) );
                        if ( workflowActionType == null )
                        {
                            // New action
                            workflowActionType = new WorkflowActionType();
                            workflowActivityType.ActionTypes.Add( workflowActionType );
                        }
                        workflowActionType.Name = editorWorkflowActionType.Name;
                        workflowActionType.EntityTypeId = editorWorkflowActionType.EntityTypeId;
                        workflowActionType.IsActionCompletedOnSuccess = editorWorkflowActionType.IsActionCompletedOnSuccess;
                        workflowActionType.IsActivityCompletedOnSuccess = editorWorkflowActionType.IsActivityCompletedOnSuccess;
                        workflowActionType.Attributes = editorWorkflowActionType.Attributes;
                        workflowActionType.AttributeValues = editorWorkflowActionType.AttributeValues;
                        workflowActionType.Order = workflowActionTypeOrder++;

                        if ( workflowActionType.WorkflowForm != null && editorWorkflowActionType.WorkflowForm == null )
                        {
                            // Form removed
                            workflowFormService.Delete( workflowActionType.WorkflowForm );
                            workflowActionType.WorkflowForm = null;
                        }

                        if (editorWorkflowActionType.WorkflowForm != null)
                        {
                            if (workflowActionType.WorkflowForm == null)
                            {
                                workflowActionType.WorkflowForm = new WorkflowActionForm();
                            }

                            workflowActionType.WorkflowForm.Header = editorWorkflowActionType.WorkflowForm.Header;
                            workflowActionType.WorkflowForm.Footer = editorWorkflowActionType.WorkflowForm.Footer;
                            workflowActionType.WorkflowForm.InactiveMessage = editorWorkflowActionType.WorkflowForm.InactiveMessage;
                            workflowActionType.WorkflowForm.Actions = editorWorkflowActionType.WorkflowForm.Actions;

                            var editorGuids = editorWorkflowActionType.WorkflowForm.FormAttributes
                                .Select( a => a.Attribute.Guid)
                                .ToList();

                            foreach( var formAttribute in workflowActionType.WorkflowForm.FormAttributes
                                .Where( a => !editorGuids.Contains(a.Attribute.Guid) ) )
                            {
                                workflowFormAttributeService.Delete(formAttribute);
                            }

                            int attributeOrder = 0;
                            foreach ( var editorAttribute in editorWorkflowActionType.WorkflowForm.FormAttributes.OrderBy( a => a.Order ) )
                            {
                                int attributeId = AttributeCache.Read( editorAttribute.Attribute.Guid ).Id;

                                var formAttribute = workflowActionType.WorkflowForm.FormAttributes
                                    .Where( a => a.AttributeId == attributeId )
                                    .FirstOrDefault();

                                if (formAttribute == null)
                                {
                                    formAttribute = new WorkflowActionFormAttribute();
                                    formAttribute.Guid = editorAttribute.Guid;
                                    formAttribute.AttributeId = attributeId;
                                    workflowActionType.WorkflowForm.FormAttributes.Add( formAttribute );
                                }

                                formAttribute.Order = attributeOrder++;
                                formAttribute.IsVisible = editorAttribute.IsVisible;
                                formAttribute.IsReadOnly = editorAttribute.IsReadOnly;
                                formAttribute.IsRequired = editorAttribute.IsRequired;
                            }
                        }
                    }
                }

                rockContext.SaveChanges();

                foreach ( var activityType in workflowType.ActivityTypes )
                {
                    foreach ( var workflowActionType in activityType.ActionTypes )
                    {
                        workflowActionType.SaveAttributeValues( rockContext );
                    }
                }

            } );

            var qryParams = new Dictionary<string, string>();
            qryParams["workflowTypeId"] = workflowType.Id.ToString();
            NavigateToPage( RockPage.Guid, qryParams );
        }
示例#48
0
        /// <summary>
        /// Initializes a new instance of the <see cref="WorkflowNavigationWorkflowType" /> class.
        /// </summary>
        /// <param name="workflowType">Type of the workflow.</param>
        /// <param name="canManage">if set to <c>true</c> [can manage].</param>
        /// <param name="canViewList">if set to <c>true</c> [can view list].</param>
        public WorkflowNavigationWorkflowType( WorkflowType workflowType, bool canManage, bool canViewList )
        {
            Id = workflowType.Id;
            Name = workflowType.Name;
            Description = workflowType.Description;
            IconCssClass = workflowType.IconCssClass;
            WorkTerm = workflowType.WorkTerm;
            HasForms = workflowType.HasActiveForms;
            HighlightColor = string.Empty;
            CanManage = canManage;
            CanViewList = canViewList;

            if ( workflowType.IsActive.HasValue )
            {
                IsActive = workflowType.IsActive.Value;
            }
            else
            {
                IsActive = true;
            }
        }
        /// <summary>
        /// Shows the detail.
        /// </summary>
        private void ShowDetail()
        {
            int? workflowTypeId = PageParameter( "workflowTypeId" ).AsIntegerOrNull();
            int? parentCategoryId = PageParameter( "ParentCategoryId" ).AsIntegerOrNull();

            if ( !workflowTypeId.HasValue )
            {
                pnlDetails.Visible = false;
                return;
            }

            var rockContext = new RockContext();

            WorkflowType workflowType = null;

            if ( workflowTypeId.Value.Equals( 0 ) )
            {
                workflowType = new WorkflowType();
                workflowType.Id = 0;
                workflowType.IsActive = true;
                workflowType.IsPersisted = true;
                workflowType.IsSystem = false;
                workflowType.CategoryId = parentCategoryId;
                workflowType.IconCssClass = "fa fa-list-ol";
                workflowType.ActivityTypes.Add( new WorkflowActivityType { Guid = Guid.NewGuid(), IsActive = true } );
                workflowType.WorkTerm = "Work";
            }
            else
            {
                workflowType = new WorkflowTypeService( rockContext ).Get( workflowTypeId.Value );
            }

            if ( workflowType == null )
            {
                return;
            }

            pnlDetails.Visible = true;
            hfWorkflowTypeId.Value = workflowType.Id.ToString();

            // render UI based on Authorized and IsSystem
            bool readOnly = false;

            nbEditModeMessage.Text = string.Empty;
            // User must have 'Edit' rights to block, or 'Administrate' rights to workflow type
            if ( !IsUserAuthorized( Authorization.EDIT ) )
            {
                readOnly = true;
                nbEditModeMessage.Heading = "Information";
                nbEditModeMessage.Text = EditModeMessage.ReadOnlyEditActionNotAllowed( WorkflowType.FriendlyTypeName );
            }

            if ( workflowType.IsSystem )
            {
                readOnly = true;
                nbEditModeMessage.Heading = "Information";
                nbEditModeMessage.Text = EditModeMessage.ReadOnlySystem( WorkflowType.FriendlyTypeName );
            }

            if ( readOnly )
            {
                btnEdit.Visible = false;
                btnSecurity.Visible = false;
                ShowReadonlyDetails( workflowType );
            }
            else
            {
                btnEdit.Visible = true;

                btnSecurity.Title = "Secure " + workflowType.Name;
                btnSecurity.EntityId = workflowType.Id;

                if ( workflowType.Id > 0 )
                {
                    ShowReadonlyDetails( workflowType );
                }
                else
                {
                    LoadStateDetails(workflowType, rockContext);
                    ShowEditDetails( workflowType, rockContext );
                }
            }
        }
示例#50
0
 private void CreateNewWorkfow(WorkflowType workflowType)
 {
     var file = new WorkflowFileViewModel(workflowType, ++dirtyCounter);
     files.Add(file);
     ActiveWorkflowFile = file;
     SubscribeToFileEvents(file);
 }
示例#51
0
        /// <summary>
        /// Adds the person to group.
        /// </summary>
        /// <param name="rockContext">The rock context.</param>
        /// <param name="person">The person.</param>
        /// <param name="workflowType">Type of the workflow.</param>
        /// <param name="groupMembers">The group members.</param>
        private void AddPersonToGroup( RockContext rockContext, Person person, WorkflowType workflowType, List<GroupMember> groupMembers )
        {
            if (person != null )
            {
                if ( !_group.Members
                    .Any( m =>
                        m.PersonId == person.Id &&
                        m.GroupRoleId == _defaultGroupRole.Id))
                {
                    var groupMemberService = new GroupMemberService(rockContext);
                    var groupMember = new GroupMember();
                    groupMember.PersonId = person.Id;
                    groupMember.GroupRoleId = _defaultGroupRole.Id;
                    groupMember.GroupMemberStatus = (GroupMemberStatus)GetAttributeValue("GroupMemberStatus").AsInteger();
                    groupMember.GroupId = _group.Id;
                    groupMemberService.Add( groupMember );
                    rockContext.SaveChanges();

                    if ( workflowType != null )
                    {
                        try
                        {
                            List<string> workflowErrors;
                            var workflow = Workflow.Activate( workflowType, person.FullName );
                            new WorkflowService( rockContext ).Process( workflow, groupMember, out workflowErrors );
                        }
                        catch (Exception ex)
                        {
                            ExceptionLogService.LogException( ex, this.Context );
                        }
                    }
                }
            }
        }
示例#52
0
        /// <summary>
        /// Launches the workflow.
        /// </summary>
        /// <param name="rockContext">The rock context.</param>
        /// <param name="connectionWorkflow">The connection workflow.</param>
        /// <param name="name">The name.</param>
        private void LaunchWorkflow( RockContext rockContext, Attendance attendance, PersonAlias pagePersonAlias, WorkflowType pageWorkflowType )
        {
            if ( pageWorkflowType != null )
            {
                var workflow = Rock.Model.Workflow.Activate( pageWorkflowType, pageWorkflowType.WorkTerm, rockContext );
                if ( workflow != null )
                {
                    workflow.SetAttributeValue( "Person", attendance.PersonAlias.Guid );
                    workflow.SetAttributeValue( "PagePerson", pagePersonAlias.Guid );

                    var workflowService = new Rock.Model.WorkflowService( rockContext );

                    List<string> workflowErrors;
                    if ( workflowService.Process( workflow, attendance, out workflowErrors ) )
                    {
                        if ( workflow.Id != 0 )
                        {

                            if ( workflow.HasActiveEntryForm( CurrentPerson ) )
                            {
                                var qryParam = new Dictionary<string, string>();
                                qryParam.Add( "WorkflowTypeId", pageWorkflowType.Id.ToString() );
                                qryParam.Add( "WorkflowId", workflow.Id.ToString() );
                                NavigateToLinkedPage( "WorkflowEntryPage", qryParam );
                            }
                            else
                            {
                                mdWorkflowLaunched.Show( string.Format( "A '{0}' workflow has been started.",
                                    pageWorkflowType.Name ), ModalAlertType.Information );
                            }
                        }
                        else
                        {
                            mdWorkflowLaunched.Show( string.Format( "A '{0}' workflow was processed (but not persisted).",
                                pageWorkflowType.Name ), ModalAlertType.Information );
                        }
                    }
                    else
                    {
                        mdWorkflowLaunched.Show( "Workflow Processing Error(s):<ul><li>" + workflowErrors.AsDelimited( "</li><li>" ) + "</li></ul>", ModalAlertType.Information );
                    }
                    return;
                }
            }

            Dictionary<string, string> qParams = new Dictionary<string, string>();
            qParams.Add( "AttendanceId", attendance.Id.ToString() );
            qParams.Add( "PagePersonId", pagePersonAlias.Person.Id.ToString() );
            NavigateToLinkedPage( "WorkflowEntryPage", qParams );
        }
示例#53
0
 /// <summary>
 /// Creates a new transient state. In transient states, some variables like the models are automatically
 /// inherited from the parent state.
 /// </summary>
 /// <param name="name">The human-readable name of the new state.</param>
 /// <param name="displayLabel">A human-readable label for the new state, to be used in the GUI.</param>
 /// <param name="mainScreen">The main screen to be shown in the new state.</param>
 /// <param name="inheritMenu">If set to <c>true</c>, the menu items of the parent state will be
 /// inherited.</param>
 /// <param name="workflowType">The workflow type of the new transient state.</param>
 /// <returns>New transient workflow state.</returns>
 public static WorkflowState CreateTransientState(string name, string displayLabel, bool isTemporary, string mainScreen, bool inheritMenu, WorkflowType workflowType)
 {
   return new WorkflowState(Guid.NewGuid(), name, displayLabel, isTemporary, mainScreen, inheritMenu, true, null, workflowType);
 }
示例#54
0
        /// <summary>
        /// Builds the controls.
        /// </summary>
        /// <param name="setValues">if set to <c>true</c> [set values].</param>
        /// <param name="activeActivityTypeGuid">The active activity type unique identifier.</param>
        /// <param name="activeActionTypeGuid">The active action type unique identifier.</param>
        private void BuildControls( bool setValues = false, Guid? activeActivityTypeGuid = null, Guid? activeActionTypeGuid = null )
        {
            phActivities.Controls.Clear();

            if ( ActivityTypesState != null )
            {
                // Add a workflowtype object to the Items collection that is used by attribute field types that may get qualifier from
                // the current workflow type (i.e. WorkflowActivityTypeAttribute
                var workflowType = new WorkflowType();
                workflowType.ActivityTypes = ActivityTypesState;
                System.Web.HttpContext.Current.Items["WorkflowType"] = workflowType;

                // Save the current workflow type attributes to state for any action settings that may need them
                var workflowAttributes = new Dictionary<Guid, Attribute>();
                AttributesState.OrderBy( a => a.Order ).ToList().ForEach( a => workflowAttributes.Add( a.Guid, a ) );
                System.Web.HttpContext.Current.Items["WorkflowTypeAttributes"] = workflowAttributes;

                if ( workflowAttributes.Any() )
                {
                    wpAttributes.Title = string.Format( "Attributes <small>Count: {0}</small>", workflowAttributes.Count.ToString( "N0" ) );
                }
                else
                {
                    wpAttributes.Title = "Attributes";
                }

                foreach ( var workflowActivityType in ActivityTypesState.OrderBy( a => a.Order ) )
                {
                    BuildActivityControl( phActivities, setValues, workflowActivityType, workflowAttributes, activeActivityTypeGuid, activeActionTypeGuid );
                }
            }
        }
        /// <summary>
        /// Shows the detail.
        /// </summary>
        /// <param name="itemKey">The item key.</param>
        /// <param name="itemKeyValue">The item key value.</param>
        /// <param name="parentCategoryId">The parent category id.</param>
        public void ShowDetail( string itemKey, int itemKeyValue, int? parentCategoryId )
        {
            if ( !itemKey.Equals( "workflowTypeId" ) )
            {
                pnlDetails.Visible = false;
                return;
            }

            var rockContext = new RockContext();

            WorkflowType workflowType = null;

            if ( !itemKeyValue.Equals( 0 ) )
            {
                workflowType = new WorkflowTypeService( rockContext ).Get( itemKeyValue );
            }
            else
            {
                workflowType = new WorkflowType { Id = 0, IsActive = true, IsPersisted = true, IsSystem = false, CategoryId = parentCategoryId };
                workflowType.ActivityTypes.Add( new WorkflowActivityType { Guid = Guid.NewGuid(), IsActive = true } );
            }

            if ( workflowType == null )
            {
                return;
            }

            pnlDetails.Visible = true;
            hfWorkflowTypeId.Value = workflowType.Id.ToString();

            // render UI based on Authorized and IsSystem
            bool readOnly = false;

            nbEditModeMessage.Text = string.Empty;
            if ( !IsUserAuthorized( Authorization.EDIT ) )
            {
                readOnly = true;
                nbEditModeMessage.Heading = "Information";
                nbEditModeMessage.Text = EditModeMessage.ReadOnlyEditActionNotAllowed( WorkflowType.FriendlyTypeName );
            }

            if ( workflowType.IsSystem )
            {
                readOnly = true;
                nbEditModeMessage.Heading = "Information";
                nbEditModeMessage.Text = EditModeMessage.ReadOnlySystem( WorkflowType.FriendlyTypeName );
            }

            if ( readOnly )
            {
                btnEdit.Visible = false;
                ShowReadonlyDetails( workflowType );
            }
            else
            {
                btnEdit.Visible = true;
                if ( workflowType.Id > 0 )
                {
                    ShowReadonlyDetails( workflowType );
                }
                else
                {
                    ShowEditDetails( workflowType, rockContext );
                }
            }
        }
示例#56
0
        private void LoadStateDetails( WorkflowType workflowType, RockContext rockContext )
        {
            if ( workflowType != null )
            {
                var attributeService = new AttributeService( rockContext );
                AttributesState = attributeService
                    .GetByEntityTypeId( new Workflow().TypeId ).AsQueryable()
                    .Where( a =>
                        a.EntityTypeQualifierColumn.Equals( "WorkflowTypeId", StringComparison.OrdinalIgnoreCase ) &&
                        a.EntityTypeQualifierValue.Equals( workflowType.Id.ToString() ) )
                    .OrderBy( a => a.Order )
                    .ThenBy( a => a.Name )
                    .ToList();

                ActivityTypesState = workflowType.ActivityTypes.OrderBy( a => a.Order ).ToList();
                ActivityAttributesState = new Dictionary<Guid, List<Attribute>>();

                foreach ( var activityType in ActivityTypesState )
                {
                    var activityTypeAttributes = attributeService
                        .GetByEntityTypeId( new WorkflowActivity().TypeId ).AsQueryable()
                        .Where( a =>
                            a.EntityTypeQualifierColumn.Equals( "ActivityTypeId", StringComparison.OrdinalIgnoreCase ) &&
                            a.EntityTypeQualifierValue.Equals( activityType.Id.ToString() ) )
                        .OrderBy( a => a.Order )
                        .ThenBy( a => a.Name )
                        .ToList();

                    ActivityAttributesState.Add( activityType.Guid, activityTypeAttributes );

                    foreach ( var actionType in activityType.ActionTypes )
                    {
                        var action = EntityTypeCache.Read( actionType.EntityTypeId );
                        if ( action != null )
                        {
                            Rock.Attribute.Helper.UpdateAttributes( action.GetEntityType(), actionType.TypeId, "EntityTypeId", actionType.EntityTypeId.ToString(), rockContext );
                            actionType.LoadAttributes( rockContext );
                        }
                    }
                }
            }
            else
            {
                AttributesState = new List<Attribute>();
                ActivityTypesState = new List<WorkflowActivityType>();
                ActivityAttributesState = new Dictionary<Guid, List<Attribute>>();
            }
        }
        /// <summary>
        /// Shows the edit details.
        /// </summary>
        /// <param name="workflowType">Type of the workflow.</param>
        private void ShowEditDetails( WorkflowType workflowType, RockContext rockContext )
        {
            if ( workflowType.Id == 0 )
            {
                lReadOnlyTitle.Text = ActionTitle.Add( WorkflowType.FriendlyTypeName ).FormatAsHtmlTitle();
                hlInactive.Visible = false;
            }

            SetEditMode( true );

            LoadDropDowns();

            tbName.Text = workflowType.Name;
            tbDescription.Text = workflowType.Description;
            cbIsActive.Checked = workflowType.IsActive ?? false;
            cpCategory.SetValue( workflowType.CategoryId );
            tbWorkTerm.Text = workflowType.WorkTerm;
            tbProcessingInterval.Text = workflowType.ProcessingIntervalSeconds != null ? workflowType.ProcessingIntervalSeconds.ToString() : string.Empty;
            cbIsPersisted.Checked = workflowType.IsPersisted;
            ddlLoggingLevel.SetValue( (int)workflowType.LoggingLevel );

            var attributeService = new AttributeService( rockContext );
            AttributesState = new ViewStateList<Attribute>();
            AttributesState.AddAll( attributeService.GetByEntityTypeId( new Workflow().TypeId ).AsQueryable()
                .Where( a =>
                    a.EntityTypeQualifierColumn.Equals( "WorkflowTypeId", StringComparison.OrdinalIgnoreCase ) &&
                    a.EntityTypeQualifierValue.Equals( workflowType.Id.ToString() ) )
                .OrderBy( a => a.Order )
                .ThenBy( a => a.Name )
                .ToList() );
            BindAttributesGrid();

            phActivities.Controls.Clear();
            foreach ( WorkflowActivityType workflowActivityType in workflowType.ActivityTypes.OrderBy( a => a.Order ) )
            {
                CreateWorkflowActivityTypeEditorControls( workflowActivityType );
            }

            RefreshActivityLists();
        }
示例#58
0
        /// <summary>
        /// Shows the detail.
        /// </summary>
        private void ShowDetail()
        {
            int? workflowTypeId = PageParameter( "workflowTypeId" ).AsIntegerOrNull();
            int? parentCategoryId = PageParameter( "ParentCategoryId" ).AsIntegerOrNull();

            if ( !workflowTypeId.HasValue )
            {
                pnlDetails.Visible = false;
                return;
            }

            var rockContext = new RockContext();

            WorkflowType workflowType = null;

            if ( workflowTypeId.Value.Equals( 0 ) )
            {
                workflowType = new WorkflowType();
                workflowType.Id = 0;
                workflowType.IsActive = true;
                workflowType.IsPersisted = true;
                workflowType.IsSystem = false;
                workflowType.CategoryId = parentCategoryId;
                workflowType.IconCssClass = "fa fa-list-ol";
                workflowType.ActivityTypes.Add( new WorkflowActivityType { Name = "Start", Guid = Guid.NewGuid(), IsActive = true, IsActivatedWithWorkflow = true } );
                workflowType.WorkTerm = "Work";
                workflowType.ProcessingIntervalSeconds = 28800; // Default to every 8 hours
                workflowType.SummaryViewText = GetAttributeValue( "DefaultSummaryViewText" );
                workflowType.NoActionMessage = GetAttributeValue( "DefaultNoActionMessage" );
                // hide the panel drawer that show created and last modified dates
                pdAuditDetails.Visible = false;
            }
            else
            {
                workflowType = new WorkflowTypeService( rockContext ).Get( workflowTypeId.Value );
                pdAuditDetails.SetEntity( workflowType, ResolveRockUrl( "~" ) );
            }

            if ( workflowType == null )
            {
                return;
            }

            pnlDetails.Visible = true;
            hfWorkflowTypeId.Value = workflowType.Id.ToString();

            // render UI based on Authorized and IsSystem
            bool readOnly = false;

            nbEditModeMessage.Text = string.Empty;
            // User must have 'Edit' rights to block, or 'Administrate' rights to workflow type
            if ( !IsUserAuthorized( Authorization.EDIT ) )
            {
                readOnly = true;
                nbEditModeMessage.Heading = "Information";
                nbEditModeMessage.Text = EditModeMessage.ReadOnlyEditActionNotAllowed( WorkflowType.FriendlyTypeName );
            }

            if ( workflowType.IsSystem )
            {
                readOnly = true;
                nbEditModeMessage.Heading = "Information";
                nbEditModeMessage.Text = EditModeMessage.ReadOnlySystem( WorkflowType.FriendlyTypeName );
            }

            if ( readOnly )
            {
                btnEdit.Visible = false;
                btnSecurity.Visible = false;
                ShowReadonlyDetails( workflowType );
            }
            else
            {
                btnEdit.Visible = true;

                btnSecurity.Title = "Secure " + workflowType.Name;
                btnSecurity.EntityId = workflowType.Id;

                if ( workflowType.Id > 0 )
                {
                    ShowReadonlyDetails( workflowType );
                }
                else
                {
                    LoadStateDetails(workflowType, rockContext);
                    ShowEditDetails( workflowType, rockContext );
                }
            }
        }
        private void LaunchWorkflow( WorkflowType workflowType, FinancialTransaction transaction )
        {
            if ( workflowType != null )
            {
                using ( var rockContext = new RockContext() )
                {
                    string workflowName = transaction.TransactionCode;
                    if ( transaction.AuthorizedPersonAliasId != null )
                    {
                        var person = new PersonAliasService( rockContext ).GetPerson( transaction.AuthorizedPersonAliasId.Value );
                        if ( person != null )
                        {
                            workflowName = person.FullName;
                        }
                    }

                    var workflowService = new WorkflowService( rockContext );
                    var workflow = Rock.Model.Workflow.Activate( workflowType, workflowName, rockContext );
                    if ( workflow != null )
                    {
                        List<string> workflowErrors;
                        workflowService.Process( workflow, transaction, out workflowErrors );
                    }
                }
            }
        }
        /// <summary>
        /// Adds the person to group.
        /// </summary>
        /// <param name="rockContext">The rock context.</param>
        /// <param name="person">The person.</param>
        /// <param name="workflowType">Type of the workflow.</param>
        /// <param name="groupMembers">The group members.</param>
        private void AddPersonToGroup( RockContext rockContext, Person person, WorkflowType workflowType, List<GroupMember> groupMembers )
        {
            if (person != null )
            {
                if ( !_group.Members
                    .Any( m =>
                        m.PersonId == person.Id &&
                        m.GroupRoleId == _defaultGroupRole.Id))
                {
                    var groupMemberService = new GroupMemberService(rockContext);
                    var groupMember = new GroupMember();
                    groupMember.PersonId = person.Id;
                    groupMember.GroupRoleId = _defaultGroupRole.Id;
                    groupMember.GroupMemberStatus = (GroupMemberStatus)GetAttributeValue("GroupMemberStatus").AsInteger();
                    groupMember.GroupId = _group.Id;
                    groupMemberService.Add( groupMember );
                    rockContext.SaveChanges();

                    if ( workflowType != null )
                    {
                        try
                        {
                            var workflowService = new WorkflowService( rockContext );
                            var workflow = Workflow.Activate( workflowType, person.FullName );

                            List<string> workflowErrors;
                            if ( workflow.Process( rockContext, groupMember, out workflowErrors ) )
                            {
                                if ( workflow.IsPersisted || workflow.IsPersisted )
                                {
                                    if ( workflow.Id == 0 )
                                    {
                                        workflowService.Add( workflow );
                                    }

                                    rockContext.WrapTransaction( () =>
                                    {
                                        rockContext.SaveChanges();
                                        workflow.SaveAttributeValues( _rockContext );
                                        foreach ( var activity in workflow.Activities )
                                        {
                                            activity.SaveAttributeValues( rockContext );
                                        }
                                    } );
                                }
                            }

                        }
                        catch (Exception ex)
                        {
                            ExceptionLogService.LogException( ex, this.Context );
                        }
                    }
                }
            }
        }