Ejemplo n.º 1
0
        public IEnumerable <PD_TransitionDTO> GetAllTransitions(int id, int sid)
        {
            PD_Subject i = _db.PD_Subjects.Find(id, sid);
            List <PD_TransitionDTO> t = new List <PD_TransitionDTO>();

            foreach (var tr in i.Transitions)
            {
                var temp = new PD_TransitionDTO()
                {
                    Id = tr.Id, Source = tr.Source, Target = tr.Target, Type = tr.Type, LabelPosition = tr.LabelPosition
                };

                if (tr.Type == PD_TransitionTypes.RegularTransition)
                {
                    temp.Label = ((PD_RegularTransition)tr).Name;
                }
                if (tr.Type == PD_TransitionTypes.ReceiveTransition)
                {
                    try
                    {
                        PD_Message     m  = _db.PD_Messages.Find(id, ((PD_ReceiveTransition)tr).Message);
                        PD_MessageType mt = m.PD_MessageType;
                        PD_Subject     s  = _db.PD_Subjects.Find(id, m.From);
                        temp.Label = s.Name + "|" + mt.Name;
                    }
                    catch (Exception e)
                    {
                        temp.Label = "Receive";
                    }
                }
                if (tr.Type == PD_TransitionTypes.TimeoutTransition)
                {
                    temp.Label = ((PD_TimeoutTransition)tr).TimeSpan;
                }
                if (temp.Label == null)
                {
                    temp.Label = "EMPTY";
                }
                t.Add(temp);
            }
            return(t.ToArray());
        }
Ejemplo n.º 2
0
        public ActionResult ImportBPMN(BPMNImportViewModel model)
        {
            model.description = "Imported from BPMN";
            ZipArchive         a       = new ZipArchive(model.zipfile.InputStream);
            List <definitions> imports = new List <definitions>();

            foreach (ZipArchiveEntry entry in a.Entries)
            {
                if (entry.FullName.EndsWith(".bpmn", StringComparison.OrdinalIgnoreCase))
                {
                    StreamReader reader = new StreamReader(entry.Open());


                    XmlRootAttribute xRoot = new XmlRootAttribute();
                    xRoot.ElementName = "definitions";
                    xRoot.Namespace   = "http://www.omg.org/spec/BPMN/20100524/MODEL";
                    xRoot.IsNullable  = true;
                    XmlSerializer serializer = new XmlSerializer(typeof(definitions), xRoot);
                    XmlReader     xRdr       = XmlReader.Create(reader);
                    definitions   import     = (definitions)serializer.Deserialize(xRdr);
                    //   BPMNImport import = (BPMNImport)serializer.Deserialize(new XmlTextReader(reader));


                    imports.Add(import);
                }
            }



            foreach (definitions i in imports)
            {
                WS_Project p = new WS_Project();

                p.Name        = i.BPMNDiagram.name;
                p.Description = model.description;
                p.Folder_Id   = model.folderId;

                this.CreateProject(p);

                int pd_id = p.ModelVersions.FirstOrDefault().PD_ProcessId;


                PD_Process pdp = _pDesignerDB.PD_Processes.Find(pd_id);
                int        n   = 50;
                int        c   = 0;
                int        t   = 50;
                foreach (var x in i.collaboration.participant)
                {
                    PD_Subject s = new PD_Subject();

                    s.Name = x.name;
                    if (c == 10)
                    {
                        t += 400;
                        c  = 0;
                        n  = 50;
                    }
                    s.PositionLeft = n;

                    s.PositionTop = t;
                    c++;
                    n += 200;
                    s.CanvasHeight = 1000;
                    s.CanvasWidth  = 1000;
                    s.Id           = IdHelper.getSubjectId(_pDesignerDB, pdp.Id);

                    pdp.Subjects.Add(s);
                    pdp.CanvasHeight = 200 + t;
                    if (s.PositionLeft > pdp.CanvasWidth)
                    {
                        pdp.CanvasWidth = s.PositionLeft;
                    }
                }
                if (i.collaboration.messageFlow != null)
                {
                    foreach (var x in i.collaboration.messageFlow)
                    {
                        PD_MessageType pdm = new PD_MessageType();
                        pdm.PD_Process_Id = pdp.Id;
                        pdm.Id            = IdHelper.getMessageTypeId(_pDesignerDB, pdp.Id);
                        pdm.Name          = x.name;
                        pdp.MessageTypes.Add(pdm);

                        /* try {
                         * PD_Message m = new PD_Message();
                         * m.Id = IdHelper.getMessageId(_pDesignerDB, pdp.Id);
                         *
                         *
                         * string fname = i.collaboration.participant.Where(s => s.id.Equals(x.sourceRef)).FirstOrDefault().name;
                         * m.From = pdp.Subjects.Where(y => y.Name.Equals(fname)).FirstOrDefault().Id;
                         * m.To = pdp.Subjects.Where(y => y.Name.Equals(i.collaboration.participant.Where(s => s.id.Equals(x.targetRef)).FirstOrDefault().name)).FirstOrDefault().Id;
                         * m.PD_MessageType_Id = pdm.Id;
                         * pdp.Messages.Add(m);
                         *  }
                         * catch (Exception e)
                         * {
                         *
                         * }*/
                    }
                }
                foreach (var x in i.process)
                {
                    PD_Subject pds = pdp.Subjects.Where(z => z.Name.Equals(x.name)).FirstOrDefault();
                    foreach (var y in x.Items)
                    {
                        PD_FunctionState pdf = new PD_FunctionState();
                        const string     pre = "strICT.InFlow.Web.Models.";
                        Type             w   = y.GetType();
                        switch (w.FullName)
                        {
                        case pre + "definitionsProcessAssociation":

                            definitionsProcessAssociation var1 = (definitionsProcessAssociation)y;

                            break;

                        case pre + "definitionsProcessDataStoreReference":

                            definitionsProcessDataStoreReference var2 = (definitionsProcessDataStoreReference)y;

                            break;

                        case pre + "definitionsProcessIntermediateCatchEvent":

                            definitionsProcessIntermediateCatchEvent var3 = (definitionsProcessIntermediateCatchEvent)y;
                            pdf               = new PD_FunctionState();
                            pdf.Name          = var3.name;
                            pdf.PD_Process_Id = pdp.Id;
                            pdf.PD_Subject_Id = pds.Id;
                            pdf.Type          = PD_StateTypes.FunctionState;
                            pdf.Id            = IdHelper.getStateId(_pDesignerDB, pdp.Id, pds.Id);
                            if (var3.incoming == null)
                            {
                                pdf.StartState = true;
                            }
                            if (var3.outgoing == null)
                            {
                                pdf.EndState = true;
                            }

                            pds.States.Add(pdf);


                            break;

                        case pre + "definitionsProcessIntermediateThrowEvent":

                            definitionsProcessIntermediateThrowEvent var4 = (definitionsProcessIntermediateThrowEvent)y;
                            pdf               = new PD_FunctionState();
                            pdf.Name          = var4.name;
                            pdf.PD_Process_Id = pdp.Id;
                            pdf.PD_Subject_Id = pds.Id;
                            pdf.Type          = PD_StateTypes.FunctionState;
                            pdf.Id            = IdHelper.getStateId(_pDesignerDB, pdp.Id, pds.Id);
                            if (var4.incoming == null)
                            {
                                pdf.StartState = true;
                            }
                            if (var4.outgoing == null)
                            {
                                pdf.EndState = true;
                            }

                            pds.States.Add(pdf);
                            break;

                        case pre + "definitionsProcessSequenceFlow":

                            definitionsProcessSequenceFlow var5 = (definitionsProcessSequenceFlow)y;

                            break;

                        case pre + "definitionsProcessServiceTask":

                            definitionsProcessServiceTask var6 = (definitionsProcessServiceTask)y;
                            pdf               = new PD_FunctionState();
                            pdf.Name          = var6.name;
                            pdf.PD_Process_Id = pdp.Id;
                            pdf.PD_Subject_Id = pds.Id;
                            pdf.Type          = PD_StateTypes.FunctionState;
                            pdf.Id            = IdHelper.getStateId(_pDesignerDB, pdp.Id, pds.Id);
                            if (var6.incoming == null)
                            {
                                pdf.StartState = true;
                            }
                            if (var6.outgoing == null)
                            {
                                pdf.EndState = true;
                            }
                            pds.States.Add(pdf);
                            break;

                        case pre + "definitionsProcessTextAnnotation":

                            definitionsProcessTextAnnotation var7 = (definitionsProcessTextAnnotation)y;

                            break;

                        case pre + "definitionsProcessUserTask":

                            definitionsProcessUserTask var8 = (definitionsProcessUserTask)y;
                            pdf               = new PD_FunctionState();
                            pdf.Name          = var8.name;
                            pdf.PD_Process_Id = pdp.Id;
                            pdf.PD_Subject_Id = pds.Id;
                            pdf.Type          = PD_StateTypes.FunctionState;
                            pdf.Id            = IdHelper.getStateId(_pDesignerDB, pdp.Id, pds.Id);
                            if (var8.incoming == null)
                            {
                                pdf.StartState = true;
                            }
                            if (var8.outgoing == null)
                            {
                                pdf.EndState = true;
                            }
                            pds.States.Add(pdf);
                            break;
                        }
                    }
                }

                pdp.CanvasWidth  += 100;
                pdp.CanvasHeight += 100;
            }

            _pDesignerDB.SaveChanges();
            return(View("Index"));
        }
Ejemplo n.º 3
0
        public int copyModel(int PD_ProcessId)
        {
            var process = _pdesignerDB.PD_Processes.Find(PD_ProcessId);

            PD_Process newProcess = new PD_Process()
            {
                Name = process.Name
            };

            _pdesignerDB.PD_Processes.Add(newProcess);
            _pdesignerDB.SaveChanges();

            foreach (var p in process.Parameters)
            {
                PD_Parameter par = new PD_Parameter()
                {
                    PD_Process_Id = newProcess.Id, Name = p.Name, Config = p.Config
                };
                _pdesignerDB.PD_Parameters.Add(par);
                _pdesignerDB.SaveChanges();
            }

            foreach (var mt in process.MessageTypes)
            {
                PD_MessageType newMessageType = new PD_MessageType()
                {
                    Id = mt.Id, Name = mt.Name, Parameters = mt.Parameters, PD_Process_Id = newProcess.Id
                };
                _pdesignerDB.PD_MessageTypes.Add(newMessageType);
                _pdesignerDB.SaveChanges();
            }

            foreach (var m in process.Messages)
            {
                PD_Message newMessage = new PD_Message()
                {
                    Id = m.Id, From = m.From, To = m.To, PD_MessageType_Id = m.PD_MessageType_Id, PD_MessageType_Process_Id = newProcess.Id, PD_Process_Id = newProcess.Id
                };
                _pdesignerDB.PD_Messages.Add(newMessage);
                _pdesignerDB.SaveChanges();
            }

            foreach (var s in process.Subjects)
            {
                PD_Subject newSubject = new PD_Subject()
                {
                    Id = s.Id, CanBeStarted = s.CanBeStarted, ExternalSubject = s.ExternalSubject, GlobalParameters = s.GlobalParameters, MultiSubject = s.MultiSubject, Name = s.Name, PD_Process_Id = newProcess.Id, PositionLeft = s.PositionLeft, PositionTop = s.PositionTop
                };
                _pdesignerDB.PD_Subjects.Add(newSubject);
                _pdesignerDB.SaveChanges();

                foreach (var st in s.States)
                {
                    if (st.Type == PD_StateTypes.FunctionState)
                    {
                        var oS = (PD_FunctionState)st;
                        PD_FunctionState newS = new PD_FunctionState()
                        {
                            EditableParameters = oS.EditableParameters, EndState = oS.EndState, Id = oS.Id, Name = oS.Name, PD_Process_Id = newProcess.Id, PD_Subject_Id = newSubject.Id, PositionLeft = oS.PositionLeft, PositionTop = oS.PositionTop, ReadableParameters = oS.ReadableParameters, StartState = oS.StartState, Type = oS.Type
                        };
                        _pdesignerDB.PD_FunctionStates.Add(newS);
                        _pdesignerDB.SaveChanges();
                    }
                    if (st.Type == PD_StateTypes.SendState)
                    {
                        var          oS   = (PD_SendState)st;
                        PD_SendState newS = new PD_SendState()
                        {
                            EditableParameters = oS.EditableParameters, EndState = oS.EndState, Id = oS.Id, Name = oS.Name, PD_Process_Id = newProcess.Id, PD_Subject_Id = newSubject.Id, PositionLeft = oS.PositionLeft, PositionTop = oS.PositionTop, ReadableParameters = oS.ReadableParameters, StartState = oS.StartState, Type = oS.Type, Message = oS.Message
                        };
                        _pdesignerDB.PD_SendStates.Add(newS);
                        _pdesignerDB.SaveChanges();
                    }
                    if (st.Type == PD_StateTypes.ReceiveState)
                    {
                        var             oS   = (PD_ReceiveState)st;
                        PD_ReceiveState newS = new PD_ReceiveState()
                        {
                            EndState = oS.EndState, Id = oS.Id, Name = oS.Name, PD_Process_Id = newProcess.Id, PD_Subject_Id = newSubject.Id, PositionLeft = oS.PositionLeft, PositionTop = oS.PositionTop, StartState = oS.StartState, Type = oS.Type
                        };
                        _pdesignerDB.PD_ReceiveStates.Add(newS);
                        _pdesignerDB.SaveChanges();
                    }
                }

                foreach (var t in s.Transitions)
                {
                    if (t.Type == PD_TransitionTypes.RegularTransition)
                    {
                        var oT = (PD_RegularTransition)t;
                        PD_RegularTransition newT = new PD_RegularTransition()
                        {
                            Id = oT.Id, Name = oT.Name, PD_Process_Id = newProcess.Id, PD_Subject_Id = newSubject.Id, Source = oT.Source, Target = oT.Target, Type = oT.Type
                        };
                        _pdesignerDB.PD_RegularTransitions.Add(newT);
                        _pdesignerDB.SaveChanges();
                    }
                    if (t.Type == PD_TransitionTypes.ReceiveTransition)
                    {
                        var oT = (PD_ReceiveTransition)t;
                        PD_ReceiveTransition newT = new PD_ReceiveTransition()
                        {
                            Id = oT.Id, PD_Process_Id = newProcess.Id, PD_Subject_Id = newSubject.Id, Source = oT.Source, Target = oT.Target, Type = oT.Type, Message = oT.Message
                        };
                        _pdesignerDB.PD_ReceiveTransitions.Add(newT);
                        _pdesignerDB.SaveChanges();
                    }
                    if (t.Type == PD_TransitionTypes.TimeoutTransition)
                    {
                        var oT = (PD_TimeoutTransition)t;
                        PD_TimeoutTransition newT = new PD_TimeoutTransition()
                        {
                            Id = oT.Id, PD_Process_Id = newProcess.Id, PD_Subject_Id = newSubject.Id, Source = oT.Source, Target = oT.Target, Type = oT.Type, TimeSpan = oT.TimeSpan
                        };
                        _pdesignerDB.PD_TimeoutTransitions.Add(newT);
                    }
                }
            }

            _pdesignerDB.SaveChanges();

            return(newProcess.Id);
        }