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;
        }
        public ActionResult _EditLoadImportedSubject(int processidNew, int subjId, int processidOld, int edit)
        {

            var _p = _db.PD_Processes.Find(processidOld);
            PD_Subject subject = _db.PD_Subjects.Find(processidNew, subjId);
            Random rand = new Random();
            PD_Subject newSubject = new PD_Subject() { Name = subject.Name, PositionTop = rand.Next(0, 800), PositionLeft = rand.Next(0, 555), ExternalSubject = false, CanvasWidth = subject.CanvasWidth, CanvasHeight = subject.CanvasHeight };
            newSubject.Id = IdHelper.getSubjectId(_db, processidOld);
            _p.Subjects.Add(newSubject);
            _db.SaveChanges();
            

            //messages
            var messages = _db.PD_Messages.Where(result => result.PD_Process_Id == processidNew && result.From == subject.Id || result.PD_Process_Id == processidNew && result.To == subject.Id).ToList();
            List<int> messageIds = new List<int>();
            foreach (var x in messages) { messageIds.Add((int)x.PD_MessageType_Id); }
            messageIds = messageIds.Distinct().ToList();
            foreach (var y in messageIds)
            {
               var newMes = new PD_MessageType() { PD_Process_Id = processidOld };
               newMes.Id = IdHelper.getMessageTypeId(_db, processidOld);
               newMes.Name = _db.PD_MessageTypes.Find(processidNew, y).Name;
               newMes.Parameters = _db.PD_MessageTypes.Find(processidNew, y).Parameters;
               var Names= _db.PD_MessageTypes.Where(result => result.PD_Process_Id == processidOld && result.Name == newMes.Name);
               if (Names.Count() == 0)
               {
                   _db.PD_MessageTypes.Add(newMes);
                   foreach (var z in _db.PD_MessageTypes.Find(processidNew, y).Parameters) //parameters
                   {
                       var param = _db.PD_Parameters.Find(processidNew, z);
                       var checkParamName = _db.PD_Parameters.Find(processidOld, param.Name);
                       //var paramNames = _db.PD_Parameters.Where(result => result.PD_Process_Id == processidNew && result.Name == param.Name);
                       if (checkParamName == null)
                       {
                           PD_Parameter paramNew = new PD_Parameter() { PD_Process_Id = processidOld };
                           paramNew.Name = param.Name;
                           paramNew.Config = param.Config;
                           _db.PD_Parameters.Add(paramNew);
                       }
                   }
               }
               _db.SaveChanges();
            }
            

            //state && transitions            
            var states = _db.PD_States.Where(result => result.PD_Process_Id == processidNew && result.PD_Subject_Id == subject.Id).ToList();
            var i = 1;
            foreach (var x in states)
            {
                PD_State newState = null;
                
                if (x.Type == PD_StateTypes.FunctionState) 
                {
                    newState = new PD_FunctionState() { Name = "Function State", EndState = false };
                }
                if (x.Type == PD_StateTypes.SendState)
                {
                    newState = new PD_SendState() { Name = "Send State", EndState = false };
                    //((PD_SendState)newState).ReadableParameters = ((PD_SendState)x).ReadableParameters;
                    //((PD_SendState)newState).EditableParameters = ((PD_SendState)x).EditableParameters;
                }
                if (x.Type == PD_StateTypes.ReceiveState)
                {
                    newState = new PD_ReceiveState() { Name = "Receive State", EndState = false };
                } 
                //newState.PD_Subject = x.PD_Subject;
                //newState.PD_Subject_Id = newSubject.Id;
                //newState.Id = IdHelper.getStateId(_db, processidOld, subjId);
                //newState.Id = IdHelper.getStateId(_db, _p.Id, newSubject.Id);
                //newState.PD_Process_Id = processidOld;
                //newState.Id = i;
                newState.Id = x.Id;
                i++;
                
                newState.Name = x.Name;
                newState.PositionLeft = x.PositionLeft;
                newState.PositionTop = x.PositionTop;
                newState.StartState = x.StartState;
                newState.EndState = x.EndState;
                newSubject.States.Add(newState);            
            }
            _db.SaveChanges();

            i = 1;
            var transitions = _db.PD_Transitions.Where(result => result.PD_Process_Id == processidNew && result.PD_Subject_Id == subject.Id).ToList();
            foreach (var x in transitions)
            {
                 PD_Transition newTransition = null;

                 var temp = new PD_TransitionDTO() { Id = x.Id, Source = x.Source, Target = x.Target, Type = x.Type, LabelPosition = x.LabelPosition };
                 
                 if (x.Type == PD_TransitionTypes.RegularTransition)
                 {
                     temp.Label = ((PD_RegularTransition)x).Name;
                     newTransition = new PD_RegularTransition() { Name = temp.Label };                     
                 }
                 if (x.Type == PD_TransitionTypes.ReceiveTransition)
                 {
                      newTransition = new PD_ReceiveTransition() { Message = -1 };
                 }
                 if (x.Type == PD_TransitionTypes.TimeoutTransition)
                 {
                     temp.Label = ((PD_TimeoutTransition)x).TimeSpan;
                     newTransition = new PD_TimeoutTransition() { TimeSpan = temp.Label };
                 }

                 //newTransition.Id = IdHelper.getTransitionId(_db, processidOld, subjId);
                 //newTransition.Id = i;
                 newTransition.Id = x.Id;
                 i++;
                 newTransition.PD_Process_Id = processidOld;
                 newTransition.Source = x.Source;
                 newTransition.Target = x.Target;
                 newTransition.LabelPosition = x.LabelPosition;
                 newSubject.Transitions.Add(newTransition);
            }
            _db.SaveChanges();
            
            string a = "location.reload();";
            string b = "imprt('" + subject.Name + "','" + newSubject.Id + "','" + newSubject.PositionLeft + "','" + newSubject.PositionTop + "','" + processidOld + "')";
            return JavaScript(b);
            //return null;
        }
        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");

        }
        public HttpResponseMessage PostState(PD_State item, int id, int sid)
        {
             var _p = _db.PD_Processes.Find(id);
             if (User.Identity.Name.Equals(_p.LockedBy))
             {
                 var subject = _db.PD_Subjects.Find(id, sid);
                 PD_State newState = null;
                 if (item.Type == PD_StateTypes.FunctionState)
                 {
                     newState = new PD_FunctionState() { Name = "Function State", EndState = false };
                 }
                 if (item.Type == PD_StateTypes.SendState)
                 {
                     newState = new PD_SendState() { Name = "Send State", EndState = false };
                 }
                 if (item.Type == PD_StateTypes.ReceiveState)
                 {
                     newState = new PD_ReceiveState() { Name = "Receive State", EndState = false };
                 }
                 if (item.Type == PD_StateTypes.RefinementState)
                 {
                     newState = new PD_RefinementState() { Name = "Refinement State", EndState = false };
                 }
                 newState.Id = IdHelper.getStateId(_db, id,sid);

                 newState.PositionLeft = item.PositionLeft;
                 newState.PositionTop = item.PositionTop;

                 newState.StartState = false;
                 if (subject.States.Count == 0)
                 {
                     newState.StartState = true;
                 }

                 subject.States.Add(newState);
                 _db.SaveChanges();
                 var response = Request.CreateResponse<PD_StateDTO>(HttpStatusCode.Created, new PD_StateDTO { Id = newState.Id, Name = newState.Name, PositionLeft = newState.PositionLeft, PositionTop = newState.PositionTop, Type = newState.Type });

                 string uri = Url.Content("Designer" + id + "/Subjects/" + sid + "/States/" + newState.Id);
                 response.Headers.Location = new Uri(uri);
                 return response;
             }
             else
             {
                 return null;
             }
        }