Пример #1
0
        internal WorkflowAction FirstJoint(WorkflowItem jumptedItem)
        {
            var trigger = new TriggerWorkflowAction(_triggeringItem);

            trigger.SetJumpedItem(jumptedItem);
            return(trigger);
        }
 public InputOutputMismatchException(WorkflowItem from, WorkflowItem to, string fromName, string toName)
 {
     this.from     = from;
     this.to       = to;
     this.fromName = fromName;
     this.toName   = toName;
 }
Пример #3
0
        public static WorkflowBase Convert(Session Session, Type ConvertToType, WorkflowBase CurrentObject)
        {
            object newObject = Activator.CreateInstance(ConvertToType, Session);

            CurrentObject.CopyProperties(newObject);

            for (int i = CurrentObject.Items.Count - 1; i >= 0; i--)
            {
                var workflowItem = new WorkflowItem(Session);

                CurrentObject.Items[i].CopyProperties(workflowItem);

                (newObject as WorkflowBase).Items.Add(workflowItem);
            }

            for (int i = CurrentObject.Attachments.Count - 1; i >= 0; i--)
            {
                var workFlowAttachment = new WorkFlowAttachment(Session);

                CurrentObject.Attachments[i].CopyProperties(workFlowAttachment);

                (newObject as WorkflowBase).Attachments.Add(workFlowAttachment);
            }

            (newObject as WorkflowBase).ChildItems.Add(CurrentObject);
            (newObject as WorkflowBase).Tracking.Add(CreateTracking(newObject as WorkflowBase, string.Format("Converted from {0}", CurrentObject.No)));

            return(newObject as WorkflowBase);
        }
Пример #4
0
        /// <summary>
        ///     Submits a membership request to the specified group's
        ///     moderation workflow for approval.
        /// </summary>
        /// <param name="member">The member information for the membership request</param>
        public void AddAModeratedMember(CommunityMember member)
        {
            // Define a unique reference representing the entity
            // under moderation. Note that this entity may be
            // transient or may not yet have been assigned a
            // unique identifier. Defining an item reference allows
            // you to bridge this gap.

            // For example: "members:/{group-id}/{user-reference}"

            var targetReference = CreateUri(member.GroupId, member.User);

            // Retrieve the workflow supporting moderation of
            // membership for the group to which the user is
            // being added.

            var moderationWorkflow = GetWorkflowFor(member.GroupId);

            // The workflow defines the intial (or 'start') state
            // for moderation.

            var initialState = moderationWorkflow.InitialState;

            // Create a new workflow item...

            var workflowItem = new WorkflowItem(
                WorkflowId.Create(moderationWorkflow.Id), // ...under the group's moderation workflow
                new WorkflowState(initialState),          // ...in the workflow's initial state
                Reference.Create(targetReference)         // ...identified with this reference
                );

            var memberRequest = _memberAdapter.Adapt(member);

            try
            {
                _workflowItemService.Add(workflowItem, memberRequest);
            }
            catch (SocialAuthenticationException ex)
            {
                throw new SocialRepositoryException("The application failed to authenticate with Episerver Social.",
                                                    ex);
            }
            catch (MaximumDataSizeExceededException ex)
            {
                throw new SocialRepositoryException(
                          "The application request was deemed too large for Episerver Social.", ex);
            }
            catch (SocialCommunicationException ex)
            {
                throw new SocialRepositoryException("The application failed to communicate with Episerver Social.", ex);
            }
            catch (SocialException ex)
            {
                throw new SocialRepositoryException("Episerver Social failed to process the application request.", ex);
            }
        }
Пример #5
0
        private WorkflowItem GetNextWorkflowItem(Repository repository, Workflow workflow, int workflowItemSequence)
        {
            WorkflowItem nextWorkflowItem = null;

            if (workflow != null && workflow.Items != null && workflow.Items.Length > 0)
            {
                nextWorkflowItem = workflow.Items.Where(it => it.Sequence == workflowItemSequence).FirstOrDefault();
            }
            return(nextWorkflowItem);
        }
Пример #6
0
        /// <summary>
        /// This method checks if Upload method should be executed.
        /// </summary>
        /// <param name="workflow">WorkflowItem to save</param>
        /// <returns>true if pre-condition check passed</returns>
        public static Tuple<bool, StoreActivitiesDC> CheckCanUpload(IWorkflowsQueryService proxy, WorkflowItem workflow)
        {
            StoreActivitiesDC workflowDC = DataContractTranslator.ActivityItemToStoreActivitiyDC(workflow);
            var workflowList = proxy.StoreActivitiesGetByName(workflowDC);

            //a new created workflow with duplicated name to be saved.
            if ((!workflow.IsOpenFromServer || workflow.Name != workflow.OriginalName) && workflowList.Count > 0)
            {
                MessageBoxService.CannotSaveDuplicatedNameWorkflow(workflow.Name);
                return new Tuple<bool, StoreActivitiesDC>(false, null);
            }

            StoreActivitiesDC latestWorkflow = workflowList.FirstOrDefault();
            bool shouldContinue = false;
            StoreActivitiesDC workflowToOpen = null;

            if (latestWorkflow == null || latestWorkflow.InsertedDateTime <= workflowDC.UpdatedDateTime)
            {
                if (AuthorizationService.IsAdministrator(AuthorizationService.CurrentPrincipalFunc())
                    || (latestWorkflow == null)
                    || (workflowDC.LockedBy == Environment.UserName))
                {
                    shouldContinue = true;
                }
                else
                {
                    MessageBoxService.CannotSaveLockedActivity();
                    shouldContinue = false;
                }
            }
            else // there is a new version saved on server after user checked current one out
            {
                if (AuthorizationService.IsAdministrator(AuthorizationService.CurrentPrincipalFunc()))
                {
                    if (MessageBoxService.CreateNewActivityOnSaving() == MessageBoxResult.Yes)
                    {
                        shouldContinue = true;
                    }
                }
                else
                {
                    if (MessageBoxService.DownloadNewActivityOnSaving() == MessageBoxResult.Yes)
                    {
                        workflowToOpen = latestWorkflow;
                    }
                }
            }
            return new Tuple<bool, StoreActivitiesDC>(shouldContinue, workflowToOpen);
        }
Пример #7
0
        public WorkflowItem GetWorkflowItemBySN(string serialNumber, String impersonateUser)
        {
            // if the serial number is null or empty we do not want to do any of this
            if (!string.IsNullOrEmpty(serialNumber))
            {
                using (var k2Connection = new Connection())
                {
                    ConnectionSetup k2Setup = new ConnectionSetup();
                    k2Setup.ConnectionString = Properties.Settings.Default.WorkflowServerConnectionString;

                    k2Connection.Open(k2Setup);

                    if (!String.IsNullOrEmpty(impersonateUser))
                    {
                        k2Connection.ImpersonateUser(impersonateUser);
                    }

                    var workCriteria = new WorklistCriteria {
                        NoData = false, Platform = "ASP"
                    };

                    if (!string.IsNullOrEmpty(serialNumber))
                    {
                        workCriteria.AddFilterField(WCField.SerialNumber, WCCompare.Equal, serialNumber);
                    }

                    Worklist k2Worklist = k2Connection.OpenWorklist(workCriteria);

                    WorkflowItem retItem = null;

                    foreach (WorklistItem item in k2Worklist)
                    {
                        retItem = new WorkflowItem(item);
                    }

                    // now that we have the workflow item get the count of the related documents
                    if ((retItem != null) && (!string.IsNullOrEmpty(retItem.PolicyID)))
                    {
                        using (DocumentService.DocumentServiceClient client = new DocumentService.DocumentServiceClient())
                        {
                            retItem.RelatedDocumentCount = client.GetDocumentsCountForPolicy(retItem.PolicyID);
                        }
                    }

                    return(retItem);
                }
            }
            return(null);
        }
Пример #8
0
        public InitialConnection(WorkflowItem to, string toName)
        {
            if (!to.Inputs.ContainsKey(toName))
            {
                throw new OutputNotFoundException(to, toName);
            }
            if (typeof(T) != to.Inputs[toName])
            {
                throw new InputMismatchException(to, toName, typeof(T));
            }

            To          = to;
            ToName      = toName;
            ContentType = to.Inputs[toName];
        }
Пример #9
0
        public WorkflowConnection(WorkflowItem from, WorkflowItem to, string fromName, string toName)
        {
            if (!from.Outputs.ContainsKey(fromName))
            {
                throw new InputNotFoundException(from, fromName);
            }
            if (!to.Inputs.ContainsKey(toName))
            {
                throw new OutputNotFoundException(to, toName);
            }
            if (from.Outputs[fromName] != to.Inputs[toName] && !from.Outputs[fromName].IsSubclassOf(to.Inputs[toName]))
            {
                throw new InputOutputMismatchException(from, to, fromName, toName);
            }


            From        = from;
            To          = to;
            FromName    = fromName;
            ToName      = toName;
            ContentType = from.Outputs[fromName];
        }
        public WorkflowItem BuildItem(HistoryEvent historyEvent, IEnumerable<HistoryEvent> history)
        {
            var eventId = historyEvent.GetInitialEventId();
            var state = GetStatus(eventId, history);

            var item = new WorkflowItem
            {
                EventId = historyEvent.EventId,
                Kind = WorkflowItemKind.ActivityCancellation,
                State = state,
                Result = state == WorkflowItemState.Completed ? history.GetActivityResult(eventId) : null,
                Reason = state == WorkflowItemState.Failed ? history.GetActivityReason(eventId) : null,
                Details =
                    state == WorkflowItemState.Failed ||
                    state == WorkflowItemState.Canceled ? history.GetActivityDetails(eventId) : null
            };

            if (state == WorkflowItemState.CancelRequested)
            {
                var attributes = historyEvent.ActivityTaskCancelRequestedEventAttributes;
                var decisionId = historyEvent.ActivityTaskCancelRequestedEventAttributes.DecisionTaskCompletedEventId;

                item.Order = decisionId;
                item.Id = attributes.ActivityId;
            }
            else if (state == WorkflowItemState.CancelFailed)
            {
                var attributes = historyEvent.RequestCancelActivityTaskFailedEventAttributes;
                var decisionId = historyEvent.RequestCancelActivityTaskFailedEventAttributes.DecisionTaskCompletedEventId;

                item.Order = decisionId;
                item.Id = attributes.ActivityId;
                item.Reason = attributes.Cause;
            }

            return item;
        }
Пример #11
0
        public static void Setup(IDocumentStore documentStore)
        {
            using (var storeSession = documentStore.OpenSession())
            {
                var rootDocument = new WorkflowItem
                {
                    Id           = "rootDocumentId",
                    Text         = "Workflow 3",
                    DisplayOrder = 0,
                };
                storeSession.Store(rootDocument);

                var subTask1Start = new WorkflowItem
                {
                    Id           = "subTask1StartId",
                    WorkflowId   = rootDocument.Id,
                    Text         = "SubTask1",
                    DisplayOrder = 0,
                };
                storeSession.Store(subTask1Start);

                storeSession.SaveChanges();
            }
        }
Пример #12
0
 /// <summary>
 /// Save a workflow to an image representation
 /// </summary>
 /// <param name="workflow"></param>
 public void SaveToImageFile(WorkflowItem workflow)
 {
     if (workflow == null)
     {
         throw new ArgumentNullException("workflow");
     }
     if (workflow.WorkflowDesigner != null)
         workflow.WorkflowDesigner.SaveWorkflowToBitmap();
 }
Пример #13
0
 /// <summary>
 /// Save focused workflow to server.
 /// </summary>
 /// <param name="workflow">The workflow to be saved.</param>
 // TODO: Changed to new Composite DataContract, needs to be verified
 public bool SaveToServer(WorkflowItem workflow)
 {
     bool isSuccess;
     IsBusy = true;
     BusyCaption = string.Format(UploadAsPrivateBusyMessage, workflow.Name, workflow.Version);
     isSuccess = this.UploadWorkflowWithBusy(workflow);
     workflow.HasMajorChanged = false;
     IsBusy = false;
     BusyCaption = String.Empty;
     return isSuccess;
 }
Пример #14
0
        private void CreatePendingWorkflowItem(Repository repository, TextContent content, string userName, Workflow workflow, WorkflowItem workflowItem, string previousComment)
        {
            PendingWorkflowItem pendingWorkflowItem = new PendingWorkflowItem()
            {
                Repository           = repository,
                Name                 = content.UUID,
                WorkflowName         = workflow.Name,
                WorkflowItemSequence = workflowItem.Sequence,
                ItemDisplayName      = workflowItem.DisplayName,
                RoleName             = workflowItem.RoleName,
                ContentFolder        = content.FolderName,
                ContentUUID          = content.UUID,
                ContentSummary       = content.GetSummary(),
                CreationUtcDate      = DateTime.UtcNow,
                CreationUser         = userName,
                PreviousComment      = previousComment
            };

            PendingWorkflowItemProvider.Add(pendingWorkflowItem);
        }
Пример #15
0
 internal TriggerActions(WorkflowItem triggeringItem)
 {
     _triggeringItem = triggeringItem;
 }
Пример #16
0
        public virtual void ProcessPendingWorkflowItem(Repository repository, string workflowName, string roleName, string pendingWorkflowItemId, string userName, bool passed, string comment)
        {
            var pendingItem = PendingWorkflowItemProvider.Get(new PendingWorkflowItem()
            {
                RoleName = roleName, Name = pendingWorkflowItemId, Repository = repository
            });

            if (pendingItem != null)
            {
                var content = new TextFolder(repository, pendingItem.ContentFolder).CreateQuery().WhereEquals("UUID", pendingItem.ContentUUID).FirstOrDefault();
                if (content != null)
                {
                    var  workflow = Get(repository, workflowName);
                    bool finished = false;
                    if (workflow != null)
                    {
                        WorkflowItem nextWorkflowItem = null;
                        if (passed)
                        {
                            nextWorkflowItem = GetNextWorkflowItem(repository, workflow, pendingItem.WorkflowItemSequence + 1);
                            if (nextWorkflowItem == null)
                            {
                                finished = true;
                            }
                        }
                        else
                        {
                            nextWorkflowItem = GetNextWorkflowItem(repository, workflow, pendingItem.WorkflowItemSequence - 1);
                        }
                        if (nextWorkflowItem != null)
                        {
                            CreatePendingWorkflowItem(repository, content, userName, workflow, nextWorkflowItem, comment);
                        }
                    }

                    if (finished)
                    {
                        var published = content.Published.HasValue ? content.Published.Value : false;
                        if (passed && !published)
                        {
                            ServiceFactory.TextContentManager.Update(repository, new Schema(repository, content.SchemaName), content.UUID
                                                                     , new string[] { "Published" }, new object[] { true }, userName);
                        }
                    }
                    WorkflowHistory history = new WorkflowHistory()
                    {
                        Id                   = WorkflowHistoryProvider.All(content).Count() + 1,
                        Repository           = repository,
                        WorkflowName         = pendingItem.WorkflowName,
                        WorkflowItemSequence = pendingItem.WorkflowItemSequence,
                        ItemDisplayName      = pendingItem.ItemDisplayName,
                        ContentFolder        = pendingItem.ContentFolder,
                        ContentUUID          = pendingItem.ContentUUID,
                        ContentSummary       = content.GetSummary(),
                        RoleName             = pendingItem.RoleName,
                        Passed               = passed,
                        ProcessingUtcDate    = DateTime.UtcNow,
                        ProcessingUser       = userName,
                        Finished             = finished,
                        Comment              = comment
                    };

                    WorkflowHistoryProvider.Add(history);
                }
                PendingWorkflowItemProvider.Remove(pendingItem);
            }
        }
        /// <summary>
        /// Gets the detailed workflow view with items
        /// </summary>
        /// <param name="id">The workflow identifier.</param>
        /// <returns>DetailedWorkflow view with items.</returns>
        public DetailedWorkflow GetDetailedWorkflow(string id)
        {
            var response = new DetailedWorkflow();
            var wfItem   = this._masterDatabase.GetItem(new ID(id));

            response.Id   = wfItem.ID.ToString();
            response.Name = wfItem.Name;

            List <Item> items = new List <Item>();

            var index = ContentSearchManager.GetIndex(Constants.IndexNames.SitecoreMasterIndex);

            if (index != null)
            {
                foreach (var wfState in wfItem.Children.Where(t => t.TemplateID == Templates.WorkflowState.TemplateId))
                {
                    var state = new DetailedWorkflowState
                    {
                        Id      = wfState.ID.ToString(),
                        IsFinal = wfState[Templates.WorkflowState.Fields.Final] == "1",
                        Name    = wfState.Name
                    };

                    using (var context = index.CreateSearchContext(SearchSecurityOptions.DisableSecurityCheck))
                    {
                        var wfStateId         = Sitecore.ContentSearch.Utilities.IdHelper.NormalizeGuid(wfState.ID);
                        var resultItems       = context.GetQueryable <WorkflowSearchItem>().Where(p => p.WorkflowState == wfStateId && p.IsLatestVersion);
                        var searchResultItems = resultItems.GetResults();

                        foreach (var resultItem in searchResultItems.Hits)
                        {
                            var item = this._masterDatabase.GetItem(resultItem.Document.ItemId, Language.Parse(resultItem.Document.Language));

                            if (item != null)
                            {
                                var workflowItem = new WorkflowItem()
                                {
                                    ID             = item.ID.ToString(),
                                    Name           = item.Name,
                                    Language       = resultItem.Document.Language ?? string.Empty,
                                    LastUpdated    = item.Statistics?.Updated ?? DateTime.MinValue,
                                    LastUpdatedBy  = item.Statistics?.UpdatedBy ?? string.Empty,
                                    TemplateName   = item.TemplateName,
                                    HasLayout      = item.Visualization?.Layout != null,
                                    CurrentVersion = item.Version.Number,
                                    Icon           = GetIconUrl(item),
                                    NextStates     = GetNextStates(item, wfState)
                                };

                                var currentDbState = item[Constants.StandardFieldNames.WorkflowState];
                                if (currentDbState.Equals(wfState.ID.ToString(), StringComparison.OrdinalIgnoreCase))
                                {
                                    state.Items.Add(workflowItem);
                                }
                                else
                                {
                                    // State is not matching in the index and in the db, maybe due to the async indexing operations
                                    // We still need to ensure the proper state
                                    var previousState = response.States.FirstOrDefault(t => t.Id.Equals(currentDbState));
                                    if (previousState != null)
                                    {
                                        // Item state should point to a previous state
                                        previousState.Items.Add(new WorkflowItem()
                                        {
                                            ID             = item.ID.ToString(),
                                            Name           = item.Name,
                                            Language       = resultItem.Document.Language ?? string.Empty,
                                            LastUpdated    = item.Statistics?.Updated ?? DateTime.MinValue,
                                            LastUpdatedBy  = item.Statistics?.UpdatedBy ?? string.Empty,
                                            TemplateName   = item.TemplateName,
                                            HasLayout      = item.Visualization?.Layout != null,
                                            CurrentVersion = item.Version.Number,
                                            Icon           = GetIconUrl(item),
                                            NextStates     = GetNextStates(item, this.GetItem(currentDbState))
                                        });
                                    }
                                    else
                                    {
                                        // Item
                                        itemsInWrongState.Add(new MemoryStoreItem
                                        {
                                            ItemId   = item.ID.ToString(),
                                            State    = currentDbState,
                                            Language = item.Language.Name
                                        });
                                    }
                                }
                            }
                        }

                        foreach (var itemInWrongState in itemsInWrongState.Where(t => t.State.Equals(state.Id)))
                        {
                            var item = this._masterDatabase.GetItem(itemInWrongState.ItemId, Language.Parse(itemInWrongState.Language));

                            if (item != null)
                            {
                                var workflowItem = new WorkflowItem()
                                {
                                    ID             = item.ID.ToString(),
                                    Name           = item.Name,
                                    Language       = item.Language?.Name ?? string.Empty,
                                    LastUpdated    = item.Statistics?.Updated ?? DateTime.MinValue,
                                    LastUpdatedBy  = item.Statistics?.UpdatedBy ?? string.Empty,
                                    TemplateName   = item.TemplateName,
                                    HasLayout      = item.Visualization?.Layout != null,
                                    CurrentVersion = item.Version.Number,
                                    Icon           = GetIconUrl(item),
                                    NextStates     = GetNextStates(item, wfState)
                                };

                                state.Items.Add(workflowItem);
                            }
                        }
                        response.States.Add(state);
                    }
                }
            }

            response.QuickFilters.Add("TemplateName", response.States?.SelectMany(t => t.Items).Select(t => t.TemplateName).Distinct());
            response.QuickFilters.Add("LastUpdatedBy", response.States?.SelectMany(t => t.Items).Select(t => t.LastUpdatedBy).Distinct());

            return(response);
        }
Пример #18
0
 public OutputNotFoundException(WorkflowItem to, string toName)
 {
     this.to     = to;
     this.toName = toName;
 }
Пример #19
0
        public bool UploadWorkflowWithBusy(WorkflowItem workflow)
        {
            bool result = false;
            Utility.DoTaskWithBusyCaption("Saving...", () =>
            {
                result = WorkflowsQueryServiceUtility.UsingClientReturn(client =>
                {
                    return UploadWorkflow(client, workflow);
                });
            }, false);

            return result;
        }
Пример #20
0
 public void CloseWorkflowItem(int index, WorkflowItem itemToClose)
 {
     RemoveWorkflowItemAndSetFocusedWorkflowItem(itemToClose);
     WorkflowItems.RemoveAt(index);
 }
Пример #21
0
        public bool UploadWorkflow(IWorkflowsQueryService client, WorkflowItem workflow, bool shouldBeLoose = true)
        {
            StoreActivitiesDC workflowDC = null;
            ActivityAssemblyItem fakeLibrary = null;

            var checkResult = WorkflowUploader.CheckCanUpload(client, workflow);
            if (!checkResult.Item1 && checkResult.Item2 == null)
            {
                return false;
            }
            else if (!checkResult.Item1 && checkResult.Item2 != null)
            {
                workflowDC = checkResult.Item2;
                fakeLibrary = GetActivityLibraries(client, workflowDC);
            }

            if (shouldBeLoose)
                workflow.SetXamlCode();

            var upResult = WorkflowUploader.Upload(client, workflow);
            if (upResult.Errorcode != 0)
            {
                ErrorMessageType = "Error Saving to Server";
                ErrorMessage = upResult.ErrorMessage + "\r\n\r\nYour changes were not successfully saved to the server.";
                return false;
            }
            else
            {
                OnStoreActivitesUnlock(workflow, false);
                workflow.OriginalName = workflow.Name;
                workflow.OldVersion = workflow.Version;
            }

            if (workflowDC != null && fakeLibrary != null)
            {
                OpenStoreActivitiesDC(workflowDC, fakeLibrary);
            }

            if (this.FocusedWorkflowItem.Name == workflow.Name && this.FocusedWorkflowItem.Version == workflow.Version)
                this.FocusedWorkflowItem.TaskActivityGuid = workflow.TaskActivityGuid;

            return true;
        }
Пример #22
0
 /// <summary>
 /// Unlock a workflow on query service
 /// </summary>
 /// <param name="workflowDC"></param>
 public void StoreActivitesUnlockWithBusy(WorkflowItem workflow, bool shouldUpdateNewVersion)
 {
     Utility.WithContactServerUI(() =>
     {
         StoreActivitesUnlock(workflow, shouldUpdateNewVersion);
     });
 }
Пример #23
0
 public void StoreActivitesUnlock(WorkflowItem workflow, bool shouldUpdateNewVersion)
 {
     if (!workflow.IsReadOnly)
     {
         StoreActivitiesDC workflowDC = DataContractTranslator.ActivityItemToStoreActivitiyDC(workflow);
         WorkflowsQueryServiceUtility.UsingClient(client =>
         {
             workflowDC.Name = workflow.OriginalName;
             workflowDC.Incaller = Assembly.GetExecutingAssembly().GetName().Name;
             workflowDC.IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
             workflowDC.Locked = false;
             workflowDC.LockedBy = Environment.UserName;
             workflowDC.UpdatedDateTime = DateTime.UtcNow;
             workflowDC.Version = shouldUpdateNewVersion ? workflow.Version : workflow.OldVersion;
             var reply = client.StoreActivitiesSetLock(workflowDC, workflowDC.UpdatedDateTime);
             reply.CheckErrors();
         });
     }
 }
Пример #24
0
 public void RegisterPostRouterWorkflow(WorkflowItem <PostRouteWorkflowData> item)
 {
     postRouteWorkflow.AddItem(item);
 }
 public static WorkflowItem CreateWorkflowItem(int workflowItemID, int decision, string message, global::System.DateTime decisionDate)
 {
     WorkflowItem workflowItem = new WorkflowItem();
     workflowItem.WorkflowItemID = workflowItemID;
     workflowItem.Decision = decision;
     workflowItem.Message = message;
     workflowItem.DecisionDate = decisionDate;
     return workflowItem;
 }
Пример #26
0
 public InputMismatchException(WorkflowItem to, string toName, Type type)
 {
     this.to     = to;
     this.toName = toName;
     this.type   = type;
 }
 public void AddToWorkflowItems(WorkflowItem workflowItem)
 {
     base.AddObject("WorkflowItems", workflowItem);
 }
Пример #28
0
        private WorkflowItem GetBlankProject()
        {
            WorkflowItem workflowItem = null;

            workflowItem = new WorkflowItem(WorkflowClassName, WorkflowName, Properties.Resources.EmptyWorkflowTemplate, string.Empty)
                                   {
                                       CachingStatus = CachingStatus.None,
                                       Category = DefaultCategory,
                                       Name = WorkflowClassName,
                                       DisplayName = WorkflowName,
                                       Description = WorkflowName,
                                       FullName = WorkflowClassName,
                                       HasCodeBehind = false,
                                       IsSavedToServer = true,
                                       Version = DefaultVersion,
                                       IsDataDirty = false,
                                       Tags = DefaultTags,
                                       WorkflowType = DefaultWorkflowType,
                                   };

            return workflowItem;
        }
Пример #29
0
        public static StoreLibraryAndTaskActivityRequestDC WorkflowToStoreLibraryAndTaskActivityRequestDC(WorkflowItem workflow, IEnumerable<ActivityAssemblyItem> assemblyItemsUsed)
        {
            string libraryName = workflow.Name;
            var library = GetActivityLibraryDC(libraryName, workflow.Category, workflow.Description, workflow.CreatedBy, workflow.Version, workflow.Status);
            var dependencyList = new List<StoreActivityLibraryDependenciesGroupsRequestDC>(
                assemblyItemsUsed.Select(asm => new StoreActivityLibraryDependenciesGroupsRequestDC
                {
                    Name = asm.Name,
                    Version = asm.Version.ToString(),
                }.SetIncaller())
            );

            return new StoreLibraryAndTaskActivityRequestDC
            {
                Incaller = Utility.GetCallerName(),
                IncallerVersion = Utility.GetCallerVersion(),
                InInsertedByUserAlias = !String.IsNullOrEmpty(workflow.CreatedBy) ? workflow.CreatedBy : Utility.GetCurrentUserName(),
                InUpdatedByUserAlias = Utility.GetCurrentUserName(),
                EnforceVersionRules = true,
                ActivityLibrary = library,
                StoreActivityLibraryDependenciesGroupsRequestDC = new StoreActivityLibraryDependenciesGroupsRequestDC()
                {
                    Name = libraryName,
                    Version = workflow.Version,
                    List = dependencyList
                }.SetIncaller(),
                TaskActivitiesList = new List<TaskActivityDC>()
                {
                    new TaskActivityDC()
                    {
                        Guid = workflow.TaskActivityGuid.Value,
                        AssignedTo = Utility.GetCurrentUserName(),
                        Activity = ActivityItemToStoreActivitiyDC(workflow),
                        Status = workflow.TaskActivityStatus.Value
                    }
                }
            };
        }
Пример #30
0
        public ActionResult _Preview(String Id)
        {
            WorkflowItem w = this._bm.GetWorkflowItemBySN(Id);

            return(PartialView(w));
        }
Пример #31
0
        /// <summary>
        /// Close the workflowItem passed in from the designer.
        /// </summary>
        /// <param name="itemToClose">workflowItem To close</param>
        public void CloseWorkflowCommandExecute(WorkflowItem itemToClose)
        {
            // We'll allow it without prompt if it's saved either to server or locally
            SavingResult? result = null;
            bool isSaveToLocal = false;
            //open from server and make the changes
            if (itemToClose.IsReadOnly)
            {
                CloseWorkflowItem(itemToClose);
            }
            else
            {
                if (itemToClose.IsOpenFromServer && itemToClose.IsDataDirty)
                {
                    result = MessageBoxService.ShowClosingComfirmation(itemToClose.Name);
                }
                else if (itemToClose.IsOpenFromServer && !itemToClose.IsDataDirty) //open from server and not make the changes
                {
                    result = MessageBoxService.ShowKeepLockedComfirmation(itemToClose.Name);
                }
                else if (!itemToClose.IsOpenFromServer && itemToClose.IsDataDirty)//open from local and make the changes
                {
                    result = MessageBoxService.ShowLocalSavingComfirmation(itemToClose.Name);
                    isSaveToLocal = true;
                }
                else//open from local and not make the changes
                {
                    CloseWorkflowItem(itemToClose);
                }
                if (result != null)
                {
                    bool shouldCancel = false;
                    if (isSaveToLocal && result.Value.HasFlag(SavingResult.Save))
                    {
                        shouldCancel = !SaveToLocal(itemToClose, true);
                    }
                    else if (!isSaveToLocal && result.Value.HasFlag(SavingResult.Save))
                    {
                        shouldCancel = !SaveToServer(itemToClose);
                    }
                    if (result.Value.HasFlag(SavingResult.Unlock))
                    {
                        OnStoreActivitesUnlockWithBusy(itemToClose, result.Value.HasFlag(SavingResult.Save));
                    }

                    if (!shouldCancel)
                    {
                        CloseWorkflowItem(itemToClose);
                    }
                }
            }
        }
Пример #32
0
 private void RemoveWorkflowItemAndSetFocusedWorkflowItem(WorkflowItem itemToClose)
 {
     itemToClose.Close();
     FocusedWorkflowItem = WorkflowItems.FirstOrDefault(w => w != itemToClose);
 }
Пример #33
0
 private void CloseWorkflowItem(WorkflowItem itemToClose)
 {
     RemoveWorkflowItemAndSetFocusedWorkflowItem(itemToClose);
     WorkflowItems.Remove(itemToClose);
 }
Пример #34
0
        /// <summary>
        /// Logic for Compile button, after WorkflowCompiler has done its work. Separated out for testability.
        /// </summary>
        private void CompileCommandExecutePostCompile(WorkflowItem compiledWorkflow, CompileResult compileResult)
        {
            if (compiledWorkflow == null)
            {
                throw new ArgumentNullException("compiledWorkflow");
            }

            if (compileResult == null)
            {
                throw new ArgumentNullException("compileResult");
            }

            // Import compile result. We signal to the UX that there has been a change, and it should respond by running the
            // import process
            try
            {
                Compiler.AddToCaching(compileResult.FileName);
                MessageBoxService.CompileSuccessed(compiledWorkflow.Name);
            }
            catch (Exception ex)
            {
                throw new UserFacingException(ex.Message);
            }
        }
Пример #35
0
        public static WorkflowItem StoreActivitiyDCToWorkflowItem(
            StoreActivitiesDC dc,
            ActivityAssemblyItem parentAssemblyItem,
            List<ActivityAssemblyItem> references = null,
            bool isTask = false)
        {
            var workflowItem = new WorkflowItem(dc.Name, dc.Name, dc.Xaml, dc.WorkflowTypeName, references);

            workflowItem.CachingStatus = CachingStatus.None;
            workflowItem.Category = dc.ActivityCategoryName;

            workflowItem.CreateDateTime = dc.InsertedDateTime;
            workflowItem.CreatedBy = dc.InsertedByUserAlias;
            workflowItem.Description = dc.Description;
            workflowItem.FullName = dc.Name;
            workflowItem.Name = dc.Name;
            workflowItem.DisplayName = dc.ShortName ?? dc.Name;
            workflowItem.HasCodeBehind = dc.IsCodeBeside;
            workflowItem.ParentAssemblyItem = parentAssemblyItem;
            workflowItem.Status = dc.StatusCodeName;
            workflowItem.UpdatedBy = dc.UpdatedByUserAlias;
            workflowItem.UpdateDateTime = dc.UpdatedDateTime;
            workflowItem.IsSavedToServer = true;
            workflowItem.Version = workflowItem.OldVersion = dc.Version;
            workflowItem.IsDataDirty = false;
            workflowItem.Tags = dc.MetaTags;
            workflowItem.XamlCode = dc.Xaml;
            workflowItem.WorkflowType = dc.WorkflowTypeName;
            workflowItem.IsOpenFromServer = true;
            workflowItem.IsTask = isTask;
            return workflowItem;
        }
Пример #36
0
        public void RunWorkflow()
        {
            WorkflowResult finalResult     = new WorkflowResult();
            String         LastItemRun     = "";
            int            LastRunResultID = 0;

            try
            {
                RunWorkflow run = db.RunWorkflows.Where(r => r.RunID == RunID).FirstOrDefault();

                run.StartTime = DateTime.Now;
                db.SaveChanges();

                List <vwRunItem> items = db.vwRunItems.Where(i => i.RunID == RunID).OrderBy(i => i.RunOrder).ToList();
                RunPayload       pl    = run.RunPayloads.FirstOrDefault();

                foreach (vwRunItem item in items)
                {
                    DateTime    StartTime = DateTime.Now;
                    LibraryItem li        = db.LibraryItems.Where(l => l.ItemID == item.ItemID).FirstOrDefault();

                    if (!String.IsNullOrEmpty(item.HtmlAnswers))
                    {
                        pl = util.SetPayload(RunID, li.ItemID, item.HtmlAnswers);
                    }

                    LastItemRun = li.ItemName;

                    WorkflowItem wfi = db.WorkflowItems.Where(w => w.ItemID == item.ItemID).FirstOrDefault();

                    RunResult rr = new RunResult
                    {
                        ResultString = "",
                        RunID        = RunID,
                        ResultID     = 1,
                        TimeStarted  = DateTime.Now,
                        WFItemID     = wfi.WFItemID
                    };

                    db.RunResults.Add(rr);
                    db.SaveChanges();

                    LastRunResultID = rr.RunResultID;

                    Assembly assembly         = Assembly.LoadFrom(li.LibraryPath);
                    Type     type             = assembly.GetType("ItemToRun.RunWorkflowItem");
                    object   instanceOfMyType = Activator.CreateInstance(type);

                    var result = type.InvokeMember("RunItem",
                                                   BindingFlags.Default | BindingFlags.InvokeMethod,
                                                   null,
                                                   instanceOfMyType,
                                                   new Object[] { run.EmpID, pl == null ? new RunPayload() : pl });

                    IEnumerable <PropertyInfo> props = result.GetType().GetRuntimeProperties();

                    int      ResultID   = Convert.ToInt32(props.ElementAt(0).GetValue(result, null));
                    String   ResultText = props.ElementAt(1).GetValue(result, null).ToString();
                    DateTime TimeDone   = Convert.ToDateTime(props.ElementAt(2).GetValue(result, null));

                    RunResult rrDone = db.RunResults.Where(r => r.RunResultID == rr.RunResultID).FirstOrDefault();

                    rrDone.TimeCompleted = DateTime.Now;
                    rrDone.ResultID      = ResultID;
                    rrDone.ResultString  = ResultText;
                    db.SaveChanges();

                    finalResult = new WorkflowResult {
                        Success = true, ResultString = ""
                    };
                }
            }
            catch (Exception ex)
            {
                finalResult = new WorkflowResult {
                    Success = false, ResultString = String.Format("There was an error during the run in the {0} item.", LastItemRun), FullError = ex
                };

                RunResult rrError = db.RunResults.Where(r => r.RunResultID == LastRunResultID).FirstOrDefault();
                rrError.ResultID      = 4;
                rrError.ResultString  = String.Format("Error: {0}", ex.Message);
                rrError.TimeCompleted = DateTime.Now;
                db.SaveChanges();
            }
        }
Пример #37
0
        /// <summary>
        /// Persists a workflow to disk, in various formats, such as:
        ///     wf      binary serialized
        ///     jpg     image
        ///     xaml    straight XAML text only, no metadata
        /// </summary>
        /// <param name="workflow">The workflow to be persisted to disk.</param>
        /// <param name="forceSaveAs">If true, forces the save as dialog to appear.</param>
        /// <returns>If true then the file was saved</returns>
        public bool SaveToLocal(WorkflowItem workflow, bool forceSaveAs)
        {
            bool isSuccess = false;   // This will be set to true on a successful save.
            string targetFileName;
            string fileExtension;

            // If the file name is null, or forceSaveAs is true, show the dialog and get the file name.
            if (string.IsNullOrEmpty(workflow.LocalFileFullName) || forceSaveAs)
            {
                string filter = "Workflow files (*.wf)|*.wf|XAML Text files (*.xaml)|*.xaml|JPEG Image files (*.jpg)|*.jpg";
                targetFileName = DialogService.ShowSaveDialogAndReturnResult(workflow.Name, filter);
                if (!string.IsNullOrEmpty(targetFileName))
                {
                    fileExtension = Path.GetExtension(targetFileName);
                    if (string.IsNullOrEmpty(fileExtension))
                    {
                        targetFileName += "." + DefaultSaveFileLocalExtension;
                        fileExtension = DefaultSaveFileLocalExtension;
                    }

                    switch (fileExtension.ToLower())
                    {
                        case ".wf":
                            using (var stream = File.Open(targetFileName, FileMode.Create))
                            {
                                var formatter = new BinaryFormatter();
                                workflow.SetXamlCode();
                                workflow.SetReferences();
                                formatter.Serialize(stream, workflow);
                                isSuccess = true;
                            }
                            break;

                        case ".jpg":
                            if (workflow.WorkflowDesigner != null)
                            {
                                workflow.WorkflowDesigner.SaveWorkflowToBitmap(targetFileName);
                                isSuccess = true;
                            }
                            break;
                        case ".xaml":
                            workflow.WorkflowDesigner.Save(targetFileName);
                            isSuccess = true;
                            break;
                        default:
                            throw new UserFacingException("The file type is not recognized. The save to local could not be completed.");
                    }
                }
            }

            return isSuccess;
        }
Пример #38
0
        /// <summary>
        /// The main method of WorkflowUploader. Upload the given workflow and its dependencies to server using the default WorkflowsQueryService, as a new activityLibrary.
        /// </summary>;
        /// <param name="workflow">WorkflowItem to save</param>
        /// <returns>true if uploaded succeeded, else CommunicationException</returns>
        /// <exception cref="CommunicationException">WCF layer exceptions and error codes from the workflow query service will be wrapped as CommunicationExceptions</exception>
        public static StatusReplyDC Upload(IWorkflowsQueryService proxy, WorkflowItem workflow)
        {
            var assemblyActivitiyItemsUsed = workflow.WorkflowDesigner.DependencyAssemblies;

            // Database requires that we upload dependencies first so the DB is always in a consistent state
            Upload(proxy, assemblyActivitiyItemsUsed);

            // Now, upload the actual workflow
            StoreActivitiesDC result = null;
            if (workflow.TaskActivityGuid.HasValue) {
                result = proxy.UploadActivityLibraryAndTaskActivities(
                    DataContractTranslator.WorkflowToStoreLibraryAndTaskActivityRequestDC(workflow, assemblyActivitiyItemsUsed)
                )[0].Activity;
            }
            else {
                List<TaskAssignment> tasks = workflow.WorkflowDesigner.Tasks;
                Guid[] newTaskIds = tasks.Where(t => t.TaskStatus == TaskActivityStatus.New).Select(t => t.TaskId).ToArray();
                if (newTaskIds.Any()) {
                    workflow.WorkflowDesigner.SetNewTasksToAssigned(newTaskIds);
                    workflow.SetXamlCode(); // Publication has removed all tasks from workflow
                }
                try {
                    result = proxy.UploadActivityLibraryAndDependentActivities(
                        DataContractTranslator.WorkflowToStoreLibraryAndActivitiesRequestDC(workflow, assemblyActivitiyItemsUsed, tasks)
                    )[0];
                }
                catch (Exception) {
                    if (newTaskIds.Any())
                        workflow.WorkflowDesigner.RollbackAssignedTasks(newTaskIds);
                }
            }

            result.StatusReply.CheckErrors();
            // No exception = success. Disable the Save button, clean up, return true to report success.
            workflow.FinishTaskAssigned();

            workflow.CreateDateTime = result.InsertedDateTime;
            workflow.UpdateDateTime = result.UpdatedDateTime;
            workflow.Version = result.Version;

            workflow.IsOpenFromServer = true;
            workflow.IsSavedToServer = true;
            workflow.IsDataDirty = false;

            return result.StatusReply;
        }
Пример #39
0
 /// <summary>
 /// Checks to see if the WorkflowItem is already in the editor active and adds it if it is not
 /// </summary>
 /// <param name="itemToCheck">Workflow to check</param>
 public bool CheckIsAlreadyInListOrAdd(WorkflowItem itemToCheck)
 {
     Contract.Requires(itemToCheck != null);
     var itemToFind = WorkflowItems.FirstOrDefault(wfi => 0 == wfi.CompareTo(itemToCheck));
     if (null != itemToFind)
     {
         FocusedWorkflowItem = itemToFind;
         return false;
     }
     else
     {
         WorkflowItems.Add(itemToCheck);
         FocusedWorkflowItem = itemToCheck;
         return true;
     }
 }
Пример #40
0
        /// <summary>
        /// Take a WorkflowItem and the computed list of ActivityAssemblyItems it depends on and translate them into DC form for an upload
        /// </summary>
        /// <param name="workflow"></param>
        /// <param name="assemblyItemsUsed">Assemblies list (computed by WorkflowUploader.ComputeDependencies())</param>
        /// <returns></returns>
        public static StoreLibraryAndActivitiesRequestDC WorkflowToStoreLibraryAndActivitiesRequestDC(WorkflowItem workflow, IEnumerable<ActivityAssemblyItem> assemblyItemsUsed, List<TaskAssignment> tasks)
        {
            string libraryName = workflow.Name;
            var library = GetActivityLibraryDC(libraryName, workflow.Category, workflow.Description, workflow.CreatedBy, workflow.Version, workflow.Status);
            var dependencyList = new List<StoreActivityLibraryDependenciesGroupsRequestDC>(
                assemblyItemsUsed.Select(asm => new StoreActivityLibraryDependenciesGroupsRequestDC
                {
                    Name = asm.Name,
                    Version = asm.Version.ToString(),
                }.SetIncaller())
            );

            return new StoreLibraryAndActivitiesRequestDC
            {
                Incaller = Utility.GetCallerName(),
                IncallerVersion = Utility.GetCallerVersion(),
                InInsertedByUserAlias = !String.IsNullOrEmpty(workflow.CreatedBy) ? workflow.CreatedBy : Utility.GetCurrentUserName(),
                InUpdatedByUserAlias = Utility.GetCurrentUserName(),
                EnforceVersionRules = true,
                ActivityLibrary = library,
                StoreActivitiesList = new List<StoreActivitiesDC> {
                    // There is only one activity in this "library", = the workflow itself
                    ActivityItemToStoreActivitiyDC(workflow)
                },
                StoreActivityLibraryDependenciesGroupsRequestDC = new StoreActivityLibraryDependenciesGroupsRequestDC()
                {
                    Name = libraryName,
                    Version = workflow.Version,
                    List = dependencyList
                }.SetIncaller(),
                TaskActivitiesList = tasks.Select(t => new StoreLibraryAndTaskActivityRequestDC()
                {
                    EnforceVersionRules = true,
                    ActivityLibrary = GetActivityLibraryDC(t.GetFriendlyName(workflow.Name), workflow.Category, workflow.Description, workflow.CreatedBy, t.Version, workflow.Status),
                    StoreActivityLibraryDependenciesGroupsRequestDC = new StoreActivityLibraryDependenciesGroupsRequestDC()
                    {
                        Name = t.GetFriendlyName(workflow.Name),
                        Version = t.Version,
                        List = dependencyList
                    },
                    TaskActivitiesList = new List<TaskActivityDC>()
                    {
                        new TaskActivityDC()
                        {
                            Guid = t.TaskId,
                            AssignedTo = t.AssignTo,
                            Activity = ActivityItemToStoreActivitiyDC(workflow, t),
                            Status = t.TaskStatus == TaskActivityStatus.Unassigned ? TaskActivityStatus.Unassigned : TaskActivityStatus.Assigned,
                        }
                    }
                }.SetIncaller()).ToList()
            };
        }
Пример #41
0
 /// <summary>
 /// Separated out for testability
 /// </summary>
 public PublishingReply PublishCommandExecute_Implementation(IWorkflowsQueryService client, WorkflowItem workflow)
 {
     // Now, start the Publish process. In general this may take arbitrarily long.
     return client.PublishWorkflow(new PublishingRequest
     {
         Incaller = Environment.UserName,
         IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(),
         WorkflowName = workflow.Name,
         WorkflowVersion = workflow.Version
     });
 }
Пример #42
0
 public InputNotFoundException(WorkflowItem from, string fromName)
 {
     this.from     = from;
     this.fromName = fromName;
 }
Пример #43
0
		/// <summary>
		/// Processes the node collection.
		/// </summary>
		/// <param name="activity">The activity.</param>
		private void ProcessNodeCollection(Activity activity, Control Parent)
		{
			if (activity == null)
				return;

			WorkflowItem item = new WorkflowItem(this);
			item.CurrentActivity = activity;
			_counter++;
			item.ID = String.Format("{1}_wi_{0}", _counter, this.ID);

			item.DataBind();
			Parent.Controls.Add(item);
			
			if (activity is CompositeActivity)
			{
				foreach (Activity innerActivity in ((CompositeActivity)activity).Activities)
				{
					ProcessNodeCollection(innerActivity, item);
				}
			}
		}
Пример #44
0
        /// <summary>
        ///     Takes action on the specified workflow item, representing a
        ///     membership request.
        /// </summary>
        /// <param name="workflowId">The id of the workflow </param>
        /// <param name="action">The moderation action to be taken</param>
        /// <param name="userId">The unique id of the user under moderation.</param>
        /// <param name="communityId">The unique id of the community to which membership has been requested.</param>
        public void Moderate(string workflowId, string action, string userId, string communityId)
        {
            var membershipRequest   = GetMembershipRequest(userId, communityId);
            var populatedWorkflowId = WorkflowId.Create(workflowId);

            var requestReference = Reference.Create(CreateUri(membershipRequest.Group, membershipRequest.User));

            try
            {
                var transitionToken = _workflowService.BeginTransitionSession(populatedWorkflowId, requestReference);
                try
                {
                    // Retrieve the moderation workflow associated with
                    // the item to be acted upon.

                    var workflow = _workflowService.Get(populatedWorkflowId);

                    // Leverage the workflow to determine what the
                    // resulting state of the item will be upon taking
                    // the specified action.

                    //retrieve the current state of the workflow item once the begintransitionsession begins.
                    var filter = new WorkflowItemFilter {
                        Target = requestReference
                    };
                    var criteria = new Criteria <WorkflowItemFilter> {
                        Filter = filter
                    };
                    var workflowItem = _workflowItemService.Get(criteria).Results.Last();

                    // Example: Current State: "Pending", Action: "Approve" => Transitioned State: "Approved"
                    var transitionedState = workflow.Transition(workflowItem.State, new WorkflowAction(action));

                    var subsequentWorkflowItem = new WorkflowItem(
                        workflow.Id,
                        transitionedState,
                        requestReference
                        );

                    _workflowItemService.Add(subsequentWorkflowItem, membershipRequest, transitionToken);

                    // Perform any application logic given the item's
                    // new state.

                    if (IsApproved(subsequentWorkflowItem.State))
                    {
                        _memberRepository.Add(_memberAdapter.Adapt(membershipRequest));
                    }
                }
                finally
                {
                    _workflowService.EndTransitionSession(transitionToken);
                }
            }
            catch (SocialAuthenticationException ex)
            {
                throw new SocialRepositoryException("The application failed to authenticate with Episerver Social.",
                                                    ex);
            }
            catch (MaximumDataSizeExceededException ex)
            {
                throw new SocialRepositoryException(
                          "The application request was deemed too large for Episerver Social.", ex);
            }
            catch (SocialCommunicationException ex)
            {
                throw new SocialRepositoryException("The application failed to communicate with Episerver Social.", ex);
            }
            catch (SocialException ex)
            {
                throw new SocialRepositoryException("Episerver Social failed to process the application request.", ex);
            }
        }
Пример #45
0
 public void RegisterPreRouterWorkflow(WorkflowItem<PreRouteWorkflowData> item)
 {
     preRouteWorkflow.AddItem(item);
 }