public async Task <ActionResult> RemoveGroup(Guid GroupId)
        {
            GNAnalysisRequestGroup Group = db.GNAnalysisRequestGroups.Where(a => a.Id.Equals(GroupId)).FirstOrDefault();

            ((AnalysisRequestService)entityService).DeleteAnalysisRequestGroup(Group);

            return(RedirectToAction("Details", "AnalysisRequests", new { id = Request["analysisRequestId"] }));
        }
        public async Task <ActionResult> AddNewGroup(Guid analysisRequestId)
        {
            var newGroupName = Request["NewGroupName"];
            GNAnalysisRequestGroup GNGroup = new GNAnalysisRequestGroup();

            GNGroup.Id                  = Guid.NewGuid();
            GNGroup.Name                = newGroupName;
            GNGroup.CreateDateTime      = DateTime.Now;
            GNGroup.CreatedBy           = UserContact.Id;
            GNGroup.GNAnalysisRequestId = analysisRequestId;

            ((AnalysisRequestService)entityService).CreateAnalysisRequestGroup(analysisRequestId, GNGroup);

            return(RedirectToAction("Details", "AnalysisRequests", new { id = Request["analysisRequestId"] }));
        }
        public override async Task <List <GNSample> > FindAll(GNContact userContact, int start = 0, int end = 10, Dictionary <string, object> filters = null)
        {
            LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());

            IQueryable <GNSample> samples       = null;
            IQueryable <GNSample> samplesResult = null;

            //Filter by Role
            //GN_ADMIN
            if (aspNetRoleService.IsUserContactAdmin(userContact))
            {
                samples = db.GNSamples
                          .Include(s => s.Organization);
            }
            //ORG_MANAGER, TEAM_MANAGER, PROJECT_MANAGER, TEAM_MEMBER
            else
            {
                samples = db.GNSamples
                          .Include(s => s.Organization)
                          .Where(s => s.GNOrganizationId == userContact.GNOrganizationId);
            }
            samplesResult = samples;

            //Filter by Filter Keys
            if (filters != null && filters.Count != 0)
            {
                string filterVal = null;

                if (filters.ContainsKey("Organization"))
                {
                    filterVal     = (string)filters["Organization"];
                    samplesResult = samplesResult.Where(t => t.Organization.Name.Contains(filterVal));
                }

                if (filters.ContainsKey("Sample Name"))
                {
                    filterVal     = (string)filters["Sample Name"];
                    samplesResult = samplesResult.Where(t => t.Name.ToUpper().Contains(filterVal.ToUpper()));
                }

                if (filters.ContainsKey("Sample Type"))
                {
                    filterVal     = (string)filters["Sample Type"];
                    samplesResult = samplesResult.Where(t => t.SampleType.Name.Contains(filterVal));
                }

                if (filters.ContainsKey("Gender"))
                {
                    filterVal     = (string)filters["Gender"];
                    samplesResult = samplesResult.Where(t => t.Gender.Equals(filterVal));
                }

                if (filters.ContainsKey("GNSampleTypeId"))
                {
                    var intFilter = Convert.ToInt32(filters["GNSampleTypeId"]);
                    samplesResult = samplesResult.Where(t => t.SampleType.Id.Equals(intFilter));
                }

                if (filters.ContainsKey("GNSampleQualifierCode"))
                {
                    filterVal     = (string)filters["GNSampleQualifierCode"];
                    samplesResult = samplesResult.Where(t => t.GNSampleQualifierCode.Equals(filterVal));
                }

                if (filters.ContainsKey("GroupId"))
                {
                    var guidFilter = Guid.Parse(filters["GroupId"].ToString());
                    GNAnalysisRequestGroup Group = db.GNAnalysisRequestGroups.Where(a => a.Id.Equals(guidFilter)).FirstOrDefault();
                    samplesResult = samplesResult.Where(t => t.GNAnalysisRequestGroups.Contains(Group));
                }

                if (filters.ContainsKey("CreatedBy"))
                {
                    var guidFilter = Guid.Parse(filters["CreatedBy"].ToString());
                    samplesResult = samplesResult.Where(t => t.CreatedBy == guidFilter);
                }

                if (filters.ContainsKey("IsReady"))
                {
                    bool boolFilter = true;
                    filterVal = (string)filters["IsReady"];
                    if (filterVal == "N")
                    {
                        boolFilter = false;
                    }

                    samplesResult = samplesResult.Where(t => t.IsReady == boolFilter);
                }

                if (filters.ContainsKey("GNOrganizationId"))
                {
                    var guidFilter = Guid.Parse((string)filters["GNOrganizationId"]);
                    samplesResult = samplesResult.Where(t => t.Organization.Id.Equals(guidFilter));
                }

                if (filters.ContainsKey("GNLeftSampleId"))
                {
                    var guidFilter = Guid.Parse((string)filters["GNLeftSampleId"]);
                    samplesResult = samplesResult.Where(t => t.Id.Equals(guidFilter) == false); // && !this.FindNeedleInHaystack(t));
                }



                if (filters.ContainsKey("All"))
                {
                    filterVal     = (string)filters["All"];
                    samplesResult = samplesResult
                                    .Where(t => t.Name.Contains(filterVal) ||
                                           t.Organization.Name.Contains(filterVal) ||
                                           t.SampleType.Name.Contains(filterVal));
                }
            }

            //Order By Results
            samplesResult = samplesResult
                            .OrderBy(t => t.SampleType.Name)
                            .OrderBy(t => t.Name)
                            .OrderBy(t => t.Organization.Name)
                            .OrderByDescending(t => t.CreateDateTime);

            //Limit Result Size
            samplesResult = samplesResult.Skip(start).Take(end - start);


            return(EvalEntityListSecurity(userContact, await samplesResult.ToListAsync()));
        }