Beispiel #1
0
        // Получение списка отпусков по фильтру
        public virtual IEnumerable <AnnualLeaveDTO> Get(AnnualLeaveFilter filter)
        {
            Func <AnnualLeave, bool>  predicate = CreatePredicate(filter);
            IEnumerable <AnnualLeave> filteredSortedCollection = FilterAndSortAnnualLeaves(filter, predicate);

            InitializeMapper();
            IEnumerable <AnnualLeaveDTO> collection = Mapper.Map <IEnumerable <AnnualLeave>, IEnumerable <AnnualLeaveDTO> >(filteredSortedCollection);

            return(collection);
        }
        public ActionResult Index(AnnualLeaveFilter filter, string filterAsJsonString, int page = 1)
        {
            if (filterAsJsonString != null)
            {
                filter = System.Web.Helpers.Json.Decode <AnnualLeaveFilter>(filterAsJsonString);
            }
            IEnumerable <AnnualLeaveDTO> alDto = (_annualLeaveService as AnnualLeaveService).Get(filter); // Filter

            alDto = _annualLeaveService.GetPage(alDto, page);                                             // Paging
            InitializeMapper();
            IEnumerable <AnnualLeaveViewModel> annualLeaves = Mapper.Map <IEnumerable <AnnualLeaveDTO>, IEnumerable <AnnualLeaveViewModel> >(alDto);
            AnnualLeaveListViewModel           model        = new AnnualLeaveListViewModel {
                AnnualLeaves = annualLeaves,
                Filter       = filter,
                PageInfo     = _annualLeaveService.PageInfo
            };

            if (Request.Headers["X-Requested-With"] == "XMLHttpRequest")
            {
                _logger.Info("Executed async request");
                var transformModel = new {
                    AnnualLeaves = model.AnnualLeaves.Select(al => new {
                        al.Id,
                        al.ScheduledNumberOfDays,
                        al.ActualNumberOfDays,
                        ScheduledDate = al.ScheduledDate.ToString("dd MMMM yyyy"),
                        ActualDate    = al.ActualDate.HasValue ? al.ActualDate.Value.ToString("dd MMMM yyyy") : "",
                        EmployeeName  = new System.Text.StringBuilder(al.Employee.LastName).Append(" ")
                                        .Append(al.Employee.FirstName).Append(" ").Append(al.Employee.Patronymic ?? "").ToString(),
                        PostTitle           = al.Employee.Post.Title,
                        NumberOfDaysOfLeave = al.Employee.Post.NumberOfDaysOfLeave,
                        DepartmentName      = al.Employee.Post.Department.DepartmentName
                    }).ToArray(),
                    model.Filter,
                    model.PageInfo
                };
                return(Json(transformModel, JsonRequestBehavior.AllowGet));
            }
            _logger.Info("Executed sync request");
            return(View("Index", model));
        }
Beispiel #3
0
        private IEnumerable <AnnualLeave> FilterAndSortAnnualLeaves(AnnualLeaveFilter filter, Func <AnnualLeave, bool> predicate)
        {
            IEnumerable <AnnualLeave> filteredSortedCollection;
            // Параметры сортировки
            string sortField = filter.SortField ?? "Default";
            string order     = filter.SortOrder ?? "Asc";
            // Компараторы сортировки по возрастанию или по убыванию
            IComparer <string> stringComparer = Comparer <string> .Create((x, y) => order.Equals("Asc")?(x ?? "").CompareTo(y ?? "") : (y ?? "").CompareTo(x ?? ""));

            IComparer <DateTime> dateTimeComparer = Comparer <DateTime> .Create((x, y) => order.Equals("Asc")?x.CompareTo(y) : y.CompareTo(x));

            IComparer <int> intComparer = Comparer <int> .Create((x, y) => order.Equals("Asc")?x.CompareTo(y) : y.CompareTo(x));

            switch (sortField)
            {
            case "Name":
                filteredSortedCollection = Database.AnnualLeaves.Get(predicate).OrderBy(al => al.Employee.LastName + " " + al.Employee.FirstName +
                                                                                        (!string.IsNullOrWhiteSpace(al.Employee.Patronymic) ? " " + al.Employee.Patronymic : ""), stringComparer); break;

            case "PostTitle": filteredSortedCollection = Database.AnnualLeaves.Get(predicate).OrderBy(al => al.Employee.Post.Title, stringComparer); break;

            case "DepartmentName": filteredSortedCollection = Database.AnnualLeaves.Get(predicate).OrderBy(al => al.Employee.Post.Department.DepartmentName, stringComparer); break;

            case "ScheduledDate": filteredSortedCollection = Database.AnnualLeaves.Get(predicate).OrderBy(al => al.ScheduledDate.Value, dateTimeComparer); break;

            case "ActualDate": filteredSortedCollection = Database.AnnualLeaves.Get(predicate).OrderBy(al => al.ActualDate.Value, dateTimeComparer); break;

            case "NumberOfDaysOfLeave": filteredSortedCollection = Database.AnnualLeaves.Get(predicate).OrderBy(al => al.Employee.Post.NumberOfDaysOfLeave, intComparer); break;

            case "ScheduledNumberOfDays": filteredSortedCollection = Database.AnnualLeaves.Get(predicate).OrderBy(al => al.ScheduledNumberOfDays.Value, intComparer); break;

            case "ActualNumberOfDays": filteredSortedCollection = Database.AnnualLeaves.Get(predicate).OrderBy(al => al.ActualNumberOfDays.Value, intComparer); break;

            default:
                filteredSortedCollection = Database.AnnualLeaves.Get(predicate).OrderBy(al => al.Employee.LastName + " " + al.Employee.FirstName +
                                                                                        (!string.IsNullOrWhiteSpace(al.Employee.Patronymic) ? " " + al.Employee.Patronymic : "")); break;
            }
            return(filteredSortedCollection);
        }
Beispiel #4
0
        private Func <AnnualLeave, bool> CreatePredicate(AnnualLeaveFilter filter)
        {
            bool predicate(AnnualLeave annualLeave)
            {
                bool returnValue = false;

                if (filter.IsAntiFilter)            // Если флаг установлен, то выбираются записи несоответствующие фильтру
                {
                    returnValue = true;
                }

                // Фильтр по ФИО сотрудника
                if (filter.Name != null)
                {
                    string[] nameArray = filter.Name.Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();   // Удаляем пустые элементы из массива
                    if (nameArray.Length > 0)
                    {
                        bool flag = true;
                        foreach (string name in nameArray)
                        {
                            string fio = annualLeave.Employee.LastName + " " + annualLeave.Employee.FirstName +
                                         (!string.IsNullOrWhiteSpace(annualLeave.Employee.Patronymic) ? " " + annualLeave.Employee.Patronymic : "");
                            if (Regex.IsMatch(fio, name, RegexOptions.IgnoreCase))
                            {
                                flag = false;
                                break;
                            }
                        }
                        if (flag)
                        {
                            return(returnValue);     // Проверяемая запись не соответствует фильтру по ФИО сотрудника
                        }
                    }
                }

                // Фильтр по названию должности
                if (filter.PostTitle != null)
                {
                    string[] postTitleArray = filter.PostTitle.Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();   // Удаляем пустые элементы из массива
                    if (postTitleArray.Length > 0)
                    {
                        bool flag = true;
                        foreach (string postTitle in postTitleArray)
                        {
                            if (Regex.IsMatch(annualLeave.Employee.Post.Title, postTitle, RegexOptions.IgnoreCase))
                            {
                                flag = false;
                                break;
                            }
                        }
                        if (flag)
                        {
                            return(returnValue);     // Проверяемая запись не соответствует фильтру по названию должности
                        }
                    }
                }

                // Фильтр по названию отдела
                if (filter.DepartmentName != null)
                {
                    string[] departmentNameArray = filter.DepartmentName.Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();   // Удаляем пустые элементы из массива
                    if (departmentNameArray.Length > 0)
                    {
                        bool flag = true;
                        foreach (string name in departmentNameArray)
                        {
                            if (Regex.IsMatch(annualLeave.Employee.Post.Department.DepartmentName, name, RegexOptions.IgnoreCase))
                            {
                                flag = false;
                                break;
                            }
                        }
                        if (flag)
                        {
                            return(returnValue);     // Проверяемая запись не соответствует фильтру по названию отдела
                        }
                    }
                }

                // Фильтр по запланированной дате отпуска
                if (!string.IsNullOrWhiteSpace(filter.ScheduledDate) && DateTime.TryParse(filter.ScheduledDate, out DateTime scheduledDate) && annualLeave.ScheduledDate != scheduledDate)
                {
                    return(returnValue);             // Проверяемая запись не соответствует фильтру по запланированной дате отпуска
                }
                // Фильтр по фактической дате отпуска
                if (!string.IsNullOrWhiteSpace(filter.ActualDate) && DateTime.TryParse(filter.ActualDate, out DateTime actualDate) && annualLeave.ActualDate != actualDate)
                {
                    return(returnValue);             // Проверяемая запись не соответствует фильтру по фактической дате отпуска
                }
                // Фильтры по общему количеству дней отпуска за год
                if (filter.MinNumberOfDaysOfLeave.HasValue && annualLeave.Employee.Post.NumberOfDaysOfLeave < filter.MinNumberOfDaysOfLeave.Value)
                {
                    return(returnValue);             // Проверяемая запись не соответствует фильтру по общему количеству дней отпуска за год
                }
                if (filter.MaxNumberOfDaysOfLeave.HasValue && annualLeave.Employee.Post.NumberOfDaysOfLeave > filter.MaxNumberOfDaysOfLeave.Value)
                {
                    return(returnValue);             // Проверяемая запись не соответствует фильтру по общему количеству дней отпуска за год
                }
                // Фильтры по запланированному количеству дней отпуска
                if (filter.MinScheduledNumberOfDays.HasValue && annualLeave.ScheduledNumberOfDays.HasValue && annualLeave.ScheduledNumberOfDays < filter.MinScheduledNumberOfDays.Value)
                {
                    return(returnValue);             // Проверяемая запись не соответствует фильтру по запланированному количеству дней отпуска
                }
                if (filter.MaxScheduledNumberOfDays.HasValue && annualLeave.ScheduledNumberOfDays.HasValue && annualLeave.ScheduledNumberOfDays > filter.MaxScheduledNumberOfDays.Value)
                {
                    return(returnValue);             // Проверяемая запись не соответствует фильтру по запланированному количеству дней отпуска
                }
                // Фильтры по фактическому количеству дней отпуска
                if (filter.MinActualNumberOfDays.HasValue && annualLeave.ActualNumberOfDays.HasValue && annualLeave.ActualNumberOfDays < filter.MinActualNumberOfDays.Value)
                {
                    return(returnValue);             // Проверяемая запись не соответствует фильтру по фактическому количеству дней отпуска
                }
                if (filter.MaxActualNumberOfDays.HasValue && annualLeave.ActualNumberOfDays.HasValue && annualLeave.ActualNumberOfDays > filter.MaxActualNumberOfDays.Value)
                {
                    return(returnValue);             // Проверяемая запись не соответствует фильтру по фактическому количеству дней отпуска
                }
                return(!returnValue);                // Если дошли до сюда, значит проверяемая запись соответствует фильтру
            }

            return(predicate);
        }