private void ValidateSublibrarySubmission(SequencingPostModel postModel)
        {
            if (!postModel.TypeOfSample.HasValue)
            {
                ModelState.AddModelError("PostModel.TypesOfSample", "Type of Sample is required.");
            }

            if (postModel.TypeOfSample == TypeOfSamples.DNA && !postModel.Concentration.HasValue)
            {
                ModelState.AddModelError("PostModel.Concentration", "DNA Concentration is required.");
            }

            if (postModel.TypeOfSample == TypeOfSamples.BAC && postModel.Vector == null)
            {
                ModelState.AddModelError("PostModel.Vector", "Vector is required.");
            }

            if (!postModel.GenomeSize.HasValue)
            {
                ModelState.AddModelError("PostModel.GenomeSize", "Genome Size is required.");
            }

            if (!postModel.Coverage.HasValue)
            {
                ModelState.AddModelError("PostModel.Coverage", "Coverage is required.");
            }

            if (postModel.Antibiotic == null)
            {
                ModelState.AddModelError("PostModel.Antibiotic", "Antibiotic is required.");
            }
        }
        private void ValidateBacterialClone(SequencingPostModel postModel)
        {
            if (postModel.PlateType == null)
            {
                ModelState.AddModelError("PostModel.PlateType", "Plate Type is required.");
            }

            if (postModel.SequenceDirection == null)
            {
                ModelState.AddModelError("PostModel.SequenceDirection", "Sequence Direction is required.");
            }

            if (postModel.Primer1 == null)
            {
                ModelState.AddModelError("PostModel.Primer1", "Primer One is required.");
            }

            if (postModel.SequenceDirection.HasValue && postModel.SequenceDirection == SequenceDirection.Backward && postModel.Primer2 == null)
            {
                ModelState.AddModelError("PostModel.Primer2", "Primer Two is required.");
            }

            if (postModel.Vector == null)
            {
                ModelState.AddModelError("PostModel.Vector", "Vector is required.");
            }

            if (postModel.Antibiotic == null)
            {
                ModelState.AddModelError("PostModel.Antibiotic", "Antibiotic is required.");
            }

            if (postModel.Strain == null)
            {
                ModelState.AddModelError("PostModel.Strain", "Host is required.");
            }

            if (postModel.Strain != null && postModel.Strain.IsOther())
            {
                if (string.IsNullOrEmpty(postModel.NewStrain))
                {
                    ModelState.AddModelError("PostModel.NewStrain", "Name for new Host is required.");
                }

                if (postModel.Bacteria == null)
                {
                    ModelState.AddModelError("PostModel.Bacteria", "Bacteria for new Host is required.");
                }
            }

            if (postModel.NumPlates <= 0)
            {
                ModelState.AddModelError("PostModel.NumPlates", "More than one plate is required.");
            }

            if (postModel.PlateNames != null && postModel.PlateNames.Count(a => !string.IsNullOrEmpty(a)) < postModel.NumPlates)
            {
                ModelState.AddModelError("PostModel.PlateNames", "Please specify a name for each plate.");
            }
        }
        private bool SaveSublibrarySubmission(SequencingPostModel postModel)
        {
            ValidateSublibrarySubmission(postModel);

            if (ModelState.IsValid)
            {
                var userJob           = new UserJob();
                var userJobSublibrary = new UserJobSublibrary();

                AutoMapper.Mapper.Map(postModel, userJob);
                AutoMapper.Mapper.Map(postModel, userJobSublibrary);
                userJob.UserJobSublibrary = userJobSublibrary;
                userJob.User            = GetCurrentUser(true);
                userJob.RechargeAccount = postModel.RechargeAccount;

                AddPlates(new List <string>()
                {
                    userJob.Name
                }, userJob, userJob.JobType);

                _repositoryFactory.UserJobRepository.EnsurePersistent(userJob);

                return(true);
            }

            return(false);
        }
        private void ValidateDnaSubmission(SequencingPostModel postModel)
        {
            if (postModel.JobType == null)
            {
                ModelState.AddModelError("PostModel.JobType", "Job Type is required.");
            }

            if (postModel.PlateType == null)
            {
                ModelState.AddModelError("PostModel.PlateType", "Plate Type is required.");
            }

            if (postModel.Primer1 == null)
            {
                ModelState.AddModelError("PostModel.Primer1", "Primer One is required.");
            }

            if (postModel.NumPlates <= 0)
            {
                ModelState.AddModelError("PostModel.NumPlates", "More than one plate is required.");
            }

            if (postModel.PlateNames != null && postModel.PlateNames.Count(a => !string.IsNullOrEmpty(a)) < postModel.NumPlates)
            {
                ModelState.AddModelError("PostModel.PlateNames", "Please specify a name for each plate.");
            }
        }
        private bool SaveBacterialClone(SequencingPostModel postModel)
        {
            ValidateBacterialClone(postModel);

            if (ModelState.IsValid)
            {
                var userJob = new UserJob();
                var userJobBacterialClone = new UserJobBacterialClone();

                AutoMapper.Mapper.Map(postModel, userJob);
                AutoMapper.Mapper.Map(postModel, userJobBacterialClone);
                userJob.UserJobBacterialClone = userJobBacterialClone;
                userJob.User            = GetCurrentUser(true);
                userJob.RechargeAccount = postModel.RechargeAccount;

                AddPlates(postModel.PlateNames, userJob, userJob.JobType);

                if (postModel.Strain != null && postModel.Strain.IsOther())
                {
                    var strain = new Strain()
                    {
                        Name = postModel.NewStrain, Bacteria = postModel.Bacteria, Supplied = false
                    };
                    userJob.UserJobBacterialClone.Strain = strain;
                }

                _repositoryFactory.UserJobRepository.EnsurePersistent(userJob);

                return(true);
            }

            return(false);
        }
        public ActionResult Create(int?id, SequencingPostModel postModel)
        {
            JobType jobType = null;

            if (id.HasValue)
            {
                jobType = _repositoryFactory.JobTypeRepository.GetNullableById(id.Value);

                // check the job type
                // 2013-01-16 by kjt: Should be all 3 types of sequencing jobs as per Jong-Min
                if (!jobType.StandardSequencing && !jobType.CustomSequencing && !jobType.DNASequencing)
                {
                    Message = "Invalid job type specified";
                    return(RedirectToAction("Create"));
                }

                // all job types are assignble except dna submission
                if (jobType.Id != (int)JobTypeIds.DnaSubmission)
                {
                    postModel.JobType = jobType;
                }
            }

            var result = false;

            switch (jobType.Id)
            {
            case (int)JobTypeIds.BacterialClone:
                result = SaveBacterialClone(postModel);
                break;

            case (int)JobTypeIds.DnaSubmission:
                result = SaveDnaSubmission(postModel);
                break;

            case (int)JobTypeIds.UserRunSequencing:
                result = SaveUserRunSubmission(postModel);
                break;

            case (int)JobTypeIds.Sublibrary:
                result = SaveSublibrarySubmission(postModel);
                break;
            }

            if (result)
            {
                Message = "Your job request has been successfully submitted.";
                return(RedirectToAction("Index", "Authorized"));
            }

            var user      = GetCurrentUser();
            var viewModel = SequencingViewModel.Create(_repositoryFactory, user, jobType, postModel);

            return(View(viewModel));
        }
        public ActionResult Create(int? id, SequencingPostModel postModel)
        {
            JobType jobType = null;
            if (id.HasValue)
            {
                jobType = _repositoryFactory.JobTypeRepository.GetNullableById(id.Value);

                // check the job type
                // 2013-01-16 by kjt: Should be all 3 types of sequencing jobs as per Jong-Min
                if (!jobType.StandardSequencing && !jobType.CustomSequencing && !jobType.DNASequencing)
                {
                    Message = "Invalid job type specified";
                    return RedirectToAction("Create");
                }

                // all job types are assignble except dna submission
                if (jobType.Id != (int)JobTypeIds.DnaSubmission)
                {
                    postModel.JobType = jobType;
                }
            }

            var result = false;

            switch(jobType.Id)
            {
                case (int)JobTypeIds.BacterialClone:
                    result = SaveBacterialClone(postModel);
                    break;
                case (int)JobTypeIds.DnaSubmission:
                    result = SaveDnaSubmission(postModel);
                    break;
                case (int)JobTypeIds.UserRunSequencing:
                    result = SaveUserRunSubmission(postModel);
                    break;
                case (int)JobTypeIds.Sublibrary:
                    result = SaveSublibrarySubmission(postModel);
                    break;
            }

            if (result)
            {
                Message = "Your job request has been successfully submitted.";
                return RedirectToAction("Index", "Authorized");
            }

            var user = GetCurrentUser();
            var viewModel = SequencingViewModel.Create(_repositoryFactory, user, jobType, postModel);
            return View(viewModel);
        }
        private bool SaveUserRunSubmission(SequencingPostModel postModel)
        {
            ValidateUserRunSubmission(postModel);

            if (ModelState.IsValid)
            {
                var userJob        = new UserJob();
                var userJobUserRun = new UserJobUserRun();

                AutoMapper.Mapper.Map(postModel, userJob);
                AutoMapper.Mapper.Map(postModel, userJobUserRun);
                userJob.UserJobUserRun  = userJobUserRun;
                userJob.User            = GetCurrentUser(true);
                userJob.RechargeAccount = postModel.RechargeAccount;

                AddPlates(postModel.PlateNames, userJob, userJob.JobType);

                _repositoryFactory.UserJobRepository.EnsurePersistent(userJob);

                return(true);
            }

            return(false);
        }
        public static SequencingViewModel Create(IRepositoryFactory repositoryFactory, User user, JobType jobType = null, SequencingPostModel postModel = null)
        {
            var viewModel = new SequencingViewModel()
                {
                    JobType = jobType,
                    JobTypes = jobType == null ? repositoryFactory.JobTypeRepository.Queryable.Where(a => a.StandardSequencing || a.CustomSequencing).ToList() : new List<JobType>(),
                    PostModel = postModel ?? new SequencingPostModel()
                };

            if (jobType != null)
            {
                var rid = postModel != null && postModel.RechargeAccount != null ? postModel.RechargeAccount.Id : -1;
                viewModel.RechargeAccounts = new SelectList(user.RechargeAccounts, "Id", "AccountNum", rid);

                // shared for bacterial clone, dna submission, user run sequencing
                if (jobType.Id == (int)JobTypeIds.BacterialClone || jobType.Id == (int)JobTypeIds.DnaSubmission || jobType.Id == (int)JobTypeIds.UserRunSequencing)
                {
                    var pts = new List<SelectListItem>();
                    pts.Add(new SelectListItem() { Value = ((int)Core.Resources.PlateTypes.NinetySix).ToString(), Text = EnumUtility.GetEnumDescription(Core.Resources.PlateTypes.NinetySix) });
                    pts.Add(new SelectListItem() { Value = ((int)Core.Resources.PlateTypes.ThreeEightyFour).ToString(), Text = EnumUtility.GetEnumDescription(Core.Resources.PlateTypes.ThreeEightyFour) });
                    viewModel.PlateTypes = new SelectList(pts, "Value", "Text");
                }

                // shared for bacterial clone, dna submission
                if (jobType.Id == (int)JobTypeIds.BacterialClone || jobType.Id == (int)JobTypeIds.DnaSubmission)
                {
                    var pid1 = postModel != null && postModel.Primer1 != null ? postModel.Primer1.Id : -1;
                    viewModel.Primers = new SelectList(repositoryFactory.PrimerRepository.Queryable.Where(a => a.Supplied), "Id", "Name", pid1);
                }

                if (jobType.Id == (int)JobTypeIds.BacterialClone || jobType.Id == (int)JobTypeIds.Sublibrary)
                {
                    var aid = postModel != null && postModel.Antibiotic != null ? postModel.Antibiotic.Id : -1;
                    viewModel.Antibiotics = new SelectList(repositoryFactory.AntibioticRepository.Queryable.OrderBy(a => a.Name), "Id", "Name", aid);

                    var vid = postModel != null && postModel.Vector != null ? postModel.Vector.Id : -1;
                    viewModel.Vectors = new SelectList(repositoryFactory.VectorRepository.Queryable.OrderByDescending(a => a.Name), "Id", "Name", vid);
                }

                // only for baacterial clone
                if (jobType.Id == (int)JobTypeIds.BacterialClone)
                {
                    var sd = new List<SelectListItem>();
                    sd.Add(new SelectListItem() { Value = ((int)SequenceDirection.Forward).ToString(), Text = EnumUtility.GetEnumDescription(SequenceDirection.Forward) });
                    sd.Add(new SelectListItem() { Value = ((int)SequenceDirection.Backward).ToString(), Text = EnumUtility.GetEnumDescription(SequenceDirection.Backward) });
                    viewModel.SequenceDirections = new SelectList(sd, "Value", "Text");

                    var sid = postModel != null && postModel.Strain != null ? postModel.Strain.Id : -1;
                    viewModel.Strains = new SelectList(repositoryFactory.StrainRepository.Queryable.Where(a => a.Supplied), "Id", "Name", sid);

                    var pid2 = postModel != null && postModel.Primer2 != null ? postModel.Primer2.Id : -1;
                    viewModel.Primers2 = new SelectList(repositoryFactory.PrimerRepository.Queryable.Where(a => a.Supplied), "Id", "Name", pid2);

                    var bid = postModel != null && postModel.Bacteria != null ? postModel.Bacteria.Id : -1;
                    viewModel.Bacterias = new SelectList(repositoryFactory.BacteriaRepository.Queryable, "Id", "Name", bid);
                }

                if (jobType.Id == (int)JobTypeIds.DnaSubmission)
                {
                    var jid = postModel != null && postModel.JobType != null ? postModel.JobType.Id : -1;
                    viewModel.DnaJobTypes = new SelectList(repositoryFactory.JobTypeRepository.Queryable.Where(a => a.DNASequencing), "Id", "Name", jid);
                }

                if (jobType.Id == (int)JobTypeIds.UserRunSequencing)
                {
                    var did = postModel != null && postModel.Dye != null ? postModel.Dye.Id : -1;
                    viewModel.Dyes = new SelectList(repositoryFactory.DyeRepository.Queryable.Where(a => a.Supplied && !a.Genotyping), "Id", "Name", did);
                }

                if (jobType.Id == (int)JobTypeIds.Sublibrary)
                {
                    var sid = postModel != null && postModel.TypeOfSample != null ? (int)postModel.TypeOfSample : -1;
                    var st = new List<SelectListItem>();
                    st.Add(new SelectListItem() {Value = ((int)Core.Resources.TypeOfSamples.BAC).ToString(), Text = EnumUtility.GetEnumDescription(Core.Resources.TypeOfSamples.BAC)});
                    st.Add(new SelectListItem() { Value = ((int)Core.Resources.TypeOfSamples.DNA).ToString(), Text = EnumUtility.GetEnumDescription(Core.Resources.TypeOfSamples.DNA) });
                    viewModel.TypeOfSamples = new SelectList(st, "Value", "Text", sid);
                }
            }

            return viewModel;
        }
        private void ValidateUserRunSubmission(SequencingPostModel postModel)
        {
            if (postModel.PlateType == null)
            {
                ModelState.AddModelError("PostModel.PlateType", "Plate Type is required.");
            }

            if (postModel.Dye == null)
            {
                ModelState.AddModelError("PostModel.Dye", "Dye is required.");
            }

            if (postModel.NumPlates <= 0)
            {
                ModelState.AddModelError("PostModel.NumPlates", "More than one plate is required.");
            }

            if (postModel.PlateNames != null && postModel.PlateNames.Count(a => !string.IsNullOrEmpty(a)) < postModel.NumPlates)
            {
                ModelState.AddModelError("PostModel.PlateNames", "Please specify a name for each plate.");
            }
        }
        private void ValidateSublibrarySubmission(SequencingPostModel postModel)
        {
            if (!postModel.TypeOfSample.HasValue)
            {
                ModelState.AddModelError("PostModel.TypesOfSample", "Type of Sample is required.");
            }

            if (postModel.TypeOfSample == TypeOfSamples.DNA && !postModel.Concentration.HasValue)
            {
                ModelState.AddModelError("PostModel.Concentration", "DNA Concentration is required.");
            }

            if (postModel.TypeOfSample == TypeOfSamples.BAC && postModel.Vector == null)
            {
                ModelState.AddModelError("PostModel.Vector", "Vector is required.");
            }

            if (!postModel.GenomeSize.HasValue)
            {
                ModelState.AddModelError("PostModel.GenomeSize", "Genome Size is required.");
            }

            if (!postModel.Coverage.HasValue)
            {
                ModelState.AddModelError("PostModel.Coverage", "Coverage is required.");
            }

            if (postModel.Antibiotic == null)
            {
                ModelState.AddModelError("PostModel.Antibiotic", "Antibiotic is required.");
            }
        }
        private void ValidateBacterialClone(SequencingPostModel postModel)
        {
            if (postModel.PlateType == null)
            {
                ModelState.AddModelError("PostModel.PlateType", "Plate Type is required.");
            }

            if (postModel.SequenceDirection == null)
            {
                ModelState.AddModelError("PostModel.SequenceDirection", "Sequence Direction is required.");
            }

            if (postModel.Primer1 == null)
            {
                ModelState.AddModelError("PostModel.Primer1", "Primer One is required.");
            }

            if (postModel.SequenceDirection.HasValue && postModel.SequenceDirection == SequenceDirection.Backward && postModel.Primer2 == null)
            {
                ModelState.AddModelError("PostModel.Primer2", "Primer Two is required.");
            }

            if (postModel.Vector == null)
            {
                ModelState.AddModelError("PostModel.Vector", "Vector is required.");
            }

            if (postModel.Antibiotic == null)
            {
                ModelState.AddModelError("PostModel.Antibiotic", "Antibiotic is required.");
            }

            if (postModel.Strain == null)
            {
                ModelState.AddModelError("PostModel.Strain", "Host is required.");
            }

            if (postModel.Strain != null && postModel.Strain.IsOther())
            {
                if (string.IsNullOrEmpty(postModel.NewStrain))
                {
                    ModelState.AddModelError("PostModel.NewStrain", "Name for new Host is required.");
                }

                if (postModel.Bacteria == null)
                {
                    ModelState.AddModelError("PostModel.Bacteria", "Bacteria for new Host is required.");
                }
            }

            if (postModel.NumPlates <= 0)
            {
                ModelState.AddModelError("PostModel.NumPlates", "More than one plate is required.");
            }

            if (postModel.PlateNames != null && postModel.PlateNames.Count(a => !string.IsNullOrEmpty(a)) < postModel.NumPlates)
            {
                ModelState.AddModelError("PostModel.PlateNames", "Please specify a name for each plate.");
            }
        }
        private bool SaveUserRunSubmission(SequencingPostModel postModel)
        {
            ValidateUserRunSubmission(postModel);

            if (ModelState.IsValid)
            {
                var userJob = new UserJob();
                var userJobUserRun = new UserJobUserRun();

                AutoMapper.Mapper.Map(postModel, userJob);
                AutoMapper.Mapper.Map(postModel, userJobUserRun);
                userJob.UserJobUserRun = userJobUserRun;
                userJob.User = GetCurrentUser(true);
                userJob.RechargeAccount = postModel.RechargeAccount;

                AddPlates(postModel.PlateNames, userJob, userJob.JobType);

                _repositoryFactory.UserJobRepository.EnsurePersistent(userJob);

                return true;
            }

            return false;
        }
        private bool SaveSublibrarySubmission(SequencingPostModel postModel)
        {
            ValidateSublibrarySubmission(postModel);

            if (ModelState.IsValid)
            {
                var userJob = new UserJob();
                var userJobSublibrary = new UserJobSublibrary();

                AutoMapper.Mapper.Map(postModel, userJob);
                AutoMapper.Mapper.Map(postModel, userJobSublibrary);
                userJob.UserJobSublibrary = userJobSublibrary;
                userJob.User = GetCurrentUser(true);
                userJob.RechargeAccount = postModel.RechargeAccount;

                AddPlates(new List<string>() {userJob.Name}, userJob, userJob.JobType);

                _repositoryFactory.UserJobRepository.EnsurePersistent(userJob);

                return true;
            }

            return false;
        }
        private bool SaveBacterialClone(SequencingPostModel postModel)
        {
            ValidateBacterialClone(postModel);

            if (ModelState.IsValid)
            {
                var userJob = new UserJob();
                var userJobBacterialClone = new UserJobBacterialClone();

                AutoMapper.Mapper.Map(postModel, userJob);
                AutoMapper.Mapper.Map(postModel, userJobBacterialClone);
                userJob.UserJobBacterialClone = userJobBacterialClone;
                userJob.User = GetCurrentUser(true);
                userJob.RechargeAccount = postModel.RechargeAccount;

                AddPlates(postModel.PlateNames, userJob, userJob.JobType);

                if (postModel.Strain != null && postModel.Strain.IsOther())
                {
                    var strain = new Strain() { Name = postModel.NewStrain, Bacteria = postModel.Bacteria, Supplied = false };
                    userJob.UserJobBacterialClone.Strain = strain;
                }

                _repositoryFactory.UserJobRepository.EnsurePersistent(userJob);

                return true;
            }

            return false;
        }