public Task BindModelAsync(ModelBindingContext bindingContext)
        {
            string   Name      = bindingContext.ValueProvider.GetValue("name").FirstValue;
            DateTime?EndDate   = Convert.ToDateTime(bindingContext.ValueProvider.GetValue("endDate").FirstValue);
            bool     Emitted   = Convert.ToBoolean(bindingContext.ValueProvider.GetValue("emitted").FirstValue);
            int      Page      = Convert.ToInt32(bindingContext.ValueProvider.GetValue("page").FirstValue);
            bool     Ascending = Convert.ToBoolean(bindingContext.ValueProvider.GetValue("ascending").FirstValue);

            var input = new PagamentiInputModel(Name, EndDate, Emitted, Page, Ascending, InvoicesOptions.CurrentValue);

            bindingContext.Result = ModelBindingResult.Success(input);

            return(Task.CompletedTask);
        }
Ejemplo n.º 2
0
        public async Task <IActionResult> GetPaymentsAsync(PagamentiInputModel input)
        {
            QueryResModel <ManyDettaglioPagamentoDTO> qrm = await InvService.GetPaymentsAsync(input).ConfigureAwait(false);


            if (qrm.Succeeded)
            {
                return(Ok(qrm.Data));
            }
            else
            {
                return(NotFound(qrm.Error));
            }
        }
Ejemplo n.º 3
0
        public async Task <QueryResModel <ManyDettaglioPagamentoDTO> > GetPaymentsAsync(PagamentiInputModel input)
        {
            QueryResModel <ManyDettaglioPagamentoDTO> queryResult = new QueryResModel <ManyDettaglioPagamentoDTO>();

            queryResult.Data          = new ManyDettaglioPagamentoDTO();
            queryResult.Data.Payments = new List <PaymentsDTO>();

            IQueryable <DettaglioPagamentoModel> paymentsQuery = DbContext.DettaglioPagamento
                                                                 .Where(dp => dp.PaymentDate == null && dp.DatiPagamento.Active)
                                                                 .OrderBy(dp => dp.DataScadenzaPagamento);

            if (input.EndDate != null)
            {
                paymentsQuery = paymentsQuery
                                .Where(dp => dp.DataScadenzaPagamento <= input.EndDate || dp.DataScadenzaPagamento == null);
            }

            if (input.Emitted)
            {
                paymentsQuery = paymentsQuery
                                .Where(dp => dp.DatiPagamento.BodyModel.CedentePrestatoreId == OwnerId);

                if (input.Name != null)
                {
                    paymentsQuery = paymentsQuery
                                    .Where(dp => dp.DatiPagamento.BodyModel.CessionarioCommittente.Denominazione.Contains(input.Name) ||
                                           (dp.DatiPagamento.BodyModel.CessionarioCommittente.Nome + " " + dp.DatiPagamento.BodyModel.CessionarioCommittente.Cognome).Contains(input.Name));
                }
            }
            else
            {
                paymentsQuery = paymentsQuery
                                .Where(dp => dp.DatiPagamento.BodyModel.CessionarioCommittenteId == OwnerId);

                if (input.Name != null)
                {
                    paymentsQuery = paymentsQuery
                                    .Where(dp => dp.DatiPagamento.BodyModel.CedentePrestatore.Denominazione.Contains(input.Name) ||
                                           (dp.DatiPagamento.BodyModel.CedentePrestatore.Nome + " " + dp.DatiPagamento.BodyModel.CedentePrestatore.Cognome).Contains(input.Name));
                }
            }

            List <DettaglioPagamentoModel> payments = await paymentsQuery
                                                      .Skip(input.Offset)
                                                      .Take(input.Limit)
                                                      .ToListAsync()
                                                      .ConfigureAwait(false);

            int nrOfPayments = await paymentsQuery
                               .CountAsync()
                               .ConfigureAwait(false);

            queryResult.Data.TotalPages = (int)Math.Ceiling((double)nrOfPayments / InvoicesOptions.PaymentsPerPage);

            foreach (var p in payments)
            {
                int cliforId = await DbContext.DettaglioPagamento
                               .Where(dp => dp.Id == p.Id)
                               .Select(dp => input.Emitted ?
                                       dp.DatiPagamento.BodyModel.CessionarioCommittenteId :
                                       dp.DatiPagamento.BodyModel.CedentePrestatore.Id)
                               .FirstOrDefaultAsync()
                               .ConfigureAwait(false);

                string clifor = await DbContext.Clifor
                                .Where(dp => dp.Id == cliforId)
                                .Select(cf => cf.Denominazione ?? cf.Cognome + " " + cf.Nome)
                                .FirstOrDefaultAsync()
                                .ConfigureAwait(false);

                List <ContiBancariModel> conti = await DbContext.DettaglioPagamento
                                                 .Where(dp => dp.Id == p.Id)
                                                 .Select(dp => input.Emitted ?
                                                         dp.DatiPagamento.BodyModel.CessionarioCommittente.ContiBancari :
                                                         dp.DatiPagamento.BodyModel.CedentePrestatore.ContiBancari)
                                                 .FirstOrDefaultAsync()
                                                 .ConfigureAwait(false);

                string numero = await DbContext.DettaglioPagamento
                                .Where(dp => dp.Id == p.Id)
                                .Select(dp => dp.DatiPagamento.BodyModel.Numero)
                                .FirstOrDefaultAsync()
                                .ConfigureAwait(false);

                DateTime data = await DbContext.DettaglioPagamento
                                .Where(dp => dp.Id == p.Id)
                                .Select(dp => dp.DatiPagamento.BodyModel.Data)
                                .FirstOrDefaultAsync()
                                .ConfigureAwait(false);

                queryResult.Data.Payments.Add(new PaymentsDTO
                {
                    DettaglioPagamento = Mapper.Map <DettaglioPagamentoModel, DettaglioPagamentoDTO>(p),
                    CliforId           = cliforId,
                    Clifor             = clifor,
                    ContiBancari       = Mapper.Map <List <ContiBancariModel>, List <ContiBancariDTO> >(conti),
                    Numero             = numero,
                    Data = data
                });
            }

            if (nrOfPayments == 0)
            {
                queryResult.Succeeded = false;
                queryResult.Error     = "Resources not found.";
            }

            return(queryResult);
        }