public ResultOperation Active(sysBpmsProcess process)
        {
            ResultOperation resultOperation = null;

            try
            {
                resultOperation = new ResultOperation();
                if (resultOperation.IsSuccess)
                {
                    if (process.StatusLU != (int)sysBpmsProcess.Enum_StatusLU.Inactive)
                    {
                        resultOperation.AddError(LangUtility.Get("ActiveError.Text", nameof(sysBpmsProcess)));
                    }
                    if (resultOperation.IsSuccess)
                    {
                        process.StatusLU = (int)sysBpmsProcess.Enum_StatusLU.Published;
                        this.UnitOfWork.Repository <IProcessRepository>().Update(process);
                        this.UnitOfWork.Save();
                    }
                }
            }
            catch (Exception ex)
            {
                return(base.ExceptionHandler(ex));
            }
            base.FinalizeService(resultOperation);

            return(resultOperation);
        }
Example #2
0
        public ResultOperation UpdateTraceToStart(sysBpmsProcess process)
        {
            ResultOperation resultOperation = new ResultOperation();

            try
            {
                List <sysBpmsGateway> listGateways = new GatewayService(base.UnitOfWork).GetList(process.ID).ToList();
                if (listGateways.Any())
                {
                    List <sysBpmsElement>      listElements     = new ElementService(base.UnitOfWork).GetList(process.ID, null, "");
                    List <sysBpmsSequenceFlow> listSequenceFlow = new SequenceFlowService(base.UnitOfWork).GetList(process.ID, "", "", "");
                    this.BeginTransaction();
                    foreach (sysBpmsGateway item in listGateways)
                    {
                        if (resultOperation.IsSuccess)
                        {
                            List <string> listEvaluatedID = new List <string>();
                            List <string> listTaskID      = new List <string>();
                            List <string> listTracedItems = new List <string>();
                            this.GetRecursiveTraceToStart(listElements.FirstOrDefault(c => c.ID == item.ElementID), listTaskID, listEvaluatedID, listElements, listSequenceFlow, listTracedItems);

                            item.TraceToStart = string.Join(",", listTaskID);
                            resultOperation   = new GatewayService(base.UnitOfWork).Update(item);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                return(base.ExceptionHandler(ex));
            }
            base.FinalizeService(resultOperation);
            return(resultOperation);
        }
        private ResultOperation UpdateProcessDataBase(sysBpmsProcess Process)
        {
            ResultOperation resultOperation  = new ResultOperation();
            WorkflowProcess _WorkflowProcess = new XmlWorkflowProcessConvertor().ConvertFromString(Process.WorkflowXML);

            //Lane
            new LaneService(this.UnitOfWork).Update(Process.ID, _WorkflowProcess);
            //Task
            resultOperation = new TaskService(this.UnitOfWork).Update(Process.ID, _WorkflowProcess);
            if (!resultOperation.IsSuccess)
            {
                return(resultOperation);
            }
            //Event
            resultOperation = new EventService(this.UnitOfWork).Update(Process.ID, _WorkflowProcess);
            if (!resultOperation.IsSuccess)
            {
                return(resultOperation);
            }
            //GateWay
            resultOperation = new GatewayService(this.UnitOfWork).Update(Process.ID, _WorkflowProcess);
            if (!resultOperation.IsSuccess)
            {
                return(resultOperation);
            }
            //SequenceFlow : this must be at the end of the others
            resultOperation = new SequenceFlowService(this.UnitOfWork).Update(Process.ID, _WorkflowProcess);
            if (!resultOperation.IsSuccess)
            {
                return(resultOperation);
            }

            return(resultOperation);
        }
Example #4
0
        private void UpdateWorkflowXML(sysBpmsProcess _Process)
        {
            this.RemoveNameSpaces(_Process);
            XmlDocument xDocDiagram = this.StringToXml(_Process.WorkflowXML);

            _Process.WorkflowXML = this.GetXMLAsString(xDocDiagram.SelectSingleNode("//process"));
            this.ConvertWorkflowXMLwithXSL(_Process);
        }
Example #5
0
        public void Delete(Guid ID)
        {
            sysBpmsProcess process = this.Context.sysBpmsProcesses.FirstOrDefault(d => d.ID == ID);

            if (process != null)
            {
                this.Context.sysBpmsProcesses.Remove(process);
            }
        }
        //It will GetSourceCode and generate assemblies
        public void GetSourceCode(sysBpmsProcess sysBpmsProcess)
        {
            string makeClass(DesignCodeModel designCode)
            {
                string code = string.Empty;

                if (designCode != null && !string.IsNullOrWhiteSpace(designCode.Code))
                {
                    code = DynamicCodeEngine.MakeClass(designCode.Code, designCode.ID);
                }
                return(code);
            }

            string                  sourceCode           = string.Empty;
            DynamicFormService      dynamicFormService   = new DynamicFormService(base.UnitOfWork);
            List <sysBpmsTask>      sysBpmsTaskList      = new TaskService(base.UnitOfWork).GetList(null, sysBpmsProcess.ID);
            List <sysBpmsCondition> sysBpmsConditionList = new ConditionService(base.UnitOfWork).GetList(null, null, sysBpmsProcess.ID);

            List <sysBpmsDynamicForm> sysBpmsDynamicFormList = dynamicFormService.GetList(sysBpmsProcess.ID, null, null, "", null, null);

            foreach (var item in sysBpmsDynamicFormList)
            {
                if (!string.IsNullOrWhiteSpace(item.SourceCode))
                {
                    sourceCode += item.SourceCode + Environment.NewLine;
                }
            }

            foreach (var item in sysBpmsTaskList)
            {
                //Service and script task
                if (!string.IsNullOrWhiteSpace(item.Code))
                {
                    sourceCode += makeClass(DesignCodeUtility.GetDesignCodeFromXml(item.Code));
                }
                //Rule
                if (!string.IsNullOrWhiteSpace(item.Rule))
                {
                    sourceCode += makeClass(DesignCodeUtility.GetDesignCodeFromXml(item.Rule));
                }
            }

            foreach (var item in sysBpmsConditionList)
            {
                if (!string.IsNullOrWhiteSpace(item.Code))
                {
                    sourceCode += makeClass(DesignCodeUtility.GetDesignCodeFromXml(item.Code));
                }
            }

            sysBpmsProcess.SourceCode = sourceCode;
            DynamicCodeEngine.GenerateProcessAssembly(sysBpmsProcess);
        }
Example #7
0
        public void Update(sysBpmsProcess process)
        {
            //To fix 'Attaching an entity failed' error.
            var local = this.Context.Set <sysBpmsProcess>().Local.FirstOrDefault(f => f.ID == process.ID);

            if (local != null)
            {
                this.Context.Entry(local).State = EntityState.Detached;
                local = null;
            }
            this.Context.Entry(process.Clone()).State = EntityState.Modified;
        }
 public KartableProcessDTO(sysBpmsProcess process)
 {
     this.ID = process.ID;
     this.FormattedNumber = process.FormattedNumber;
     this.Name            = process.Name;
     this.Description     = process.Description;
     this.ProcessVersion  = process.ProcessVersion;
     this.StatusLUName    = ((sysBpmsProcess.Enum_StatusLU)process.StatusLU).GetDescription();
     this.CreatorUsername = process.CreatorUsername;
     this.ParentProcessID = process.ParentProcessID;
     this.CreateDate      = process.CreateDate;
     this.UpdateDate      = process.UpdateDate;
 }
        public ResultOperation Add(string Name, string Description, string userName, int?parallelCountPerUser, Guid processGroupId, int typeLU)
        {
            ResultOperation resultOperation = new ResultOperation();

            try
            {
                sysBpmsProcess process = new sysBpmsProcess()
                {
                    CreateDate           = DateTime.Now,
                    Name                 = Name,
                    Description          = Description,
                    UpdateDate           = DateTime.Now,
                    FormattedNumber      = string.Empty,
                    Number               = null,
                    StatusLU             = (int)sysBpmsProcess.Enum_StatusLU.Draft,
                    ProcessVersion       = (int)sysBpmsProcess.Enum_Version.startVersion,
                    WorkflowXML          = string.Empty,
                    DiagramXML           = this.GetDefaultXML(),
                    SourceCode           = string.Empty,
                    CreatorUsername      = userName,
                    BeginTasks           = string.Empty,
                    ParallelCountPerUser = parallelCountPerUser,
                    ProcessGroupID       = processGroupId,
                    TypeLU               = typeLU,
                };
                process.Number          = this.CalculateSerlialNumber(this.UnitOfWork.Repository <IProcessRepository>().MaxNumber() + 1);
                process.FormattedNumber = this.CalculateFormatNumber(process.Number.Value, DateTime.Now.Date);
                if (resultOperation.IsSuccess)
                {
                    this.BeginTransaction();

                    this.UnitOfWork.Repository <IProcessRepository>().Add(process);
                    this.UnitOfWork.Save();

                    //process.Code = process.ID.ToString();
                    this.UnitOfWork.Repository <IProcessRepository>().Update(process);
                    this.UnitOfWork.Save();

                    resultOperation.CurrentObject = process;
                }
            }
            catch (Exception ex)
            {
                return(base.ExceptionHandler(ex));
            }
            base.FinalizeService(resultOperation);

            return(resultOperation);
        }
Example #10
0
 public object GetIndex(Guid ID)
 {
     using (ProcessService processService = new ProcessService())
     {
         sysBpmsProcess process = processService.GetInfo(ID);
         if (process != null)
         {
             if (string.IsNullOrWhiteSpace(process.DiagramXML))
             {
                 process.DiagramXML = "<definitions xmlns=\"http://www.omg.org/spec/BPMN/20100524/MODEL\" xmlns:bpmndi=\"http://www.omg.org/spec/BPMN/20100524/DI\" xmlns:omgdc=\"http://www.omg.org/spec/DD/20100524/DC\" xmlns:omgdi=\"http://www.omg.org/spec/DD/20100524/DI\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" targetNamespace=\"\" xsi:schemaLocation=\"http://www.omg.org/spec/BPMN/20100524/MODEL http://www.omg.org/spec/BPMN/2.0/20100501/BPMN20.xsd\"><collaboration id=\"sid-c0e745ff-361e-4afb-8c8d-2a1fc32b1424\"><participant id=\"sid-87F4C1D6-25E1-4A45-9DA7-AD945993D06F\" name=\"مشتری\" processRef=\"sid-C3803939-0872-457F-8336-EAE484DC4A04\" /></collaboration><process id=\"sid-C3803939-0872-457F-8336-EAE484DC4A04\" name=\"مشتری\" processType=\"None\" isClosed=\"false\" isExecutable=\"false\"></process><bpmndi:BPMNDiagram id=\"sid-74620812-92c4-44e5-949c-aa47393d3830\"></bpmndi:BPMNDiagram></definitions>";
             }
         }
         return(new ProcessDTO(process));
     }
 }
Example #11
0
 public object GetActive(Guid ID)
 {
     using (ProcessService processService = new ProcessService())
     {
         sysBpmsProcess  process         = processService.GetInfo(ID);
         ResultOperation resultOperation = processService.Publish(ID);
         if (resultOperation.IsSuccess)
         {
             return(new PostMethodMessage(SharedLang.Get("Success.Text"), DisplayMessageType.success));
         }
         else
         {
             return(new PostMethodMessage(resultOperation.GetErrors(), DisplayMessageType.error));
         }
     }
 }
Example #12
0
        public object PostEditInfo(ProcessDTO processDTO)
        {
            using (ProcessService processService = new ProcessService())
            {
                sysBpmsProcess process = processService.GetInfo(processDTO.ID);
                process.Update(processDTO.Name, processDTO.Description, processDTO.ParallelCountPerUser, processDTO.TypeLU);

                ResultOperation resultOperation = processService.UpdateInfo(process);
                if (resultOperation.IsSuccess)
                {
                    return(new PostMethodMessage(SharedLang.Get("Success.Text"), DisplayMessageType.success));
                }
                else
                {
                    return(new PostMethodMessage(resultOperation.GetErrors(), DisplayMessageType.error));
                }
            }
        }
Example #13
0
        private void RemoveNameSpaces(sysBpmsProcess _Process)
        {
            XmlDocument xdoc = this.StringToXml(_Process.DiagramXML);

            //Load class pattern
            string XslFile = System.Web.Hosting.HostingEnvironment.MapPath(BPMSResources.Repository + "RemoveNameSpaces.xslt");

            XslCompiledTransform xsl = new XslCompiledTransform();

            xsl.Load(XslFile);

            // get transformed results
            StringWriter sw = new StringWriter();

            xsl.Transform(xdoc, null, sw);

            _Process.WorkflowXML = sw.ToString();
            sw.Close();
        }
 public ProcessDTO(sysBpmsProcess process)
 {
     if (process != null)
     {
         this.ID                   = process.ID;
         this.Name                 = process.Name;
         this.Number               = process.Number;
         this.FormattedNumber      = process.FormattedNumber;
         this.Description          = process.Description;
         this.StatusLU             = process.StatusLU;
         this.CreatorUsername      = process.CreatorUsername;
         this.CreateDate           = process.CreateDate;
         this.UpdateDate           = process.UpdateDate;
         this.ParallelCountPerUser = process.ParallelCountPerUser;
         this.ProcessGroupID       = process.ProcessGroupID;
         this.TypeLU               = process.TypeLU;
         this.ProcessVersion       = process.ProcessVersion;
         this.DiagramXML           = process.DiagramXML;
     }
 }
Example #15
0
        public object PostEdit(ProcessDTO processDTO)
        {
            if (processDTO.DiagramXML != string.Empty)
            {
                using (ProcessService processService = new ProcessService())
                {
                    sysBpmsProcess currentProcess = processService.GetInfo(processDTO.ID);
                    if (currentProcess != null)
                    {
                        currentProcess.DiagramXML = processDTO.DiagramXML.Replace("\r\n", "").Replace("<?xml version=\"1.0\" encoding=\"UTF-8\"?>", "");
                        this.UpdateWorkflowXML(currentProcess);

                        ResultOperation resultOperation = processService.Update(currentProcess);
                        if (!resultOperation.IsSuccess)
                        {
                            return(new PostMethodMessage(resultOperation.GetErrors(), DisplayMessageType.error));
                        }
                    }
                }
            }
            return(new PostMethodMessage(SharedLang.Get("Success.Text"), DisplayMessageType.success));
        }
        public ResultOperation UpdateInfo(sysBpmsProcess process)
        {
            ResultOperation resultOperation;

            try
            {
                resultOperation = new ResultOperation();
                if (resultOperation.IsSuccess)
                {
                    this.BeginTransaction();
                    this.UnitOfWork.Repository <IProcessRepository>().Update(process);
                    this.UnitOfWork.Save();
                }
            }
            catch (Exception ex)
            {
                return(base.ExceptionHandler(ex));
            }
            base.FinalizeService(resultOperation);

            return(resultOperation);
        }
        public ResultOperation Update(sysBpmsProcess process)
        {
            ResultOperation resultOperation;

            try
            {
                resultOperation = new ResultOperation();
                if (!process.AllowEdit() &&
                    process.WorkflowXML.Replace("<?xml version=\"1.0\" encoding=\"utf-16\"?>\r\n", "").Replace("\r\n", "").Replace(" ", "") != this.GetInfo(process.ID).WorkflowXML.Replace("<?xml version=\"1.0\" encoding=\"utf-16\"?>\r\n", "").Replace("\r\n", "").Replace(" ", ""))
                {
                    resultOperation.AddError(LangUtility.Get("NotAllowEdit.Text", nameof(sysBpmsProcess)));
                }
                if (resultOperation.IsSuccess)
                {
                    this.BeginTransaction();
                    if (process.StatusLU == (int)sysBpmsProcess.Enum_StatusLU.Published)
                    {
                        process.BeginTasks = string.Join(",", this.GetListBeginTaskElementID(process.ID));
                    }
                    process.UpdateDate = DateTime.Now;
                    this.UnitOfWork.Repository <IProcessRepository>().Update(process);
                    resultOperation = this.UpdateProcessDataBase(process);
                    if (resultOperation.IsSuccess)
                    {
                        this.UnitOfWork.Save();
                    }
                }
            }
            catch (Exception ex)
            {
                return(base.ExceptionHandler(ex));
            }
            base.FinalizeService(resultOperation);

            return(resultOperation);
        }
        public ResultOperation NewVersion(sysBpmsProcess current, string userName)
        {
            ResultOperation resultOperation;

            try
            {
                resultOperation = new ResultOperation();
                if (resultOperation.IsSuccess)
                {
                    if (this.GetList((int)sysBpmsProcess.Enum_StatusLU.Draft, current.ParentProcessID ?? current.ID).Any())
                    {
                        resultOperation.AddError(LangUtility.Get("NewVersionError.Text", nameof(sysBpmsProcess)));
                        return(resultOperation);
                    }
                    this.BeginTransaction();

                    //Create new process
                    sysBpmsProcess newProcess = this.GetInfo(current.ID);
                    newProcess.CreateDate      = DateTime.Now;
                    newProcess.UpdateDate      = DateTime.Now;
                    newProcess.StatusLU        = (int)sysBpmsProcess.Enum_StatusLU.Draft;
                    newProcess.ProcessVersion  = newProcess.ProcessVersion + 1;
                    newProcess.ParentProcessID = current.ParentProcessID.HasValue ? current.ParentProcessID.Value : current.ID;
                    newProcess.Number          = this.CalculateSerlialNumber(this.UnitOfWork.Repository <IProcessRepository>().MaxNumber() + 1);
                    newProcess.FormattedNumber = this.CalculateFormatNumber(newProcess.Number.Value, DateTime.Now.Date);

                    this.UnitOfWork.Repository <IProcessRepository>().Add(newProcess);
                    this.UnitOfWork.Save();
                    //Copy Variable
                    Dictionary <Guid, Guid> variableConvertID   = new Dictionary <Guid, Guid>();
                    VariableService         variableService     = new VariableService(base.UnitOfWork);
                    List <sysBpmsVariable>  sysBpmsVariableList = variableService.GetList(current.ID, null, null, "", null, null);
                    if (resultOperation.IsSuccess)
                    {
                        foreach (sysBpmsVariable item in sysBpmsVariableList)
                        {
                            Guid oldGuidID = item.ID;
                            item.ProcessID  = newProcess.ID;
                            resultOperation = variableService.Add(item, null);
                            variableConvertID.Add(oldGuidID, item.ID);
                            if (!resultOperation.IsSuccess)
                            {
                                break;
                            }
                        }
                    }
                    //Copy VariableDependency
                    VariableDependencyService        variableDependencyService     = new VariableDependencyService(base.UnitOfWork);
                    List <sysBpmsVariableDependency> sysBpmsVariableDependencyList = variableDependencyService.GetList(current.ID);
                    if (resultOperation.IsSuccess)
                    {
                        foreach (sysBpmsVariableDependency item in sysBpmsVariableDependencyList)
                        {
                            if (item.ToVariableID.HasValue)
                            {
                                item.ToVariableID = variableConvertID[item.ToVariableID.Value];
                            }
                            item.DependentVariableID = variableConvertID[item.DependentVariableID];
                            resultOperation          = variableDependencyService.Add(item);
                            if (!resultOperation.IsSuccess)
                            {
                                break;
                            }
                        }
                    }
                    //Copy Element
                    ElementService        elementService     = new ElementService(base.UnitOfWork);
                    List <sysBpmsElement> sysBpmsElementList = elementService.GetList(current.ID, null, "");
                    if (resultOperation.IsSuccess)
                    {
                        foreach (sysBpmsElement item in sysBpmsElementList)
                        {
                            item.ProcessID  = newProcess.ID;
                            item.Process    = null;
                            resultOperation = elementService.Add(item);
                            if (!resultOperation.IsSuccess)
                            {
                                break;
                            }
                        }
                    }
                    //Copy Lane
                    LaneService        laneService     = new LaneService(base.UnitOfWork);
                    List <sysBpmsLane> sysBpmsLaneList = laneService.GetList(current.ID);
                    if (resultOperation.IsSuccess)
                    {
                        foreach (sysBpmsLane item in sysBpmsLaneList)
                        {
                            item.ID        = Guid.NewGuid();
                            item.ProcessID = newProcess.ID;
                            item.Element   = null;
                            laneService.Add(item);
                        }
                    }
                    //Copy event
                    EventService        eventService     = new EventService(base.UnitOfWork);
                    List <sysBpmsEvent> sysBpmsEventList = eventService.GetList(null, current.ID, "", null, null);
                    if (resultOperation.IsSuccess)
                    {
                        foreach (sysBpmsEvent item in sysBpmsEventList)
                        {
                            item.ID         = Guid.NewGuid();
                            item.ProcessID  = newProcess.ID;
                            item.Element    = null;
                            resultOperation = eventService.Add(item);
                            if (!resultOperation.IsSuccess)
                            {
                                break;
                            }
                        }
                    }
                    //Copy SequenceFlow
                    Dictionary <Guid, Guid>    flowConvertID           = new Dictionary <Guid, Guid>();
                    SequenceFlowService        sequenceFlowService     = new SequenceFlowService(base.UnitOfWork);
                    List <sysBpmsSequenceFlow> sysBpmsSequenceFlowList = sequenceFlowService.GetList(current.ID);
                    if (resultOperation.IsSuccess)
                    {
                        foreach (sysBpmsSequenceFlow item in sysBpmsSequenceFlowList)
                        {
                            Guid flowNewId = Guid.NewGuid();
                            flowConvertID.Add(item.ID, flowNewId);
                            item.ID         = flowNewId;
                            item.ProcessID  = newProcess.ID;
                            item.Process    = null;
                            item.Element    = null;
                            resultOperation = sequenceFlowService.Add(item);
                            if (!resultOperation.IsSuccess)
                            {
                                break;
                            }
                        }
                    }
                    //Copy gateway
                    GatewayService        gatewayService     = new GatewayService(base.UnitOfWork);
                    ConditionService      conditionService   = new ConditionService(base.UnitOfWork);
                    List <sysBpmsGateway> sysBpmsGatewayList = gatewayService.GetList(current.ID);
                    if (resultOperation.IsSuccess)
                    {
                        foreach (sysBpmsGateway item in sysBpmsGatewayList)
                        {
                            List <sysBpmsCondition> sysBpmsConditionList = conditionService.GetList(item.ID, null, null);
                            item.ID        = Guid.NewGuid();
                            item.ProcessID = newProcess.ID;
                            item.Element   = null;
                            if (item.DefaultSequenceFlowID.HasValue)
                            {
                                item.DefaultSequenceFlowID = flowConvertID[item.DefaultSequenceFlowID.Value];
                            }
                            resultOperation = gatewayService.Add(item);
                            if (!resultOperation.IsSuccess)
                            {
                                break;
                            }
                            foreach (sysBpmsCondition condition in sysBpmsConditionList)
                            {
                                condition.GatewayID = item.ID;
                                if (condition.SequenceFlowID.HasValue)
                                {
                                    condition.SequenceFlowID = flowConvertID[condition.SequenceFlowID.Value];
                                }
                                condition.Gateway      = null;
                                condition.SequenceFlow = null;
                                resultOperation        = conditionService.Add(condition);
                                if (!resultOperation.IsSuccess)
                                {
                                    break;
                                }
                            }
                        }
                    }
                    //Copy dynamicForm
                    Dictionary <Guid, Guid>   formConvertID          = new Dictionary <Guid, Guid>();
                    DynamicFormService        dynamicFormService     = new DynamicFormService(base.UnitOfWork);
                    ApplicationPageService    applicationPageService = new ApplicationPageService(base.UnitOfWork);
                    List <sysBpmsDynamicForm> sysBpmsDynamicFormList = dynamicFormService.GetList(current.ID, null, null, "", null, null);
                    if (resultOperation.IsSuccess)
                    {
                        foreach (sysBpmsDynamicForm item in sysBpmsDynamicFormList)
                        {
                            Guid oldID = item.ID;
                            item.ProcessId = newProcess.ID;
                            //First change code id.
                            dynamicFormService.UpdateBackendCodeID(item);
                            //Then update sourceCode value.
                            dynamicFormService.GetSourceCode(item);
                            item.Process    = null;
                            resultOperation = dynamicFormService.Add(item,
                                                                     item.ApplicationPageID.HasValue ? applicationPageService.GetInfo(item.ApplicationPageID.Value) : null, userName);
                            formConvertID.Add(oldID, item.ID);
                            if (!resultOperation.IsSuccess)
                            {
                                break;
                            }
                        }
                    }
                    //Update formHtml control formid property
                    if (resultOperation.IsSuccess)
                    {
                        foreach (sysBpmsDynamicForm item in sysBpmsDynamicFormList)
                        {
                            if (item.DesignJson.Contains("formId"))
                            {
                                formConvertID.ToList().ForEach(c =>
                                {
                                    item.DesignJson = item.DesignJson.Replace(c.Key.ToString(), c.Value.ToString());
                                });
                                resultOperation = dynamicFormService.Update(item, userName);
                                if (!resultOperation.IsSuccess)
                                {
                                    break;
                                }
                            }
                        }
                    }
                    //Copy task
                    TaskService        taskService     = new TaskService(base.UnitOfWork);
                    StepService        stepService     = new StepService(base.UnitOfWork);
                    List <sysBpmsTask> sysBpmsTaskList = taskService.GetList(null, current.ID);
                    if (resultOperation.IsSuccess)
                    {
                        foreach (sysBpmsTask item in sysBpmsTaskList)
                        {
                            List <sysBpmsStep> sysBpmsStepList = stepService.GetList(item.ID, null);
                            item.ID         = Guid.NewGuid();
                            item.ProcessID  = newProcess.ID;
                            item.Process    = null;
                            item.Element    = null;
                            resultOperation = taskService.Add(item);
                            if (!resultOperation.IsSuccess)
                            {
                                break;
                            }
                            foreach (sysBpmsStep step in sysBpmsStepList)
                            {
                                step.TaskID = item.ID;
                                if (step.DynamicFormID.HasValue)
                                {
                                    step.DynamicFormID = formConvertID[step.DynamicFormID.Value];
                                }
                                step.DynamicForm = null;
                                step.Task        = null;
                                resultOperation  = stepService.Add(step);
                                if (!resultOperation.IsSuccess)
                                {
                                    break;
                                }
                            }
                        }
                    }

                    this.UnitOfWork.Save();
                }
            }
            catch (Exception ex)
            {
                return(base.ExceptionHandler(ex));
            }
            base.FinalizeService(resultOperation);

            return(resultOperation);
        }
        public ResultOperation Delete(Guid processId)
        {
            ResultOperation resultOperation = new ResultOperation();

            try
            {
                this.BeginTransaction();
                sysBpmsProcess process = this.GetInfo(processId);
                if (this.GetList(null, process.ID).Any())
                {
                    resultOperation.AddError(LangUtility.Get("OldVersionDeleteError.Text", nameof(sysBpmsProcess)));
                }
                int countThread = new ThreadService().GetCount(process.ID);
                if (countThread > 0)
                {
                    resultOperation.AddError(string.Format(LangUtility.Get("DeleteProcessThreadError.Text", nameof(sysBpmsProcess)), countThread));
                }
                if (resultOperation.IsSuccess)
                {
                    //Delete Gateway
                    foreach (sysBpmsGateway gateway in new GatewayService(base.UnitOfWork).GetList(processId))
                    {
                        if (resultOperation.IsSuccess)
                        {
                            resultOperation = new GatewayService(base.UnitOfWork).Delete(gateway.ID);
                        }
                    }

                    //Delete Task
                    foreach (sysBpmsTask task in new TaskService(base.UnitOfWork).GetList(null, processId))
                    {
                        if (resultOperation.IsSuccess)
                        {
                            resultOperation = new TaskService(base.UnitOfWork).Delete(task.ID);
                        }
                    }

                    //Delete Event
                    foreach (sysBpmsEvent @event in new EventService(base.UnitOfWork).GetList(null, processId, "", null))
                    {
                        if (resultOperation.IsSuccess)
                        {
                            resultOperation = new EventService(base.UnitOfWork).Delete(@event.ID);
                        }
                    }

                    //Delete DynamicForm
                    foreach (sysBpmsDynamicForm dynamicForm in new DynamicFormService(base.UnitOfWork).GetList(processId, null, null, "", null, null))
                    {
                        if (resultOperation.IsSuccess)
                        {
                            resultOperation = new DynamicFormService(base.UnitOfWork).Delete(dynamicForm.ID);
                        }
                    }

                    //Delete Variable
                    foreach (sysBpmsVariable variable in new VariableService(base.UnitOfWork).GetList(processId, null, null, "", null, null))
                    {
                        if (resultOperation.IsSuccess)
                        {
                            resultOperation = new VariableService(base.UnitOfWork).Delete(variable.ID);
                        }
                    }

                    //Delete Process
                    if (resultOperation.IsSuccess)
                    {
                        this.UnitOfWork.Repository <IProcessRepository>().Delete(processId);
                        this.UnitOfWork.Save();
                    }
                }
            }
            catch (Exception ex)
            {
                return(base.ExceptionHandler(ex));
            }
            base.FinalizeService(resultOperation);
            return(resultOperation);
        }
        public ResultOperation Publish(Guid processID)
        {
            ResultOperation resultOperation = new ResultOperation();

            try
            {
                sysBpmsProcess process = this.GetInfo(processID);
                if (process.StatusLU != (int)sysBpmsProcess.Enum_StatusLU.Draft &&
                    process.StatusLU != (int)sysBpmsProcess.Enum_StatusLU.Inactive)
                {
                    resultOperation.AddError(LangUtility.Get("WorkflowPublishError.Text", nameof(sysBpmsProcess)));
                }

                if (new EventService(base.UnitOfWork).GetList((int)sysBpmsEvent.e_TypeLU.StartEvent, processID, "", null).Count == 0)
                {
                    resultOperation.AddError(LangUtility.Get("WorkflowPublishNoStartError.Text", nameof(sysBpmsProcess)));
                }

                if (new EventService(base.UnitOfWork).GetList((int)sysBpmsEvent.e_TypeLU.EndEvent, processID, "", null).Count == 0)
                {
                    resultOperation.AddError(LangUtility.Get("WorkflowPublishNoEndError.Text", nameof(sysBpmsProcess)));
                }

                foreach (var item in new TaskService(base.UnitOfWork).GetList((int)sysBpmsTask.e_TypeLU.UserTask, processID))
                {
                    if (item.Steps.Count == 0)
                    {
                        resultOperation.AddError(LangUtility.Get("WorkflowPublishNoStepError.Text", nameof(sysBpmsProcess)));
                    }
                }
                if (resultOperation.IsSuccess)
                {
                    process.BeginTasks = string.Join(",", this.GetListBeginTaskElementID(process.ID));

                    this.BeginTransaction();
                    if (process.ParentProcessID.HasValue)
                    {
                        sysBpmsProcess parent = this.GetLastActive(process.ParentProcessID.Value);
                        //Make parent process as old version.
                        if (parent.StatusLU != (int)sysBpmsProcess.Enum_StatusLU.OldVersion)
                        {
                            parent.StatusLU = (int)sysBpmsProcess.Enum_StatusLU.OldVersion;
                            this.UnitOfWork.Repository <IProcessRepository>().Update(parent);
                        }
                    }
                    process.StatusLU    = (int)sysBpmsProcess.Enum_StatusLU.Published;
                    process.PublishDate = DateTime.Now;
                    //Update sourceCode fired and Generate assembly
                    GetSourceCode(process);
                    //Update TraceToStartField of Gateway element.
                    resultOperation = new GatewayEngine(null, base.UnitOfWork).UpdateTraceToStart(process);

                    if (resultOperation.IsSuccess)
                    {
                        this.UnitOfWork.Repository <IProcessRepository>().Update(process);
                        this.UnitOfWork.Save();
                    }
                }
            }
            catch (Exception ex)
            {
                return(base.ExceptionHandler(ex));
            }
            base.FinalizeService(resultOperation);

            return(resultOperation);
        }
Example #21
0
 public void Add(sysBpmsProcess Process)
 {
     Process.ID = Guid.NewGuid();
     this.Context.sysBpmsProcesses.Add(Process);
 }
Example #22
0
 public static void GenerateProcessAssembly(sysBpmsProcess process)
 {
     CompileAssemblies(process.SourceCode, process.ID.ToString());
 }