public async Task <OperationDataResult <Paged <StatByYearModel> > > GetFractionsStatsByYear([FromBody] FractionPnYearRequestModel requestModel)
 {
     return(await _fractionService.GetFractionsStatsByYear(requestModel));
 }
Beispiel #2
0
        public async Task <OperationDataResult <Paged <StatByYearModel> > > GetFractionsStatsByYear(FractionPnYearRequestModel pnRequestModel)
        {
            try
            {
                var trashInspectionsQuery = _dbContext.TrashInspections
                                            .Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
                                            .Where(x => x.Date.Year == pnRequestModel.Year)
                                            .AsQueryable();

                var fractionsStatsByYearModel = new Paged <StatByYearModel>();

                var fractionQuery = _dbContext.Fractions
                                    .Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
                                    .AsQueryable();

                //if (!pnRequestModel.NameFilter.IsNullOrEmpty() && pnRequestModel.NameFilter != "")
                //{
                //    fractionQuery = fractionQuery.Where(x =>
                //        x.Name.Contains(pnRequestModel.NameFilter) ||
                //        x.Description.Contains(pnRequestModel.NameFilter));
                //}

                var exludeSort = new List <string>
                {
                    "Weighings",
                    "ControlPercentage",
                    "AmountOfWeighingsControlled",
                    "ApprovedPercentage",
                    "NotApprovedPercentage",
                    "ConditionalApprovedPercentage"
                };
                fractionQuery = QueryHelper.AddSortToQuery(fractionQuery, pnRequestModel.Sort, pnRequestModel.IsSortDsc, exludeSort);

                fractionsStatsByYearModel.Total = await fractionQuery.Select(x => x.Id).CountAsync();

                var fractionsStatsByYear = await fractionQuery
                                           .Select(x => new StatByYearModel
                {
                    Id                            = x.Id,
                    Name                          = x.Name,
                    Weighings                     = trashInspectionsQuery.Count(t => t.FractionId == x.Id),
                    ControlPercentage             = 0,
                    AmountOfWeighingsControlled   = trashInspectionsQuery.Count(t => t.FractionId == x.Id && t.Status == 100),
                    ApprovedPercentage            = trashInspectionsQuery.Count(t => t.FractionId == x.Id && t.IsApproved && t.Status == 100),
                    NotApprovedPercentage         = trashInspectionsQuery.Count(t => t.FractionId == x.Id && t.ApprovedValue == "3" && t.Status == 100),
                    ConditionalApprovedPercentage = trashInspectionsQuery.Count(t => t.FractionId == x.Id && t.ApprovedValue == "2" && t.Status == 100)
                })
                                           .ToListAsync();

                foreach (var statByYearModel in fractionsStatsByYear)
                {
                    if (statByYearModel.Weighings > 0)
                    {
                        statByYearModel.ControlPercentage = Math.Round((statByYearModel.AmountOfWeighingsControlled / statByYearModel.Weighings) * 100, 1);
                    }

                    if (statByYearModel.ApprovedPercentage > 0 && statByYearModel.AmountOfWeighingsControlled > 0)
                    {
                        statByYearModel.ApprovedPercentage =
                            Math.Round((statByYearModel.ApprovedPercentage / statByYearModel.AmountOfWeighingsControlled) * 100, 1);
                    }
                    else
                    {
                        statByYearModel.ApprovedPercentage = 0;
                    }

                    if (statByYearModel.ConditionalApprovedPercentage > 0 && statByYearModel.AmountOfWeighingsControlled > 0)
                    {
                        statByYearModel.ConditionalApprovedPercentage =
                            Math.Round((statByYearModel.ConditionalApprovedPercentage / statByYearModel.AmountOfWeighingsControlled) * 100, 1);
                    }
                    else
                    {
                        statByYearModel.ConditionalApprovedPercentage = 0;
                    }

                    if (statByYearModel.NotApprovedPercentage > 0 && statByYearModel.AmountOfWeighingsControlled > 0)
                    {
                        statByYearModel.NotApprovedPercentage =
                            Math.Round((statByYearModel.NotApprovedPercentage / statByYearModel.AmountOfWeighingsControlled) * 100, 1);
                    }
                    else
                    {
                        statByYearModel.NotApprovedPercentage = 0;
                    }
                }

                if (!string.IsNullOrEmpty(pnRequestModel.Sort) && exludeSort.Contains(pnRequestModel.Sort))
                {
                    fractionsStatsByYear = pnRequestModel.IsSortDsc
                        ? fractionsStatsByYear.OrderByDescending(x => x.GetPropValue(pnRequestModel.Sort)).ToList()
                        : fractionsStatsByYear.OrderBy(x => x.GetPropValue(pnRequestModel.Sort)).ToList();
                }

                fractionsStatsByYearModel.Entities = fractionsStatsByYear;

                return(new OperationDataResult <Paged <StatByYearModel> >(true, fractionsStatsByYearModel));
            }
            catch (Exception e)
            {
                Trace.TraceError(e.Message);
                _coreHelper.LogException(e.Message);
                return(new OperationDataResult <Paged <StatByYearModel> >(false,
                                                                          _trashInspectionLocalizationService.GetString("ErrorObtainingFractions")));
            }
        }