Example #1
0
        // GET: Workers
        //public async Task<IActionResult> Index()
        //{
        //    var dentalClinicDBContext = _context.Workers.Include(w => w.Office).Include(w => w.Position);
        //    return View(await dentalClinicDBContext.ToListAsync());
        //}
        //GET: Workers
        public async Task <IActionResult> Index(string firstName, string lastName, WorkerSortState sortOrder = WorkerSortState.FirstNameAsc)
        {
            var workers = _context.Workers.Select(x => x);

            //var workers = from m in _context.Workers
            //             select m;

            if (!String.IsNullOrEmpty(firstName))
            {
                workers = workers.Where(w => w.FirstName == firstName);
            }
            if (!String.IsNullOrEmpty(lastName))
            {
                workers = workers.Where(w => w.LastName == lastName);
            }

            ViewData["FirstNameSort"] = sortOrder == WorkerSortState.FirstNameAsc ? WorkerSortState.FirstNameDesc : WorkerSortState.FirstNameAsc;
            ViewData["LastNameSort"]  = sortOrder == WorkerSortState.LastNameAsc ? WorkerSortState.LastNameDesc : WorkerSortState.LastNameAsc;
            ViewData["OfficeSort"]    = sortOrder == WorkerSortState.OfficeAsc ? WorkerSortState.OfficeDesc : WorkerSortState.OfficeAsc;

            workers = sortOrder switch
            {
                WorkerSortState.FirstNameDesc => workers.OrderByDescending(s => s.FirstName),
                WorkerSortState.LastNameAsc => workers.OrderBy(s => s.LastName),
                WorkerSortState.LastNameDesc => workers.OrderByDescending(s => s.LastName),
                WorkerSortState.OfficeAsc => workers.OrderBy(s => s.Office.Address),
                WorkerSortState.OfficeDesc => workers.OrderByDescending(s => s.Office.Address),
                _ => workers.OrderBy(s => s.FirstName),
            };

            return(View(await workers.Include(w => w.Office).ThenInclude(c => c.City).Include(w => w.Position).ToListAsync()));
        }
        public async Task <IActionResult> Index(string fio, int page = 1, WorkerSortState sortOrder = WorkerSortState.FIOAsc)
        {
            int pageSize = 5;

            //фильтрация
            IQueryable <Worker> workers = db.Workers;

            if (!string.IsNullOrEmpty(fio))
            {
                workers = workers.Where(p => p.WorkerFIO.Contains(fio));
            }

            // сортировка
            switch (sortOrder)
            {
            case WorkerSortState.FIODesc:
                workers = workers.OrderByDescending(s => s.WorkerFIO);
                break;

            case WorkerSortState.PostAsc:
                workers = workers.OrderBy(s => s.WorkerPost);
                break;

            case WorkerSortState.PostDesc:
                workers = workers.OrderByDescending(s => s.WorkerPost);
                break;

            default:
                workers = workers.OrderBy(s => s.WorkerFIO);
                break;
            }

            // пагинация
            var count = await workers.CountAsync();

            var items = await workers.Skip((page - 1) *pageSize).Take(pageSize).ToListAsync();

            // формируем модель представления
            WorkersViewModel viewModel = new WorkersViewModel
            {
                PageViewModel         = new PageViewModel(count, page, pageSize),
                WorkerSortViewModel   = new WorkerSortViewModel(sortOrder),
                WorkerFilterViewModel = new WorkerFilterViewModel(fio),
                Workers = items
            };

            return(View(viewModel));
        }
 public WorkerSortViewModel(WorkerSortState sortOrder)
 {
     FIOSort  = sortOrder == WorkerSortState.FIOAsc ? WorkerSortState.FIODesc : WorkerSortState.FIOAsc;
     PostSort = sortOrder == WorkerSortState.PostAsc ?WorkerSortState.PostDesc : WorkerSortState.PostAsc;
     Current  = sortOrder;
 }