Example #1
0
        public ActionResult Create(AdministrationViewModel administrationVM, int projectid)
        {
            if (!_projectuservalidationservice.UserCanEditProject(projectid))
            {
                ViewBag.ErrorMessage = "Access Denied. Please contact administrator for further assistance.";
                return(View("Error"));
            }
            if (ModelState.IsValid)
            {
                var unit = db.Units.Find(administrationVM.unitID);

                var factor = unit.ConversionFactor;

                Administration administration = new Administration
                {
                    StartTime     = Convert.ToInt32(administrationVM.StartTime * factor),
                    EndTime       = Convert.ToInt32(administrationVM.EndTime * factor),
                    ProcedureID   = administrationVM.ProcedureID,
                    CreatedBy     = (int)Membership.GetUser().ProviderUserKey,
                    LastUpdatedBy = (int)Membership.GetUser().ProviderUserKey,
                };

                db.Administrations.Add(administration);
                db.SaveChanges();
                return(RedirectToAction("Index", new { procedureid = administrationVM.ProcedureID, projectid = administrationVM.ProjectID }));
            }
            return(View(administrationVM));
        }
Example #2
0
        public ActionResult Create(CohortViewModel cohortVM)
        {
            if (!ModelState.IsValid || cohortVM == null)
            {
                return(View(cohortVM));
            }

            if (!_projectuservalidationservice.UserCanEditProject(cohortVM.MultiPARTProjectID))
            {
                ViewBag.ErrorMessage = "Access Denied. Please contact administrator for further assistance.";
                return(View("Error"));
            }

            Cohort cohort = new Cohort()
            {
                MultiPARTProjectMultiPARTProjectID = cohortVM.MultiPARTProjectID,
                CohortLabel = cohortVM.CohortLabel,

                StrainStrainID = cohortVM.StrainID,
                SampleSize     = cohortVM.SampleSize ?? 0,
                SexID          = cohortVM.SexID,
                MinAge         = cohortVM.MinAge ?? 0,
                MaxAge         = cohortVM.MaxAge ?? 0,
                MinWeight      = cohortVM.MinWeight ?? 0,
                MaxWeight      = cohortVM.MaxWeight ?? 0,
                Details        = cohortVM.Details,

                CreatedBy     = (int)Membership.GetUser().ProviderUserKey,
                LastUpdatedBy = (int)Membership.GetUser().ProviderUserKey
            };

            db.Cohorts.Add(cohort);
            db.SaveChanges();
            return(RedirectToAction("Details", "MultiPARTProject", new { projectid = cohortVM.MultiPARTProjectID }));
        }
Example #3
0
        public ActionResult Create(InstitutionViewModel institutionVM)
        {
            Institution institution = new Institution();

            if (ModelState.IsValid)
            {
                institution.InstitutionName  = institutionVM.InstitutionName;
                institution.CountryCountryID = institutionVM.CountryCountryID;
                institution.LastUpdatedBy    = (int)Membership.GetUser().ProviderUserKey;
                //institution.LastUpdatedOn = DateTimeOffset.Now;
                institution.CreatedBy = (int)Membership.GetUser().ProviderUserKey;
                institution.CreatedOn = DateTimeOffset.Now;
                db.Institutions.Add(institution);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            ViewBag.CountryList = new SelectList(db.Countries.Where(c => c.Status == "Current").OrderBy(c => c.CountryName).AsEnumerable(), "CountryID", "CountryName", institution.CountryCountryID);
            return(View(institution));
        }
Example #4
0
        public ActionResult Create(ProcedureViewModel procedureVM)
        {
            if (!ModelState.IsValid)
            {
                ViewBag.proceduretypelist = new SelectList(db.Options.Where(o => o.OptionFields.OptionFieldName == "Procedure Type" && o.Status == "Current").AsEnumerable(), "OptionID", "OptionValue");

                ViewBag.procedurepurpose   = procedureVM.ProcedurePurpose;
                ViewBag.MultiPARTProjectID = procedureVM.MultiPARTProjectID;

                return(View(procedureVM));
            }

            if (procedureVM == null)
            {
                return(new HttpStatusCodeResult(422));
            }

            if (!_projectuservalidationservice.UserCanEditProject(procedureVM.ProcedureID))
            {
                ViewBag.ErrorMessage = "Access Denied. Please contact administrator for further assistance.";
                return(View("Error"));
            }


            Procedure procedure = new Procedure()
            {
                MultiPARTProjectMultiPARTProjectID = procedureVM.MultiPARTProjectID,
                ProcedureLabel     = procedureVM.ProcedureLabel,
                ProcedureTypeID    = procedureVM.ProcedureTypeID,
                ProcedurePurposeID = db.Options.Where(p => p.Status == "Current" && p.OptionFields.OptionFieldName == "Procedure Purpose" && p.OptionValue == procedureVM.ProcedurePurpose).Select(p => p.OptionID).FirstOrDefault(),
                Details            = procedureVM.Details,

                CreatedBy     = (int)Membership.GetUser().ProviderUserKey,
                CreatedOn     = DateTimeOffset.Now,
                LastUpdatedBy = (int)Membership.GetUser().ProviderUserKey
            };

            db.Procedures.Add(procedure);
            db.SaveChanges();
            return(RedirectToAction("Details", "MultiPARTProject", new { projectid = procedureVM.MultiPARTProjectID }));
        }
Example #5
0
        public ActionResult Create(AnimalViewModel animalVM)
        {
            if (!ModelState.IsValid || animalVM == null)
            {
                View(animalVM);
            }

            if (!_projectuservalidationservice.UserCanCreateAnimal(animalVM.ProjectID))
            {
                ViewBag.ErrorMessage = "Access Denied. Please contact administrator for further assistance.";
                return(View("Error"));
            }

            Animal animal = new Animal
            {
                AnimalLabel     = animalVM.AnimalLabel,
                ResearchgroupID = animalVM.ResearchgroupID,

                CreatedBy     = (int)Membership.GetUser().ProviderUserKey,
                CreatedOn     = DateTimeOffset.Now,
                LastUpdatedBy = (int)Membership.GetUser().ProviderUserKey
            };

            var cohorts = from r in db.ResearchgroupCohortAssignments
                          orderby r.CohortID
                          where r.Status == "Current" &&
                          r.Cohorts.Status == "Current" &&
                          r.ResearchgroupID == animalVM.ResearchgroupID &&
                          r.Researchgroups.Status == "Current" &&
                          r.Cohorts.MultiPARTProjectMultiPARTProjectID == animalVM.ProjectID &&
                          r.Cohorts.MultiPARTProjects.Status == "Current" &&
                          r.Cohorts.CohortProcedureAssignments.Where(cpa => cpa.Status == "Current").Select(cpa => cpa.ProcedureID).Contains(animalVM.DiseasseModelInductionID)
                          select new RandomizationViewModel
            {
                CohortLabel            = r.Cohorts.CohortLabel,
                CohortID               = r.CohortID,
                CurrentNumberOfAnimals = r.Cohorts.Animals.Count(a => a.ResearchgroupID == animalVM.ResearchgroupID),
                TotalNumberOfAnimals   = r.NumberOfAnimals,
            };


            animal.CohortID = RandomisationService.RandomizeAnimal(cohorts.ToList());

            db.Animals.Add(animal);

            db.SaveChanges();

            return(RedirectToAction("Details", new { animalid = animal.AnimalID, researchgroupid = animalVM.ResearchgroupID, diseasemodelinductionid = animalVM.DiseasseModelInductionID }));
        }
Example #6
0
        public ActionResult Edit(UserProfile userprofile)
        {
            UserProfile newprofile = db.UserProfiles.Find(userprofile.UserId);

            if (ModelState.IsValid)
            {
                newprofile.ForeName      = userprofile.ForeName;
                newprofile.SurName       = userprofile.SurName;
                newprofile.Email         = userprofile.Email;
                newprofile.Details       = userprofile.Details;
                newprofile.LastUpdatedBy = userprofile.UserId;
                //newprofile.LastUpdatedOn = DateTimeOffset.Now;
                //db.Entry(userprofile).State = EntityState.Modified;

                db.SaveChanges();
                if (User.IsInRole("Administrator"))
                {
                    return(RedirectToAction("Users"));
                }
                return(RedirectToAction("ViewProfile"));
            }

            return(View(userprofile));
        }
Example #7
0
        public ActionResult Create(ResearchgroupViewModel ResearchgroupVM)
        {
            if (!ModelState.IsValid)
            {
                ViewBag.InstitutionList = new SelectList(db.Institutions.Where(c => c.Status == "Current").OrderBy(c => c.InstitutionName).AsEnumerable(), "InstitutionID", "InstitutionName", ResearchgroupVM.InstitutionID);
                return(View(ResearchgroupVM));
            }

            Researchgroup researchgroup = new Researchgroup()
            {
                ResearchgroupName        = ResearchgroupVM.ResearchgroupName,
                InstitutionInstitutionID = ResearchgroupVM.InstitutionID,
                LastUpdatedBy            = (int)Membership.GetUser().ProviderUserKey,
                CreatedOn = DateTimeOffset.Now,
                CreatedBy = (int)Membership.GetUser().ProviderUserKey,
            };

            db.Researchgroups.Add(researchgroup);
            db.SaveChanges();

            return(RedirectToAction("Index"));
        }
Example #8
0
        public ActionResult Index(IList <AnimalHusbandryViewModel> AnimalHusbandryVM)
        {
            if (!ModelState.IsValid || AnimalHusbandryVM == null)
            {
                return(new HttpStatusCodeResult(422));
            }

            if (!_projectuservalidationservice.UserIsInProject(AnimalHusbandryVM.FirstOrDefault().MultiPARTProjectID))
            {
                ViewBag.ErrorMessage = "Access Denied. Please contact administrator for further assistance.";
                return(View("Error"));
            }

            int userid          = (int)Membership.GetUser().ProviderUserKey;
            int projectid       = AnimalHusbandryVM.FirstOrDefault().MultiPARTProjectID;
            int researchgroupid = AnimalHusbandryVM.FirstOrDefault().ResearchgroupID;
            int strainid        = AnimalHusbandryVM.FirstOrDefault().StrainID;

            foreach (var ah in AnimalHusbandryVM)
            {
                if (ah.AnimalHusbandryID > 0)
                {
                    AnimalHusbandry AnimalHusbandry = db.AnimalHusbandries.Find(ah.AnimalHusbandryID);

                    if (AnimalHusbandry.AnimalHusbandryFieldID == ah.FieldID &&
                        AnimalHusbandry.StrainID == ah.StrainID &&
                        AnimalHusbandry.MultiPARTProjectMultiPARTProjectID == ah.MultiPARTProjectID &&
                        AnimalHusbandry.ResearchgroupResearchgroupID == ah.ResearchgroupID)
                    {
                        AnimalHusbandry.AnimalHusbandryOptionID = ah.OptionID;
                        AnimalHusbandry.Value         = ah.Value;
                        AnimalHusbandry.LastUpdatedBy = userid;
                    }
                    else
                    {
                        ViewBag.ErrorMessage = "Some illegal changes had been made to the animal husbandry record. Please contact administrator about the error.";
                        return(View("Error"));
                    }
                }
                else if (ah.AnimalHusbandryID == 0)
                {
                    AnimalHusbandry AnimalHusbandry = new AnimalHusbandry()
                    {
                        AnimalHusbandryFieldID = ah.FieldID,
                        StrainID = ah.StrainID,
                        MultiPARTProjectMultiPARTProjectID = ah.MultiPARTProjectID,
                        ResearchgroupResearchgroupID       = ah.ResearchgroupID,

                        LastUpdatedBy = userid,
                    };

                    AnimalHusbandry.AnimalHusbandryOptionID = ah.OptionID;
                    AnimalHusbandry.Value = ah.Value;

                    db.AnimalHusbandries.Add(AnimalHusbandry);
                }
                else
                {
                    ViewBag.ErrorMessage = "Some illegal changes had been made to the animal husbandry table. Please contact administrator for the error.";
                    return(View("Error"));
                }
            }


            db.SaveChanges();

            return(RedirectToAction("Index", new { projectid = projectid, researchgroupid = researchgroupid, strainid = strainid }));


            //   ViewBag.ErrorMessage = "Saving to table failed. Please seed help from the administrator. ";

            //return View("Error");
        }
Example #9
0
        public ActionResult Index(ICollection <LookupTableViewModel> lookupVM, string lookuptablename)
        {
            if (lookuptablename == "Species")
            {
                foreach (var lookupVMitem in lookupVM)
                {
                    if (lookupVMitem.ID == 0)
                    {
                        Species record = new Species()
                        {
                            SpeciesID   = lookupVMitem.ID,
                            SpeciesName = lookupVMitem.Name,
                        };
                        db.Species.Add(record);
                    }
                    else if (lookupVMitem.ID > 0)
                    {
                        Species record = db.Species.Find(lookupVMitem.ID);
                        record.SpeciesName = lookupVMitem.Name;
                    }
                    else
                    {
                        return(View("Error"));
                    }
                    db.SaveChanges();
                }
            }
            else if (lookuptablename == "Strains")
            {
                foreach (var lookupVMitem in lookupVM)
                {
                    if (lookupVMitem.ID == 0)
                    {
                        Strain record = new Strain()
                        {
                            StrainID   = lookupVMitem.ID,
                            StrainName = lookupVMitem.Name,
                            SpeciesID  = lookupVMitem.CategoryID,
                        };
                        db.Strains.Add(record);
                    }
                    else if (lookupVMitem.ID > 0)
                    {
                        Strain record = db.Strains.Find(lookupVMitem.ID);
                        record.StrainName = lookupVMitem.Name;
                        record.SpeciesID  = lookupVMitem.CategoryID;
                    }
                    else
                    {
                        return(View("Error"));
                    }
                    db.SaveChanges();
                }
            }
            else if (lookuptablename == "AnimalHusbandryFields")
            {
                foreach (var lookupVMitem in lookupVM)
                {
                    if (lookupVMitem.ID == 0)
                    {
                        AnimalHusbandryField record = new AnimalHusbandryField()
                        {
                            AnimalHusbandryFieldID     = lookupVMitem.ID,
                            AnimalHusbandryFieldName   = lookupVMitem.Name,
                            AnimalHusbandryFieldTypeID = lookupVMitem.CategoryID,
                        };
                        db.AnimalHusbandryFields.Add(record);
                    }
                    else if (lookupVMitem.ID > 0)
                    {
                        AnimalHusbandryField record = db.AnimalHusbandryFields.Find(lookupVMitem.ID);
                        record.AnimalHusbandryFieldName   = lookupVMitem.Name;
                        record.AnimalHusbandryFieldTypeID = lookupVMitem.CategoryID;
                    }
                    else
                    {
                        return(View("Error"));
                    }
                    db.SaveChanges();
                }
            }
            else if (lookuptablename == "AnimalHusbandryOptions")
            {
                foreach (var lookupVMitem in lookupVM)
                {
                    if (lookupVMitem.ID == 0)
                    {
                        AnimalHusbandryOption record = new AnimalHusbandryOption()
                        {
                            AnimalHusbandryOptionID   = lookupVMitem.ID,
                            AnimalHusbandryOptionName = lookupVMitem.Name,
                            AnimalHusbandryFieldID    = lookupVMitem.CategoryID,
                        };
                        db.AnimalHusbandryOptions.Add(record);
                    }
                    else if (lookupVMitem.ID > 0)
                    {
                        AnimalHusbandryOption record = db.AnimalHusbandryOptions.Find(lookupVMitem.ID);
                        record.AnimalHusbandryOptionName = lookupVMitem.Name;
                        record.AnimalHusbandryFieldID    = lookupVMitem.CategoryID;
                    }
                    else
                    {
                        return(View("Error"));
                    }
                    db.SaveChanges();
                }
            }
            else if (lookuptablename == "ProcedureDetailFields")
            {
                foreach (var lookupVMitem in lookupVM)
                {
                    if (lookupVMitem.ID == 0)
                    {
                        ProcedureDetailOptionField record = new ProcedureDetailOptionField()
                        {
                            ProcedureDetailOptionFieldID   = lookupVMitem.ID,
                            ProcedureDetailOptionFieldName = lookupVMitem.Name,
                            ProcedureDetailFieldTypeID     = lookupVMitem.CategoryID,
                            ProcedurePurposeOrTypeID       = lookupVMitem.PurposeOrTypeID,
                            Multiple = lookupVMitem.Multiple,
                        };
                        db.ProcedureDetailOptionFields.Add(record);
                    }
                    else if (lookupVMitem.ID > 0)
                    {
                        ProcedureDetailOptionField record = db.ProcedureDetailOptionFields.Find(lookupVMitem.ID);
                        record.ProcedureDetailOptionFieldName = lookupVMitem.Name;
                        record.ProcedureDetailFieldTypeID     = lookupVMitem.CategoryID;
                        record.ProcedurePurposeOrTypeID       = lookupVMitem.PurposeOrTypeID;
                        record.Multiple = lookupVMitem.Multiple;
                    }
                    else
                    {
                        return(View("Error"));
                    }
                    db.SaveChanges();
                }
            }
            else if (lookuptablename == "ProcedureDetailOptions")
            {
                foreach (var lookupVMitem in lookupVM)
                {
                    if (lookupVMitem.ID == 0)
                    {
                        ProcedureDetailOption record = new ProcedureDetailOption()
                        {
                            ProcedureDetailOptionID      = lookupVMitem.ID,
                            ProcedureDetailOptionName    = lookupVMitem.Name,
                            ProcedureDetailOptionFieldID = lookupVMitem.CategoryID,
                        };
                        db.ProcedureDetailOptions.Add(record);
                    }
                    else if (lookupVMitem.ID > 0)
                    {
                        ProcedureDetailOption record = db.ProcedureDetailOptions.Find(lookupVMitem.ID);
                        record.ProcedureDetailOptionName    = lookupVMitem.Name;
                        record.ProcedureDetailOptionFieldID = lookupVMitem.CategoryID;
                    }
                    else
                    {
                        return(View("Error"));
                    }
                    db.SaveChanges();
                }
            }
            else if (lookuptablename == "DataEntryFields")
            {
                foreach (var lookupVMitem in lookupVM)
                {
                    if (lookupVMitem.ID == 0)
                    {
                        DataEntryField record = new DataEntryField()
                        {
                            DataEntryFieldID   = lookupVMitem.ID,
                            DataEntryFieldName = lookupVMitem.Name,
                            FieldTypeID        = lookupVMitem.CategoryID,
                        };
                        db.DataEntryFields.Add(record);
                    }
                    else if (lookupVMitem.ID > 0)
                    {
                        DataEntryField record = db.DataEntryFields.Find(lookupVMitem.ID);
                        record.DataEntryFieldName = lookupVMitem.Name;
                        record.FieldTypeID        = lookupVMitem.CategoryID;
                    }
                    else
                    {
                        return(View("Error"));
                    }
                    db.SaveChanges();
                }
            }
            else if (lookuptablename == "DataEntryOptions")
            {
                foreach (var lookupVMitem in lookupVM)
                {
                    if (lookupVMitem.ID == 0)
                    {
                        DataEntryOption record = new DataEntryOption()
                        {
                            DataEntryOptionID              = lookupVMitem.ID,
                            DataEntryOptionName            = lookupVMitem.Name,
                            DataEntryFieldDataEntryFieldID = lookupVMitem.CategoryID,
                        };
                        db.DataEntryOptions.Add(record);
                    }
                    else if (lookupVMitem.ID > 0)
                    {
                        DataEntryOption record = db.DataEntryOptions.Find(lookupVMitem.ID);
                        record.DataEntryOptionName            = lookupVMitem.Name;
                        record.DataEntryFieldDataEntryFieldID = lookupVMitem.CategoryID;
                    }
                    else
                    {
                        return(View("Error"));
                    }
                    db.SaveChanges();
                }
            }
            //else if (lookuptablename == "OptionFields")
            //{
            //    foreach (var lookupVMitem in lookupVM)
            //    {
            //        if (lookupVMitem.ID == 0)
            //        {
            //            OptionField record = new OptionField()
            //            {
            //                OptionFieldID = lookupVMitem.ID,
            //                OptionFieldName = lookupVMitem.Name,
            //            };
            //            db.OptionFields.Add(record);
            //        }
            //        else if (lookupVMitem.ID > 0)
            //        {
            //            OptionField record = db.OptionFields.Find(lookupVMitem.ID);
            //            record.OptionFieldName = lookupVMitem.Name;

            //        }
            //        else
            //        {
            //            return View("Error");
            //        }
            //        db.SaveChanges();
            //    }
            //}
            //else if (lookuptablename == "Options")
            //{
            //    foreach (var lookupVMitem in lookupVM)
            //    {
            //        if (lookupVMitem.ID == 0)
            //        {
            //            Option record = new Option()
            //            {
            //                OptionID = lookupVMitem.ID,
            //                OptionValue = lookupVMitem.Name,
            //                OptionFieldOptionFieldID = lookupVMitem.CategoryID,
            //            };
            //            db.Options.Add(record);
            //        }
            //        else if (lookupVMitem.ID > 0)
            //        {
            //            Option record = db.Options.Find(lookupVMitem.ID);
            //            record.OptionValue = lookupVMitem.Name;
            //            record.OptionFieldOptionFieldID = lookupVMitem.CategoryID;
            //        }
            //        else
            //        {
            //            return View("Error");
            //        }
            //        db.SaveChanges();
            //    }
            //}

            return(RedirectToAction("Index", new { lookuptablename = lookuptablename }));
        }
Example #10
0
        public ActionResult Index(int procedureid, int projectid, IEnumerable <ProcedureDetailViewModel> ProcedureDetailVM)
        {
            if (!_projectuservalidationservice.UserCanEditProject(projectid))
            {
                ViewBag.ErrorMessage = "Access Denied. Please contact administrator for further assistance.";
                return(View("Error"));
            }

            var userKey = (int)Membership.GetUser().ProviderUserKey;

            if (!ModelState.IsValid)
            {
                return(RedirectToAction("Index", new { procedureid = procedureid, projectid = projectid }));
            }

            Procedure procedure = GetValidProcedure(procedureid);

            if (procedure == null)
            {
                return(HttpNotFound());
            }

            foreach (var eachProcedureDetail in ProcedureDetailVM)
            {
                if (!ProcedureDetailFieldIsValid(eachProcedureDetail.FieldID))
                {
                    ViewBag.ErrorMessage = "Data conflicts occurred. Please contact administrator for further assistance.";
                    return(View("Error"));
                }
                ;

                if (eachProcedureDetail.FieldType == EntryFieldType.Lookup.ToString() && eachProcedureDetail.Multiple == false)
                {
                    // the procedure details with the same fields
                    var ExistingProceduredetails = db.ProcedureDetails.Where(pd => pd.ProcedureDetailOptionFieldID == eachProcedureDetail.FieldID && pd.ProcedureProcedureID == procedureid);

                    foreach (var proceduredetail in ExistingProceduredetails)
                    {
                        if (proceduredetail.Status != "Deleted")
                        {
                            proceduredetail.Status        = "Deleted";
                            proceduredetail.LastUpdatedBy = userKey;
                        }
                    }
                    if (eachProcedureDetail.OptionID > 0)
                    {
                        // procedure details with the same field and same option
                        var ExistingProceduredetail = ExistingProceduredetails.Where(pd => pd.ProcedureDetailOptionID == eachProcedureDetail.OptionID);

                        if (ExistingProceduredetail.Count() == 0)
                        {
                            ProcedureDetail Newproceduredetail = new ProcedureDetail()
                            {
                                ProcedureProcedureID         = eachProcedureDetail.ProcedureID,
                                ProcedureDetailOptionFieldID = eachProcedureDetail.FieldID,
                                ProcedureDetailOptionID      = eachProcedureDetail.OptionID,

                                LastUpdatedBy = userKey,
                            };
                            db.ProcedureDetails.Add(Newproceduredetail);
                        }
                        else
                        {
                            ExistingProceduredetail.FirstOrDefault().Status        = "Current";
                            ExistingProceduredetail.FirstOrDefault().LastUpdatedBy = userKey;
                        }
                    }
                }

                if (eachProcedureDetail.FieldType == EntryFieldType.Lookup.ToString() && eachProcedureDetail.Multiple == true)
                {
                    var ExistingProceduredetails = db.ProcedureDetails.Where(pd => pd.ProcedureDetailOptionFieldID == eachProcedureDetail.FieldID && pd.ProcedureProcedureID == procedureid);

                    foreach (var proceduredetail in ExistingProceduredetails)
                    {
                        proceduredetail.Status        = "Deleted";
                        proceduredetail.LastUpdatedBy = userKey;
                    }

                    if (eachProcedureDetail.OptionIDs != null)
                    {
                        foreach (var optionID in eachProcedureDetail.OptionIDs)
                        {
                            var ExistingProceduredetail = ExistingProceduredetails.Where(pd => pd.ProcedureDetailOptionID == optionID);

                            if (ExistingProceduredetail.Count() == 0)
                            {
                                ProcedureDetail procedureDetail = new ProcedureDetail
                                {
                                    ProcedureDetailOptionFieldID = eachProcedureDetail.FieldID,
                                    ProcedureProcedureID         = eachProcedureDetail.ProcedureID,
                                    ProcedureDetailOptionID      = optionID,

                                    LastUpdatedBy = userKey,
                                };

                                db.ProcedureDetails.Add(procedureDetail);
                            }
                            else
                            {
                                ExistingProceduredetail.FirstOrDefault().Status        = "Current";
                                ExistingProceduredetail.FirstOrDefault().LastUpdatedBy = userKey;
                            }
                        }
                    }
                }
                else if (eachProcedureDetail.FieldType != EntryFieldType.Lookup.ToString())
                {
                    var ExistingProceduredetails = db.ProcedureDetails.Where(pd => pd.ProcedureDetailOptionFieldID == eachProcedureDetail.FieldID && pd.ProcedureProcedureID == procedureid);

                    //set everything to "Deleted" as a reset before adding new values
                    foreach (var proceduredetail in ExistingProceduredetails)
                    {
                        proceduredetail.Status        = "Deleted";
                        proceduredetail.LastUpdatedBy = userKey;
                    }
                    if (eachProcedureDetail.Value != null)
                    {
                        if (ExistingProceduredetails.Count() == 0)
                        {
                            ProcedureDetail proceduredetail = new ProcedureDetail()
                            {
                                ProcedureProcedureID         = eachProcedureDetail.ProcedureID,
                                ProcedureDetailValue         = eachProcedureDetail.Value,
                                ProcedureDetailOptionFieldID = eachProcedureDetail.FieldID,

                                LastUpdatedBy = (int)Membership.GetUser().ProviderUserKey,
                            };
                            db.ProcedureDetails.Add(proceduredetail);
                        }
                        else
                        {
                            ExistingProceduredetails.FirstOrDefault().ProcedureDetailValue = eachProcedureDetail.Value;
                            ExistingProceduredetails.FirstOrDefault().Status        = "Current";
                            ExistingProceduredetails.FirstOrDefault().LastUpdatedBy = userKey;
                        }
                    }
                }
            }

            db.SaveChanges();

            //      ViewBag.UpdatedMessage = "Information Updated";

            return(RedirectToAction("Details", "MultiPARTProject", new { projectid = projectid }));
        }