コード例 #1
0
        public IActionResult Index(SortState sortState = SortState.FullNameAsc, int page = 1)
        {
            StaffFilterViewModel filter = HttpContext.Session.Get <StaffFilterViewModel>(filterKey);

            if (filter == null)
            {
                filter = new StaffFilterViewModel {
                    FullName = string.Empty, StaffAge = 0, StaffFunction = string.Empty, WorkingHoursForAweek = 0
                };
                HttpContext.Session.Set(filterKey, filter);
            }

            string modelKey = $"{typeof(Staff).Name}-{page}-{sortState}-{filter.FullName}-{filter.StaffAge}-{filter.StaffFunction}-{filter.WorkingHoursForAweek}";

            if (!cache.TryGetValue(modelKey, out StaffViewModel model))
            {
                model = new StaffViewModel();

                IQueryable <Staff> staff = GetSortedEntities(sortState, filter.FullName, filter.StaffAge, filter.StaffFunction, filter.WorkingHoursForAweek);

                int count    = staff.Count();
                int pageSize = 10;
                model.PageViewModel = new PageViewModel(count, page, pageSize);

                model.Staffs               = count == 0 ? new List <Staff>() : staff.Skip((model.PageViewModel.PageNumber - 1) * pageSize).Take(pageSize).ToList();
                model.SortViewModel        = new SortViewModel(sortState);
                model.StaffFilterViewModel = filter;

                cache.Set(modelKey, model);
            }

            return(View(model));
        }
コード例 #2
0
        public IActionResult Index(StaffViewModel filterModel, string positionName)
        {
            StaffFilterViewModel filter;

            if (!string.IsNullOrEmpty(positionName))
            {
                filter = new StaffFilterViewModel {
                    PositionName = positionName
                };
                HttpContext.Session.Set(filterKey, filter);

                return(RedirectToAction("Index", new { page = 1 }));
            }

            filter = HttpContext.Session.Get <StaffFilterViewModel>(filterKey);
            if (filter != null)
            {
                filter.FullName     = filterModel.StaffFilterViewModel.FullName;
                filter.PositionName = filterModel.StaffFilterViewModel.PositionName;

                HttpContext.Session.Remove(filterKey);
                HttpContext.Session.Set(filterKey, filter);
            }

            return(RedirectToAction("Index", new { page = 1 }));
        }
コード例 #3
0
        public IActionResult Index(SortState sortState = SortState.StaffFullNameAsc, int page = 1)
        {
            StaffFilterViewModel filter = HttpContext.Session.Get <StaffFilterViewModel>(filterKey);

            if (filter == null)
            {
                filter = new StaffFilterViewModel {
                    FullName = string.Empty, PositionName = string.Empty
                };
                HttpContext.Session.Set(filterKey, filter);
            }

            string modelKey = $"{typeof(Staff).Name}-{page}-{sortState}-{filter.FullName}-{filter.PositionName}";

            if (!cache.TryGetValue(modelKey, out StaffViewModel model))
            {
                model = new StaffViewModel();

                IQueryable <Staff> Staff = GetSortedEntities(sortState, filter);

                int count    = Staff.Count();
                int pageSize = 10;
                model.PageViewModel = new PageViewModel(page, count, pageSize);

                model.Entities             = count == 0 ? new List <Staff>() : Staff.Skip((model.PageViewModel.CurrentPage - 1) * pageSize).Take(pageSize).ToList();
                model.SortViewModel        = new SortViewModel(sortState);
                model.StaffFilterViewModel = filter;

                cache.Set(modelKey, model);
            }

            return(View(model));
        }
コード例 #4
0
        private IQueryable <Staff> GetSortedEntities(SortState sortState, StaffFilterViewModel filterModel)
        {
            IQueryable <Staff> Staff = db.Staff.Include(s => s.Position).AsQueryable();

            switch (sortState)
            {
            case SortState.StaffFullNameAsc:
                Staff = Staff.OrderBy(s => s.FullName);
                break;

            case SortState.StaffFullNameDesc:
                Staff = Staff.OrderByDescending(s => s.FullName);
                break;

            case SortState.PositionsNameAsc:
                Staff = Staff.OrderBy(s => s.Position.Name);
                break;

            case SortState.PositionsNameDesc:
                Staff = Staff.OrderByDescending(s => s.Position.Name);
                break;
            }

            if (!string.IsNullOrEmpty(filterModel.FullName))
            {
                Staff = Staff.Where(s => s.FullName.Contains(filterModel.FullName)).AsQueryable();
            }
            if (!string.IsNullOrEmpty(filterModel.PositionName))
            {
                Staff = Staff.Where(s => s.Position.Name.Contains(filterModel.PositionName)).AsQueryable();
            }

            return(Staff);
        }
コード例 #5
0
        // GET: Staff
        public async Task <IActionResult> Index(SortState sortState, int page = 1)
        {
            StaffFilterViewModel filter = HttpContext.Session.Get <StaffFilterViewModel>(filterKey);

            if (filter == null)
            {
                filter = new StaffFilterViewModel
                {
                    Info   = string.Empty,
                    Reward = string.Empty
                };
                HttpContext.Session.Set(filterKey, filter);
            }

            string key = $"{typeof(Staff).Name}-{page}-{sortState}-{filter.Info}-{filter.Reward}";

            if (!_cache.TryGetValue(key, out StaffViewModel model))
            {
                model = new StaffViewModel();

                IQueryable <Staff> staff = GetSortedStaff(sortState, filter.Info, filter.Reward);

                int count = staff.Count();

                model.PageViewModel = new PageViewModel(page, count, pageSize);

                model.Staffs               = count == 0 ? new List <Staff>() : staff.Skip((model.PageViewModel.PageIndex - 1) * pageSize).Take(pageSize).ToList();
                model.SortViewModel        = new SortViewModel(sortState);
                model.StaffFilterViewModel = filter;

                _cache.Set(key, model);
            }

            return(View(model));
        }
コード例 #6
0
        public ActionResult SaveFilter(StaffFilterViewModel model)
        {
            var handle = new FilterHandlerJSON();

            if (model.Filter.FilterID == null || (ValidateSave(model.Filter.FilterName) as ContentResult).Content.Equals("true"))
            {
                handle.AddModel(model.Filter);
            }
            else
            {
                handle.UpdateModel(model.Filter);
            }

            return(RedirectToAction("ApplyFilter", model.Filter));
        }
コード例 #7
0
        public IActionResult Index(StaffFilterViewModel filterModel, int page)
        {
            StaffFilterViewModel filter = HttpContext.Session.Get <StaffFilterViewModel>(filterKey);

            if (filter != null)
            {
                filter.Info   = filterModel.Info;
                filter.Reward = filterModel.Reward;

                HttpContext.Session.Remove(filterKey);
                HttpContext.Session.Set(filterKey, filter);
            }

            return(RedirectToAction("Index", new { page }));
        }
コード例 #8
0
        public IActionResult Index(StaffFilterViewModel filterModel, int page)
        {
            StaffFilterViewModel filter = HttpContext.Session.Get <StaffFilterViewModel>(filterKey);

            if (filter != null)
            {
                filter.FullName             = filterModel.FullName;
                filter.StaffAge             = filterModel.StaffAge;
                filter.StaffFunction        = filterModel.StaffFunction;
                filter.WorkingHoursForAweek = filterModel.WorkingHoursForAweek;

                HttpContext.Session.Remove(filterKey);
                HttpContext.Session.Set(filterKey, filter);
            }

            return(RedirectToAction("Index", new { page }));
        }
コード例 #9
0
        public ActionResult ApplyFilter(Filter Model)
        {
            ViewBag.LoggedUser = HttpContext.Session.GetString("LogUserName");
            ViewBag.AccessRole = HttpContext.Session.GetString("AccessRole");
            String sql        = BuildSQLFromFilter(Model);
            var    parameters = BuildParamsFromFilter(Model);

            var returnModel = new StaffFilterViewModel();

            using (var con = DBHandler.GetSqlConnection())
            {
                var staffMembers = new List <StaffMember>();
                con.Query <StaffMember, Position, Center, Education, CertCompletion, Certification, string, StaffMember>(sql, (staff, pos, center, edu, certCompleted, cert, requiredCerts) =>
                {
                    int foundStaff = staffMembers.FindIndex(s => s.StaffMemberID == staff.StaffMemberID);
                    if (foundStaff == -1)
                    {
                        if (pos != null)
                        {
                            staff.Positions.Add(pos);
                        }
                        if (center != null)
                        {
                            staff.Center = center;
                        }
                        if (edu != null)
                        {
                            staff.Education.Add(edu);
                        }
                        if (requiredCerts != null)
                        {
                            var reqCerts = new List <int>();
                            var temp     = JsonConvert.DeserializeObject <List <Dictionary <string, int> > >(requiredCerts);
                            temp.ForEach(f => reqCerts.Add(f.FirstOrDefault().Value));

                            foreach (int reqCert in reqCerts)
                            {
                                staff.CompletedCerts.Add(new CertCompletion
                                {
                                    Cert = new Certification {
                                        CertificationID = reqCert
                                    },
                                    IsRequired     = true,
                                    CertInProgress = false
                                });
                            }
                        }

                        if (certCompleted != null && cert != null)
                        {
                            bool found = false;
                            for (int i = 0; i < staff.CompletedCerts.Count; i++)
                            {
                                if (staff.CompletedCerts[i].Cert.CertificationID == cert.CertificationID)
                                {
                                    staff.CompletedCerts[i].Cert           = cert;
                                    staff.CompletedCerts[i].DateCompleted  = certCompleted.DateCompleted;
                                    staff.CompletedCerts[i].CertInProgress = certCompleted.CertInProgress;
                                    if (certCompleted.DateCompleted.HasValue)
                                    {
                                        staff.CompletedCerts[i].ExpireDate      = certCompleted.DateCompleted.Value.AddMonths(cert.CertExpireAmount);
                                        staff.CompletedCerts[i].DaysUntilExpire = (staff.CompletedCerts[i].ExpireDate - DateTime.Now).Value.Days;
                                    }

                                    found = true;
                                    break;
                                }
                            }

                            if (!found)
                            {
                                certCompleted.Cert = cert;

                                if (certCompleted.DateCompleted.HasValue)
                                {
                                    certCompleted.ExpireDate      = certCompleted.DateCompleted.Value.AddMonths(cert.CertExpireAmount);
                                    certCompleted.DaysUntilExpire = (certCompleted.ExpireDate - DateTime.Now).Value.Days;
                                }

                                certCompleted.IsRequired = false;
                                staff.CompletedCerts.Add(certCompleted);
                            }
                        }
                        staffMembers.Add(staff);
                    }
                    else
                    {
                        if (pos != null && !staffMembers[foundStaff].Positions.Any(p => p.PositionID == pos.PositionID))
                        {
                            staffMembers[foundStaff].Positions.Add(pos);
                        }

                        if (edu != null && !staffMembers[foundStaff].Education.Any(e => e.EducationID == edu.EducationID))
                        {
                            staffMembers[foundStaff].Education.Add(edu);
                        }

                        if (requiredCerts != null)
                        {
                            var reqCerts = new List <int>();
                            var temp     = JsonConvert.DeserializeObject <List <Dictionary <string, int> > >(requiredCerts);
                            temp.ForEach(f => reqCerts.Add(f.FirstOrDefault().Value));

                            foreach (int reqCert in reqCerts)
                            {
                                if (!staffMembers[foundStaff].CompletedCerts.Any(rq => rq.Cert.CertificationID == reqCert))
                                {
                                    staffMembers[foundStaff].CompletedCerts.Add(new CertCompletion
                                    {
                                        Cert = new Certification {
                                            CertificationID = reqCert
                                        },
                                        IsRequired     = true,
                                        CertInProgress = false
                                    });
                                }
                                else
                                {
                                    for (int i = 0; i < staffMembers[foundStaff].CompletedCerts.Count; i++)
                                    {
                                        if (staffMembers[foundStaff].CompletedCerts[i].Cert.CertificationID == reqCert)
                                        {
                                            staffMembers[foundStaff].CompletedCerts[i].IsRequired = true;
                                        }
                                    }
                                }
                            }
                        }
                        if (certCompleted != null && cert != null)
                        {
                            bool found = false;

                            for (int i = 0; i < staffMembers[foundStaff].CompletedCerts.Count; i++)
                            {
                                if (staffMembers[foundStaff].CompletedCerts[i].Cert.CertificationID == cert.CertificationID)
                                {
                                    staffMembers[foundStaff].CompletedCerts[i].Cert           = cert;
                                    staffMembers[foundStaff].CompletedCerts[i].DateCompleted  = certCompleted.DateCompleted;
                                    staffMembers[foundStaff].CompletedCerts[i].CertInProgress = certCompleted.CertInProgress;
                                    if (certCompleted.DateCompleted.HasValue)
                                    {
                                        staffMembers[foundStaff].CompletedCerts[i].ExpireDate      = certCompleted.DateCompleted.Value.AddMonths(cert.CertExpireAmount);
                                        staffMembers[foundStaff].CompletedCerts[i].DaysUntilExpire = (staffMembers[foundStaff].CompletedCerts[i].ExpireDate - DateTime.Now).Value.Days;
                                    }

                                    found = true;
                                    break;
                                }
                            }

                            if (!found)
                            {
                                certCompleted.Cert = cert;
                                if (certCompleted.DateCompleted.HasValue)
                                {
                                    certCompleted.ExpireDate      = certCompleted.DateCompleted.Value.AddMonths(cert.CertExpireAmount);
                                    certCompleted.DaysUntilExpire = (certCompleted.ExpireDate - DateTime.Now).Value.Days;
                                }

                                certCompleted.IsRequired = false;
                                staffMembers[foundStaff].CompletedCerts.Add(certCompleted);
                            }
                        }
                    }
                    return(staff);
                }, splitOn: "PositionID,CenterID,EducationID,CertInProgress,CertificationID,RequiredCerts", param: parameters);

                staffMembers = CodeFilter(staffMembers, Model);

                returnModel.StaffMembers = staffMembers;
                returnModel.Filter       = Model;
            }

            return(View("Details", returnModel));
        }