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));
}
public async Task <ScadenzaViewModel> EditScadenzaAsync(ScadenzaEditInputModel inputModel)
{
ScadenzaViewModel viewModel = await scadenzaService.EditScadenzaAsync(inputModel);
memoryCache.Remove($"Scadenze{inputModel.IDScadenza}");
return(viewModel);
}
public async Task <IActionResult> DeleteAllegato(int id, int idscadenza)
{
ScadenzaViewModel viewModel = await service.GetScadenzaAsync(idscadenza);
ViewData["Title"] = "Dettaglio Scadenza".ToUpper();
RicevutaViewModel ricevutaViewModel = await ricevute.GetRicevutaAsync(id);
await ricevute.DeleteRicevutaAsync(id);
System.IO.File.Delete(ricevutaViewModel.Path);
viewModel.Ricevute = ricevute.GetRicevute(idscadenza);
return(View("Detail", viewModel));
}
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));
}
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);
}
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);
}
}