Exemplo n.º 1
0
        public async Task <ScadenzaViewModel> EditScadenzaAsync(ScadenzaEditInputModel inputModel)
        {
            Scadenza scadenza = await dbContext.Scadenze.FindAsync(inputModel.IDScadenza);

            if (scadenza == null)
            {
                throw new ScadenzaNotFoundException(inputModel.IDScadenza);
            }
            try
            {
                //Mapping
                scadenza.Beneficiario   = inputModel.Beneficiario;
                scadenza.DataScadenza   = inputModel.DataScadenza;
                scadenza.DataPagamento  = inputModel.DataPagamento;
                scadenza.GiorniRitardo  = inputModel.GiorniRitardo;
                scadenza.Sollecito      = inputModel.Sollecito;
                scadenza.Importo        = inputModel.Importo;
                scadenza.IDBeneficiario = inputModel.IDBeneficiario;
                scadenza.IDUser         = user.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;


                dbContext.Update(scadenza);
                await dbContext.SaveChangesAsync();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return(ScadenzaViewModel.FromEntity(scadenza));
        }
Exemplo n.º 2
0
        public async Task <ScadenzaViewModel> CreateScadenzaAsync(ScadenzaCreateInputModel inputModel)
        {
            Scadenza scadenza = new();

            scadenza.Beneficiario   = inputModel.Beneficiario;
            scadenza.DataScadenza   = inputModel.DataScadenza;
            scadenza.Importo        = inputModel.Importo;
            scadenza.IDBeneficiario = inputModel.IDBeneficiario;
            scadenza.IDUser         = user.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
            await dbContext.AddAsync(scadenza);

            await dbContext.SaveChangesAsync();

            return(ScadenzaViewModel.FromEntity(scadenza));
        }
Exemplo n.º 3
0
        public async Task <ScadenzaViewModel> GetScadenzaAsync(int id)
        {
            logger.LogInformation("Ricevuto identificativo scadenza {id}", id);
            IQueryable <ScadenzaViewModel> queryLinq = dbContext.Scadenze
                                                       .AsNoTracking()
                                                       .Include(Scadenza => Scadenza.Ricevute)
                                                       .Where(scadenza => scadenza.IDScadenza == id)
                                                       .Select(scadenza => ScadenzaViewModel.FromEntity(scadenza)); //Usando metodi statici come FromEntity, la query potrebbe essere inefficiente. Mantenere il mapping nella lambda oppure usare un extension method personalizzato

            ScadenzaViewModel viewModel = await queryLinq.FirstOrDefaultAsync();

            //Restituisce il primo elemento dell'elenco, ma se ne contiene 0 o più di 1 solleva un eccezione.
            //.FirstOrDefaultAsync(); //Restituisce null se l'elenco è vuoto e non solleva mai un'eccezione
            //.SingleOrDefaultAsync(); //Tollera il fatto che l'elenco sia vuoto e in quel caso restituisce null, oppure se l'elenco contiene più di 1 elemento, solleva un'eccezione
            //.FirstAsync(); //Restituisce il primo elemento, ma se l'elenco è vuoto solleva un'eccezione
            if (viewModel == null)
            {
                throw new ScadenzaNotFoundException(id);
            }
            return(viewModel);
        }
Exemplo n.º 4
0
        public async Task <ListViewModel <ScadenzaViewModel> > GetScadenzeAsync(ScadenzaListInputModel model)
        {
            IQueryable <Scadenza> baseQuery = dbContext.Scadenze;

            switch (model.OrderBy)
            {
            case "Beneficiario":
                if (model.Ascending)
                {
                    baseQuery = baseQuery.OrderBy(z => z.Beneficiario);
                }
                else
                {
                    baseQuery = baseQuery.OrderByDescending(z => z.Beneficiario);
                }
                break;

            case "DataScadenza":
                if (model.Ascending)
                {
                    baseQuery = baseQuery.OrderBy(z => z.DataScadenza);
                }
                else
                {
                    baseQuery = baseQuery.OrderByDescending(z => z.DataScadenza);
                }
                break;

            case "Importo":
                if (model.Ascending)
                {
                    baseQuery = baseQuery.OrderBy(z => z.Importo);
                }
                else
                {
                    baseQuery = baseQuery.OrderByDescending(z => z.Importo);
                }
                break;
            }
            if (IsDate(model.Search))
            {
                DateTime data = Convert.ToDateTime(model.Search);
                IQueryable <ScadenzaViewModel> queryLinq = baseQuery
                                                           .AsNoTracking()
                                                           .Include(Scadenza => Scadenza.Ricevute)
                                                           .Where(Scadenze => Scadenze.IDUser == user.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value)
                                                           .Where(scadenze => scadenze.DataScadenza == data)
                                                           .Select(scadenze => ScadenzaViewModel.FromEntity(scadenze)); //Usando metodi statici come FromEntity, la query potrebbe essere inefficiente. Mantenere il mapping nella lambda oppure usare un extension method personalizzato
                List <ScadenzaViewModel> scadenza = await queryLinq
                                                    .Skip(model.Offset)
                                                    .Take(model.Limit).ToListAsync();

                int totalCount = await queryLinq.CountAsync();

                ListViewModel <ScadenzaViewModel> results = new ListViewModel <ScadenzaViewModel>
                {
                    Results    = scadenza,
                    TotalCount = totalCount
                };
                return(results);
            }
            else
            {
                IQueryable <ScadenzaViewModel> queryLinq = baseQuery
                                                           .AsNoTracking()
                                                           .Include(Scadenza => Scadenza.Ricevute)
                                                           .Where(Scadenze => Scadenze.IDUser == user.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value)
                                                           .Where(scadenze => scadenze.Beneficiario.Contains(model.Search))
                                                           .Select(scadenze => ScadenzaViewModel.FromEntity(scadenze)); //Usando metodi statici come FromEntity, la query potrebbe essere inefficiente. Mantenere il mapping nella lambda oppure usare un extension method personalizzato
                List <ScadenzaViewModel> scadenza = await queryLinq
                                                    .Skip(model.Offset)
                                                    .Take(model.Limit).ToListAsync();

                int totalCount = await queryLinq.CountAsync();

                ListViewModel <ScadenzaViewModel> results = new ListViewModel <ScadenzaViewModel>
                {
                    Results    = scadenza,
                    TotalCount = totalCount
                };
                return(results);
            }
        }