예제 #1
0
        public IEnumerable <DerogationHeader> GetLast(DerogationListRequestModel requestModel)
        {
            requestModel.ToDate = requestModel.ToDate.AddDays(1);
            var authUser = _database.Users.First(usr => usr.DerogationUser == this.User.Identity.Name);

            var filteredList = _derogationService.GetFilteredList(requestModel, authUser);

            return(filteredList);
        }
예제 #2
0
        public List <DerogationHeader> GetFilteredList(DerogationListRequestModel model, User user)
        {
            if (!model.UseDateRange)
            {
                model.FromDate = DateTime.MinValue;
                model.ToDate   = DateTime.MaxValue;
            }

            if (model.DerogationId != 0)
            {
                var derogation = _db.DerogationHeaders
                                 .Include(dHeader => dHeader.Author)
                                 .Include(dHeader => dHeader.FactoryDepartment)
                                 .Include(dHeader => dHeader.Operators)
                                 .FirstOrDefault(derg => derg.DerogationId == model.DerogationId);

                return(new List <DerogationHeader> {
                    derogation
                });
            }

            if (model.WorkOrder != 0)
            {
                var derogationsByWorkOrder = GetDerogationsByWorkOrder(model.WorkOrder.ToString());

                return(derogationsByWorkOrder);
            }

            if (model.ModelName != "")
            {
                var derogationsByModelName = GetDerogationsByModelName(model.ModelName);

                return(derogationsByModelName);
            }

            if (model.PartNumber != "")
            {
                var derogationsByPartNumber = GetDerogationsByPartNumber(model.PartNumber);

                return(derogationsByPartNumber);
            }

            var derogationList = _db.DerogationHeaders
                                 .Where(derg => derg.CreatedDate >= model.FromDate && derg.CreatedDate <= model.ToDate)
                                 .Include(dHeader => dHeader.Author)
                                 .Include(dHeader => dHeader.FactoryDepartment)
                                 .ToList();

            var result = new List <DerogationHeader>(derogationList);

            if (model.DepartmentOwner != "All")
            {
                result = result.FindAll(derg => derg.Department == model.DepartmentOwner);
            }

            if (model.ByStatus != "All")
            {
                switch (model.ByStatus)
                {
                case "NewForMe":
                    result = new List <DerogationHeader>();
                    derogationList.ForEach(derogation =>
                    {
                        if (derogation.Approved == '0' && derogation.Cancelled == '0')
                        {
                            derogation = GetDerogation(derogation.DerogationId);
                        }

                        derogation.DerogationDepartments.ForEach(dDept =>
                        {
                            if (dDept.Department != user.Department)
                            {
                                return;
                            }

                            if (dDept.Approved == '0' && dDept.Rejected == '0' & dDept.CancellationRequest == '0')
                            {
                                result.Add(derogation);
                            }
                        });
                    });
                    break;

                case "MyTurnForApproval":
                    result = new List <DerogationHeader>();
                    derogationList.ForEach(derogation =>
                    {
                        if (derogation.Approved == '0' && derogation.Cancelled == '0')
                        {
                            derogation = GetDerogation(derogation.DerogationId);
                        }

                        GetNextDeptsForApproval(derogation).ForEach(fDept =>
                        {
                            if (!fDept.Equals(user.FactoryDepartment))
                            {
                                return;
                            }

                            var dDepartment = GetDergDeptByDepartmentName(derogation, fDept.Department);
                            if (dDepartment.Approved != '1' && dDepartment.Rejected != '1' && dDepartment.CancellationRequest != '1')
                            {
                                result.Add(derogation);
                            }
                        });
                    });

                    break;

                case "InProgress":
                    result = result.FindAll(derg =>
                                            derg.Approved != '1' && derg.Cancelled != '1' && derg.Offline != '1');
                    break;

                case "Approved":
                    result = result.FindAll(derg => derg.Approved == '1');
                    break;

                case "Cancelled":
                    result = result.FindAll(derg => derg.Cancelled == '1');
                    break;

                case "Offline":
                    result = result.FindAll(derg => derg.Offline == '1');
                    break;
                }
            }

            result.Sort(((derg1, derg2) => derg1.CreatedDate < derg2.CreatedDate ? 1 : -1));

            var count         = model.LastCount > result.Count ? result.Count : model.LastCount;
            var croppedResult = result.GetRange(0, count);

            return(croppedResult);
        }