Example #1
0
        public AD.Program RequestPatientProgramDetail(IProcessActionRequest request)
        {
            try
            {
                AD.Program  pd     = null;
                IRestClient client = new JsonServiceClient();

                var url = Common.Helper.BuildURL(string.Format("{0}/{1}/{2}/{3}/Patient/{4}/Program/{5}/Details/?Token={6}",
                                                               DDProgramServiceUrl,
                                                               "NG",
                                                               request.Version,
                                                               request.ContractNumber,
                                                               request.PatientId,
                                                               request.ProgramId,
                                                               request.Token), request.UserId);

                GetProgramDetailsSummaryResponse resp = client.Get <GetProgramDetailsSummaryResponse>(url);
                pd = NGUtils.FormatProgramDetail(resp.Program);

                return(pd);
            }
            catch (Exception ex)
            {
                throw new Exception("AD:PlanElementEndpointUtil:RequestPatientProgramDetail()::" + ex.Message, ex.InnerException);
            }
        }
Example #2
0
 public override bool IsSatisfiedBy(T obj)
 {
     try
     {
         Program p      = obj as Program;
         bool    result = true;
         if (p.Modules != null)
         {
             foreach (Module m in p.Modules)
             {
                 foreach (Actions a in m.Actions)
                 {
                     if (a.ElementState == (int)ElementState.InProgress) // == 4
                     {
                         result = false;
                     }
                 }
             }
         }
         return(result);
     }
     catch (Exception ex)
     {
         throw new Exception("AD:PlanElementUtil:IsActionInitial()::" + ex.Message, ex.InnerException);
     }
 }
Example #3
0
            public void Set_Two_Actions_Enabled_AssignTo()
            {
                IPlanElementUtils pUtils     = new PlanElementUtils();
                string            modId      = ObjectId.GenerateNewId().ToString();
                ObjectId          assingtoID = ObjectId.GenerateNewId();

                AD.Program prog = new AD.Program
                {
                    AssignToId = assingtoID.ToString(),
                    Modules    = new List <AD.Module>
                    {
                        new AD.Module
                        {
                            Id      = modId,
                            Actions = new List <AD.Actions>
                            {
                                new AD.Actions
                                {
                                    Enabled = true
                                },
                                new AD.Actions
                                {
                                    Enabled = true
                                }
                            }
                        }
                    }
                };

                pUtils.SetElementEnabledState(modId, prog);
                Assert.AreEqual(assingtoID.ToString(), prog.Modules[0].Actions[0].AssignToId);
                Assert.AreEqual(assingtoID.ToString(), prog.Modules[0].Actions[1].AssignToId);
            }
Example #4
0
            public void Set_One_Action_Enabled()
            {
                IPlanElementUtils pUtils = new PlanElementUtils();
                string            modId  = ObjectId.GenerateNewId().ToString();

                AD.Program prog = new AD.Program
                {
                    Modules = new List <AD.Module>
                    {
                        new AD.Module
                        {
                            Id      = modId,
                            Actions = new List <AD.Actions>
                            {
                                new AD.Actions
                                {
                                    Enabled = true
                                },
                                new AD.Actions
                                {
                                    Enabled = false
                                }
                            }
                        }
                    }
                };

                pUtils.SetElementEnabledState(modId, prog);
                Assert.IsNotNull(prog.Modules[0].Actions[0].AssignById);
            }
Example #5
0
        public static DTO.Program FormatProgramDetail(ProgramDetail program)
        {
            try
            {
                ProgramDetail p  = program;
                DTO.Program   pD = null;

                pD = new DTO.Program
                {
                    AssignById              = p.AssignBy,
                    AssignDate              = p.AssignDate,
                    AssignToId              = p.AssignTo,
                    Client                  = p.Client,
                    Completed               = p.Completed,
                    CompletedBy             = p.CompletedBy,
                    ContractProgramId       = p.ContractProgramId,
                    DateCompleted           = p.DateCompleted,
                    Description             = p.Description,
                    ElementState            = p.ElementState,
                    StateUpdatedOn          = p.StateUpdatedOn,
                    EligibilityEndDate      = p.EligibilityEndDate,
                    EligibilityRequirements = p.EligibilityRequirements,
                    EligibilityStartDate    = p.EligibilityStartDate,
                    Enabled                 = p.Enabled,
                    StartDate               = p.StartDate,
                    EndDate                 = p.EndDate,
                    AttrEndDate             = p.AttrEndDate,
                    AttrStartDate           = p.AttrStartDate,
                    AuthoredBy              = p.AuthoredBy,
                    TemplateName            = p.TemplateName,
                    TemplateVersion         = p.TemplateVersion,
                    ProgramVersion          = p.ProgramVersion,
                    ProgramVersionUpdatedOn = p.ProgramVersionUpdatedOn,
                    Id              = p.Id,
                    Modules         = GetADModules(p.Modules),
                    Name            = p.Name,
                    Next            = p.Next,
                    Objectives      = GetADObjectives(p.ObjectivesData),
                    Order           = p.Order,
                    PatientId       = p.PatientId,
                    Previous        = p.Previous,
                    ProgramState    = p.ProgramState,
                    ShortName       = p.ShortName,
                    SourceId        = p.SourceId,
                    SpawnElement    = GetADSpawnElements(p.SpawnElement),
                    Status          = p.Status,
                    Text            = p.Text,
                    Version         = p.Version,
                    Archived        = p.Archived,
                    ArchivedDate    = p.ArchivedDate,
                    ArchiveOriginId = p.ArchiveOriginId
                };

                return(pD);
            }
            catch (Exception ex)
            {
                throw new Exception("AD:FormatProgramDetail()::" + ex.Message, ex.InnerException);
            }
        }
Example #6
0
            public void Set_One_Action_Enabled_AssignDate()
            {
                IPlanElementUtils pUtils = new PlanElementUtils();
                string            modId  = ObjectId.GenerateNewId().ToString();

                AD.Program prog = new AD.Program
                {
                    Modules = new List <AD.Module>
                    {
                        new AD.Module
                        {
                            Id      = modId,
                            Actions = new List <AD.Actions>
                            {
                                new AD.Actions
                                {
                                    Enabled = true
                                },
                                new AD.Actions
                                {
                                    Enabled = false
                                }
                            }
                        }
                    }
                };

                pUtils.SetElementEnabledState(modId, prog);
                Assert.AreEqual(DateTime.UtcNow.Date, ((DateTime)prog.Modules[0].Actions[0].AssignDate).Date);
            }
Example #7
0
            public void Get_Assigned_Date()
            {
                DateTime          control = DateTime.UtcNow.Date;
                IPlanElementUtils peUtil  = new PlanElementUtils {
                };

                AD.Module  mod  = new AD.Module();
                AD.Program prog = new AD.Program();

                peUtil.SetInitialProperties("123456789012345678901234", mod, false);

                Assert.AreEqual(DateTime.UtcNow.Date, ((DateTime)mod.AssignDate).Date);
            }
Example #8
0
        public PostSaveActionResponse SaveActionResults(PostSaveActionRequest request)
        {
            try
            {
                // need to refactor this into a mediator.
                RelatedChanges.Clear();
                PostSaveActionResponse response = new PostSaveActionResponse();

                Program p      = EndPointUtils.RequestPatientProgramDetail(request);
                Actions action = request.Action;

                // set elementstates to in progress
                Module mod = PEUtils.FindElementById(p.Modules, action.ModuleId);

                // set to in progress
                if (mod.ElementState == (int)ElementState.NotStarted)  //!= 4
                {
                    mod.ElementState   = (int)ElementState.InProgress; //4;
                    mod.StateUpdatedOn = DateTime.UtcNow;
                }

                if (PEUtils.IsActionInitial(p))
                {
                    // set program to in progress
                    if (p.ElementState == (int)ElementState.NotStarted)
                    {
                        p.ElementState   = (int)ElementState.InProgress; //4;
                        p.StateUpdatedOn = System.DateTime.UtcNow;
                    }
                }

                NGUtils.UpdateProgramAction(action, p);

                AddUniquePlanElementToProcessedList(mod);

                // save
                EndPointUtils.SaveAction(request, action.Id, p, false);

                //response.Program = p;
                response.Saved          = true;
                response.RelatedChanges = RelatedChanges;
                response.PatientId      = request.PatientId;
                response.Version        = request.Version;

                return(response);
            }
            catch (Exception ex)
            {
                throw new Exception("AD:InterviewManager:ProcessActionResults()::" + ex.Message, ex.InnerException);
            }
        }
Example #9
0
        private static Actions GetActionById(AD.Program p, string actionId)
        {
            Actions action = null;

            try
            {
                action = p.Modules.SelectMany(module => module.Actions).Where(act => act.Id == actionId).FirstOrDefault();
                return(action);
            }
            catch (Exception ex)
            {
                throw new Exception("AD:PlanElementEndpointUtil:GetActionById()::" + ex.Message, ex.InnerException);
            }
        }
Example #10
0
            public void Get_Assigned_To_Null()
            {
                string            assignedTO = null;
                IPlanElementUtils peUtil     = new PlanElementUtils {
                };

                AD.Module  mod  = new AD.Module();
                AD.Program prog = new AD.Program {
                    AssignToId = assignedTO
                };

                peUtil.SetInitialProperties(assignedTO, mod, false);

                Assert.AreEqual(assignedTO, mod.AssignToId);
            }
Example #11
0
            public void Set_Assigned_Date_Null()
            {
                string            assignedTO = null;
                IPlanElementUtils peUtil     = new PlanElementUtils {
                };

                AD.Module  mod  = new AD.Module();
                AD.Program prog = new AD.Program {
                    AssignToId = assignedTO
                };

                peUtil.SetInitialProperties(assignedTO, mod, false);

                Assert.AreEqual(DateTime.UtcNow.Date, ((DateTime)mod.AssignDate).Date);
            }
Example #12
0
            public void Get_Assigned_To()
            {
                ObjectId?         assignedTO = new ObjectId();
                IPlanElementUtils peUtil     = new PlanElementUtils {
                };

                AD.Module  mod  = new AD.Module();
                AD.Program prog = new AD.Program {
                    AssignToId = assignedTO.ToString()
                };

                peUtil.SetInitialProperties(assignedTO.ToString(), mod, false);

                Assert.AreEqual(assignedTO.ToString(), mod.AssignToId);
            }
Example #13
0
            public void Clone_With_StateChangeDate()
            {
                DateTime          control = DateTime.UtcNow.Date;
                IPlanElementUtils peUtil  = new PlanElementUtils {
                };

                AD.Program program = new AD.Program {
                    ElementState = 1, StateUpdatedOn = control
                };
                peUtil.CloneProgram(program);

                DateTime sample = ((DateTime)program.StateUpdatedOn).Date;

                Assert.AreEqual(control, sample);
            }
Example #14
0
 private void SaveResponsesFromProgramAction(AD.Program p, string actionId, IProcessActionRequest request, bool repeat)
 {
     try
     {
         Actions act = GetActionById(p, actionId);
         SaveResponses(act, request, repeat);
         // clear response collections
         foreach (Step stp in act.Steps)
         {
             stp.Responses = null;
         }
     }
     catch (Exception ex)
     {
         throw new Exception("AD:PlanElementEndpointUtil:SaveResponsesFromProgramAction()::" + ex.Message, ex.InnerException);
     }
 }
Example #15
0
            public void Set_AssignedTo_CM_Already_Assigned_In_Program()
            {
                string            assignedTO = ObjectId.GenerateNewId().ToString();
                IPlanElementUtils peUtil     = new PlanElementUtils {
                };
                DateTime assigned            = DateTime.UtcNow;

                AD.Actions act = new AD.Actions {
                    AssignDate = assigned
                };
                AD.Program prog = new AD.Program {
                    AssignToId = assignedTO
                };

                peUtil.SetInitialProperties(assignedTO, act, false);

                Assert.AreEqual(assignedTO, act.AssignToId);
            }
Example #16
0
            public void Set_Assigned_To_No_CM_Assigned_In_Program()
            {
                string            assignedTO = null;
                IPlanElementUtils peUtil     = new PlanElementUtils {
                };
                DateTime assigned            = DateTime.UtcNow;

                AD.Actions act = new AD.Actions {
                    AssignDate = assigned
                };
                AD.Program prog = new AD.Program {
                    AssignToId = assignedTO
                };

                peUtil.SetInitialProperties(assignedTO, act, false);

                Assert.IsNull(act.AssignToId);
            }
Example #17
0
            public void Set_Assigned_Date_Already_Assigned()
            {
                string            assignedDate = null;
                IPlanElementUtils peUtil       = new PlanElementUtils {
                };
                DateTime assigned = DateTime.UtcNow;

                AD.Actions act = new AD.Actions {
                    AssignDate = assigned
                };
                AD.Program prog = new AD.Program {
                    AssignToId = assignedDate
                };

                peUtil.SetInitialProperties(assignedDate, act, false);

                Assert.AreEqual(assigned.Date, ((DateTime)act.AssignDate).Date);
            }
Example #18
0
        public static Actions UpdateProgramAction(Actions ac, DTO.Program p)
        {
            DTO.Program pr  = p;
            DTO.Actions act = null;
            pr.Modules.ForEach(m =>
            {
                foreach (Actions a in m.Actions)
                {
                    bool replaced = ReplaceAction(ac, m, a);
                    if (replaced)
                    {
                        act = a;
                        break;
                    }
                }
            });

            return(act);
        }
Example #19
0
            public void SetProgramAttributes_DoNot_Set_Program_State_state_1()
            {
                IPlanElementUtils pUtils = new PlanElementUtils {
                    ProgramAttributeStrategy = new ProgramAttributeStrategy()
                };
                var pe = new AD.PlanElement {
                    Enabled = false
                };
                var progAttr = new ProgramAttributeData();
                var prog     = new AD.Program {
                    Name = "test"
                };

                pUtils.SetProgramAttributes(new AD.SpawnElement {
                    Tag = "1", ElementType = 10, ElementId = "1234"
                }, prog, "user", progAttr);

                Assert.AreEqual(0, prog.ElementState);
            }
Example #20
0
 public void ProcessWorkflow(IPlanElement planElem, Program program, string userId, string patientId,
                             Actions action, IAppDomainRequest request)
 {
     try
     {
         OnPlanElement(new PlanElementEventArg
         {
             PlanElement   = planElem,
             Program       = program,
             UserId        = userId,
             PatientId     = patientId,
             Action        = action,
             DomainRequest = request
         });
     }
     catch (Exception ex)
     {
         throw new Exception("AD:PlanProcessor:ProcessWorkflow()::" + ex.Message, ex.InnerException);
     }
 }
        public override void Execute(SpawnElement r, Program program, string userId, ProgramAttributeData progAttr)
        {
            try
            {
                if (r.Tag == null)
                {
                    throw new ArgumentException("Cannot set attribute of type " + r.ElementType + ". Tag value is null.");
                }

                progAttr.Eligibility = (!string.IsNullOrEmpty(r.Tag)) ? Convert.ToInt32(r.Tag) : 0;
            }
            catch (Exception ex)
            {
                throw new Exception("AD:SetProgramAttributes()::Eligibility" + ex.Message, ex.InnerException);
            }

            int state; // no = 1, yes = 2
            var isNum = int.TryParse(r.Tag, out state);

            if (!isNum)
            {
                return;
            }

            // program is closed due to ineligibility
            switch (state)
            {
            case 1:
                //program.ElementState = (int) DataDomain.Program.DTO.ElementState.Completed; //5;
                //program.StateUpdatedOn = System.DateTime.UtcNow;
                progAttr.Eligibility = 1;
                //program.AttrEndDate = System.DateTime.UtcNow;
                break;

            case 2:
                //program.ElementState = (int) DataDomain.Program.DTO.ElementState.InProgress; //4;
                //program.StateUpdatedOn = System.DateTime.UtcNow;
                progAttr.Eligibility = 2;
                break;
            }
        }
Example #22
0
            public void Set_Element_State_Change_Date()
            {
                IPlanElementUtils peUtil = new PlanElementUtils {
                };

                AD.SpawnElement spwn = new AD.SpawnElement
                {
                    ElementId   = "123456789012345678901234",
                    ElementType = 12,
                    Tag         = "3"
                };
                AD.Program program = new AD.Program {
                    ElementState = 1
                };
                ProgramAttributeData progAttr = new ProgramAttributeData();

                peUtil.SetProgramAttributes(spwn, program, "UserId", progAttr);

                DateTime control = DateTime.UtcNow.Date;
                DateTime sample  = ((DateTime)program.StateUpdatedOn).Date;

                Assert.AreEqual(control, sample);
            }
Example #23
0
            public void Update_Action_Assign_To()
            {
                IPlanElementUtils pUtils = new PlanElementUtils();

                var targetAction = ObjectId.GenerateNewId().ToString();

                AD.Program prog = new AD.Program
                {
                    Id      = ObjectId.GenerateNewId().ToString(),
                    Modules = new List <AD.Module>
                    {
                        new AD.Module
                        {
                            Id      = ObjectId.GenerateNewId().ToString(),
                            Actions = new List <AD.Actions>
                            {
                                new AD.Actions
                                {
                                    Id           = targetAction,
                                    ElementState = 2
                                },
                                new AD.Actions
                                {
                                    Id = ObjectId.GenerateNewId().ToString()
                                }
                            }
                        },
                        new AD.Module
                        {
                            Id      = ObjectId.GenerateNewId().ToString(),
                            Actions = new List <AD.Actions>
                            {
                                new AD.Actions
                                {
                                    Id = ObjectId.GenerateNewId().ToString()
                                },
                                new AD.Actions
                                {
                                    Id = ObjectId.GenerateNewId().ToString()
                                }
                            }
                        },
                    }
                };

                var assignToId = ObjectId.GenerateNewId().ToString();

                AD.PlanElement pe = new AD.PlanElement
                {
                    Id         = targetAction,
                    AssignToId = assignToId
                };

                var planElems = new DTO.PlanElements
                {
                    Actions  = new List <DTO.Actions>(),
                    Modules  = new List <DTO.Module>(),
                    Programs = new List <DTO.Program>(),
                    Steps    = new List <DTO.Step>()
                };

                pUtils.UpdatePlanElementAttributes(prog, pe, "111111111111111111111111", planElems);

                Assert.AreEqual(assignToId, prog.Modules[0].Actions[0].AssignToId);
            }
Example #24
0
        public PostProcessActionResponse ProcessActionResults(PostProcessActionRequest request)
        {
            try
            {
                // need to refactor this into a mediator.
                RelatedChanges.Clear();
                ProcessedElements.Clear();
                PostProcessActionResponse response = new PostProcessActionResponse();
                response.PlanElems = new PlanElements();

                Program p = EndPointUtils.RequestPatientProgramDetail(request);

                Actions action = request.Action;

                if (action.Completed)
                {
                    // 1) pre-process
                    // set program starting date
                    if (IsInitialAction.IsSatisfiedBy(p))
                    {
                        p.AttrStartDate = DateTime.UtcNow;
                        //PlanElementUtil.SetStartDateForProgramAttributes(request.ProgramId, request);
                    }

                    // get module reference
                    Module mod = PEUtils.FindElementById(p.Modules, action.ModuleId);

                    // set module to in progress
                    if (mod.ElementState == (int)ElementState.NotStarted)  //!= 4
                    {
                        mod.ElementState   = (int)ElementState.InProgress; //4;
                        mod.StateUpdatedOn = DateTime.UtcNow;
                    }

                    // 2) set in progress state
                    //new ResponseSpawnAllowed<Step>().IsSatisfiedBy(s)
                    if (PEUtils.IsActionInitial(p))
                    //if (new IsActionInitialSpecification<Program>().IsSatisfiedBy(p))
                    {
                        // set program to in progress
                        if (p.ElementState == (int)ElementState.NotStarted)
                        {
                            p.ElementState   = (int)ElementState.InProgress; //4;
                            p.StateUpdatedOn = DateTime.UtcNow;
                        }
                    }

                    // 3) set action state to completed
                    action.ElementState   = (int)ElementState.Completed;
                    action.StateUpdatedOn = DateTime.UtcNow;

                    // 4) insert action update
                    var act = NGUtils.UpdateProgramAction(action, p);

                    //// create a responsibility chain to process each elemnt in the hierachy
                    ProgramPlanProcessor pChain = InitializeProgramChain();

                    // 5)  process steps
                    action.Steps.ForEach(
                        s =>
                        pChain.ProcessWorkflow((IPlanElement)s, p, request.UserId, request.PatientId, action,
                                               request));

                    // 6) process action
                    pChain.ProcessWorkflow((IPlanElement)action, p, request.UserId, request.PatientId, action, request);

                    // 7) process module
                    if (mod != null)
                    {
                        // set enabled status for action dependencies
                        PEUtils.SetEnabledStatusByPrevious(mod.Actions, mod.AssignToId, mod.Enabled);
                        // set enable/visibility of actions after action processing.
                        pChain.ProcessWorkflow((IPlanElement)mod, p, request.UserId, request.PatientId, action, request);
                        AddUniquePlanElementToProcessedList(mod);
                    }

                    // post processing //
                    // 8) set module visibility for modules
                    PEUtils.SetEnabledStatusByPrevious(p.Modules, p.AssignToId, p.Enabled);

                    // 9) evaluate program status
                    if (PEUtils.IsProgramCompleted(p, request.UserId))
                    {
                        p.Completed = true;
                        pChain.ProcessWorkflow((IPlanElement)p, p, request.UserId, request.PatientId, action, request);
                    }

                    // 10) register changed action
                    AddUniquePlanElementToProcessedList(action);
                }
                else
                {
                    // need to update this on the p level.
                    action.ElementState = (int)ElementState.InProgress; //4; // in progress
                }

                AddUniquePlanElementToProcessedList(p);

                // save
                var pdetail = EndPointUtils.SaveAction(request, action.Id, p, false);

                // create element changed lists
                PEUtils.HydratePlanElementLists(ProcessedElements, response.PlanElems);

                response.PlanElems.Attributes = PEUtils.GetAttributes(pdetail.Attributes);
                response.RelatedChanges       = RelatedChanges;
                response.PatientId            = request.PatientId;
                response.Version = request.Version;

                return(response);
            }
            catch (Exception ex)
            {
                throw new Exception("AD:InterviewManager:ProcessActionResults()::" + ex.Message, ex.InnerException);
            }
        }
Example #25
0
 public ProgramDetail SaveAction(IProcessActionRequest request, string actionId, Program p, bool repeat)
 {
     throw new NotImplementedException();
 }
Example #26
0
        public ProgramDetail SaveAction(IProcessActionRequest request, string actionId, AD.Program p, bool repeat)
        {
            try
            {
                // save responses from action steps
                SaveResponsesFromProgramAction(p, actionId, request, repeat);

                var pD = NGUtils.FormatProgramDetail(p);

                var client = new JsonServiceClient();

                var url = Common.Helper.BuildURL(string.Format(@"{0}/{1}/{2}/{3}/Patient/{4}/Programs/{5}/Update",
                                                               DDProgramServiceUrl,
                                                               "NG",
                                                               request.Version,
                                                               request.ContractNumber,
                                                               request.PatientId,
                                                               request.ProgramId,
                                                               request.Token), request.UserId);

                var response = client.Put <DD.PutProgramActionProcessingResponse>(
                    url, new PutProgramActionProcessingRequest {
                    Program = pD, UserId = request.UserId
                });

                return(response.program);
            }
            catch (Exception ex)
            {
                throw new Exception("AD:PlanElementEndpointUtil:SaveAction()::" + ex.Message, ex.InnerException);
            }
        }
Example #27
0
 public abstract void Execute(SpawnElement r, Program program, string userId, ProgramAttributeData progAttr);
Example #28
0
 public void Run(SpawnElement r, Program program, string userId, ProgramAttributeData progAttr)
 {
     _rules.First(a => a.ProgramAttributeType == r.ElementType).Execute(r, program, userId, progAttr);
 }
Example #29
0
        public void HydratePlanElementLists(List <object> processedElements, DTO.PlanElements planElems)
        {
            object _obj = null;

            try
            {
                if (planElems == null)
                {
                    throw new ArgumentException("planElems is null.");
                }
                if (processedElements == null)
                {
                    throw new ArgumentException("processedElements is null.");
                }

                if (processedElements != null && processedElements.Count > 0)
                {
                    foreach (Object obj in processedElements)
                    {
                        _obj = obj;
                        if (obj.GetType() == typeof(Program))
                        {
                            try
                            {
                                if (!planElems.Programs.Contains(obj))
                                {
                                    Program p = CloneProgram((Program)obj);
                                    planElems.Programs.Add(p);
                                }
                            }
                            catch (Exception ex)
                            {
                                throw new ArgumentException("plan elems programs collection null" + ex.Message);
                            }
                        }
                        else if (obj.GetType() == typeof(Module))
                        {
                            try
                            {
                                if (!planElems.Modules.Contains(obj))
                                {
                                    Module m = CloneModule((Module)obj);
                                    planElems.Modules.Add(m);
                                }
                            }
                            catch (Exception ex)
                            {
                                throw new ArgumentException("plan elems modules collection null" + ex.Message);
                            }
                        }
                        else if (obj.GetType() == typeof(Actions))
                        {
                            try
                            {
                                if (!planElems.Actions.Contains(obj))
                                {
                                    Actions a = CloneAction((Actions)obj);
                                    planElems.Actions.Add(a);
                                }
                            }
                            catch (Exception ex)
                            {
                                throw new ArgumentException("plan elems actions collection null" + ex.Message);
                            }
                        }
                        else if (obj.GetType() == typeof(Step))
                        {
                            try
                            {
                                if (!planElems.Steps.Contains(obj))
                                {
                                    Step s = CloneStep((Step)obj);
                                    planElems.Steps.Add(s);
                                }
                            }
                            catch (Exception ex)
                            {
                                throw new ArgumentException("plan elems step collection null" + ex.Message);
                            }
                        }
                        else if (obj.GetType() == typeof(PatientGoal))
                        {
                            try
                            {
                                if (!planElems.Goals.Contains(obj))
                                {
                                    PatientGoal s = CloneGoal((PatientGoal)obj);
                                    planElems.Goals.Add(s);
                                }
                            }
                            catch (Exception ex)
                            {
                                throw new ArgumentException("plan elems patientgoal collection null" + ex.Message);
                            }
                        }
                        else if (obj.GetType() == typeof(PatientIntervention))
                        {
                            try
                            {
                                if (!planElems.Interventions.Contains(obj))
                                {
                                    PatientIntervention s = CloneIntervention((PatientIntervention)obj);
                                    planElems.Interventions.Add(s);
                                }
                            }
                            catch (Exception ex)
                            {
                                throw new ArgumentException("plan elems PatientIntervention collection null" + ex.Message);
                            }
                        }
                        else if (obj.GetType() == typeof(PatientTask))
                        {
                            try
                            {
                                if (!planElems.Tasks.Contains(obj))
                                {
                                    PatientTask s = CloneTask((PatientTask)obj);
                                    planElems.Tasks.Add(s);
                                }
                            }
                            catch (Exception ex)
                            {
                                throw new ArgumentException("plan elems patienttask collection null" + ex.Message);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception("AD:PlanElementUtil:HydratePlanElementLists()::" + _obj.GetType().ToString() + ex.Message, ex.InnerException);
            }
        }