public async Task <BeneficiarioViewModel> Beneficiarios(string user)
{
Usuario usu = new Usuario();
usu = _context.Usuario.FirstOrDefault(x => x.Usuario1 == user);
BeneficiarioViewModel agg = new BeneficiarioViewModel();
agg.IdUsuario = usu.IdUsuario;
var list = new List <Cuenta>();
var lista = new List <Usuario>();
var beneficiarios = await _context.Beneficiario.Where(x => x.IdUsuarioCliente == usu.IdUsuario).ToListAsync();
foreach (var c in beneficiarios)
{
var cuenta = _context.Cuenta.FirstOrDefault(x => x.IdUsuario == c.IdUsuarioBeneficiario);
var usuarios = _context.Usuario.FirstOrDefault(x => x.IdUsuario == c.IdUsuarioBeneficiario);
list.Add(cuenta);
lista.Add(usuarios);
}
var cuentauser = _context.Cuenta.Where(x => x.IdUsuario == usu.IdUsuario).ToList();
agg.cuenta = list;
agg.usuario = lista;
agg.cuentauser = cuentauser;
return(agg);
}
public async Task <BeneficiarioViewModel> EditBeneficiarioAsync(BeneficiarioEditInputModel inputModel)
{
BeneficiarioViewModel viewModel = await beneficiarioService.EditBeneficiarioAsync(inputModel);
memoryCache.Remove($"Beneficiario{inputModel.IDBeneficiario}");
return(viewModel);
}
public BeneficiarioViewModel Atualizar(BeneficiarioViewModel beneficiarioViewModel)
{
BeginTransaction();
_beneficiarioServico.Atualizar(Mapper.Map <Beneficiario>(beneficiarioViewModel));
Commit();
return(beneficiarioViewModel);
}
public JsonResult Incluir(BeneficiarioViewModel beneficiario, bool alterar)
{
if (alterar)
{
return(Alterar(beneficiario));
}
else
{
if (CustomSession.Beneficiarios.Count == 0)
{
CustomSession.Beneficiarios = new List <BeneficiarioViewModel>();
CustomSession.Beneficiarios.Add(beneficiario);
}
else
{
if (CustomSession.Beneficiarios.Where(c => c.CPF.Equals(beneficiario.CPF)).ToList().Count > 0)
{
return(Json(new { CPFExistente = "Beneficiario com CPF já informado.", Mensagem = "" }));
}
else
{
CustomSession.Beneficiarios.Add(beneficiario);
}
}
return(Json(new { listaBeneficiario = CustomSession.Beneficiarios, CPFExistente = "", Mensagem = "" }));
}
}
public async Task <BeneficiarioViewModel> EditBeneficiarioAsync(BeneficiarioEditInputModel inputModel)
{
Beneficiario beneficiario = await dbContext.Beneficiari.FindAsync(inputModel.IDBeneficiario);
if (beneficiario == null)
{
throw new BeneficiarioNotFoundException(inputModel.IDBeneficiario);
}
try
{
//Mapping
beneficiario.Sbeneficiario = inputModel.Beneficiario;
beneficiario.Descrizione = inputModel.Descrizione;
beneficiario.Email = inputModel.Email;
beneficiario.Telefono = inputModel.Telefono;
beneficiario.SitoWeb = inputModel.SitoWeb;
dbContext.Update(beneficiario);
await dbContext.SaveChangesAsync();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return(BeneficiarioViewModel.FromEntity(beneficiario));
}
public BeneficiarioViewModel BeneficiarioAtualizar(BeneficiarioViewModel beneficiarioViewModel)
{
var beneficiario = Mapper.Map <Beneficiario>(beneficiarioViewModel);
_beneficiarioService.BeneficiarioAtualizar(beneficiario);
Commit();
return(beneficiarioViewModel);
}
public ActionResult Editar(BeneficiarioViewModel beneficiarioViewModel)
{
if (ModelState.IsValid)
{
_beneficiarioApplicationService.BeneficiarioAtualizar(beneficiarioViewModel);
return(RedirectToAction("Index"));
}
return(View(beneficiarioViewModel));
}
public async Task <IActionResult> PagosBeneficiario(BeneficiarioViewModel bvm)
{
ViewData["Nombre"] = User.Identity.Name;
CuentasyPagos cp = new CuentasyPagos(_context, _userManager, _cuentaRepository,
_tarjetasRepository, _prestamosRepository, _usuarioRepository, _transaccionesRepository, _mapper);
if (ModelState.IsValid)
{
var cuenta = await _context.Cuenta.FirstOrDefaultAsync(x => x.NumeroCuenta == bvm.NumeroCuenta);
var cuenta2 = await _context.Cuenta.FirstOrDefaultAsync(x => x.NumeroCuenta == bvm.NumeroCuentaPagar);
if (cuenta == null || cuenta2 == null)
{
ModelState.AddModelError("", "Cuenta o cuentas inexistentes");
return(View(await cp.Beneficiarios(User.Identity.Name)));
}
if (bvm.NumeroCuenta == bvm.NumeroCuentaPagar)
{
ModelState.AddModelError("", "No puedes tranferirte el dinero que ya tienes por favor verifique la cuenta desitinataria.");
return(View(await cp.Beneficiarios(User.Identity.Name)));
}
if (cuenta.Balance < bvm.Monto)
{
ModelState.AddModelError("", "No tiene suficiente balance");
return(View(await cp.Beneficiarios(User.Identity.Name)));
}
cuenta.Balance = cuenta.Balance - bvm.Monto;
cuenta2.Balance = cuenta2.Balance + bvm.Monto;
try
{
//await _cuentaRepository.Update(cuenta);
//await _cuentaRepository.Update(cuenta2);
ModelState.AddModelError("", "Tu cuenta si tiene dinero");
var UsuarioDestinatario = await _usuarioRepository.GetByIdAsync(cuenta2.IdUsuario);
TransaccionesViewModels Transacciones = new TransaccionesViewModels();
Transacciones.NumeroCuenta = cuenta.NumeroCuenta;
Transacciones.NumeroCuentaDestinatario = bvm.NumeroCuentaPagar;
Transacciones.Monto = bvm.Monto;
Transacciones.Nombre = UsuarioDestinatario.Nombre;
Transacciones.Apellido = UsuarioDestinatario.Apellido;
Transacciones.TipoTransaccion = 1;
return(RedirectToAction("ConfirmPagosBeneficiario", "Client", Transacciones));
}
catch { }
return(RedirectToAction("Index"));
}
return(View(bvm));
}
public async Task <BeneficiarioViewModel> CreateBeneficiarioAsync(BeneficiarioCreateInputModel inputModel)
{
Beneficiario beneficiario = new Beneficiario();
beneficiario.Sbeneficiario = inputModel.Beneficiario;
beneficiario.Descrizione = inputModel.Descrizione;
await dbContext.AddAsync(beneficiario);
await dbContext.SaveChangesAsync();
return(BeneficiarioViewModel.FromEntity(beneficiario));
}
public JsonResult Alterar(BeneficiarioViewModel beneficiario)
{
var beneficiarioAlterado = CustomSession.Beneficiarios.FirstOrDefault(c => c.CPF.Equals(beneficiario.CPF));
if (beneficiarioAlterado != null)
{
CustomSession.Beneficiarios.FirstOrDefault(c => c.CPF.Equals(beneficiario.CPF)).Nome = beneficiario.Nome;
return(Json(new { listaBeneficiario = CustomSession.Beneficiarios, Mensagem = "", CPFExistente = "" }));
}
else
{
return(Json(new { Mensagem = "O CPF Informado não faz parte da lista de beneficiários cadastrado.", CPFExistente = "" }));
}
}
public ActionResult Details(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BeneficiarioViewModel beneficarioViewModel = _beneficiarioAppServico.ObterPorId(id.Value);
if (beneficarioViewModel == null)
{
return(HttpNotFound());
}
return(View(beneficarioViewModel));
}
public async Task <IActionResult> Beneficiario()
{
ViewData["Nombre"] = User.Identity.Name;
Usuario usu = new Usuario();
usu = await _context.Usuario.FirstOrDefaultAsync(x => x.Usuario1 == User.Identity.Name);
var newBeneficiarios = await _context.probandoBeneficiarioViewModels.FromSql("TodosBeneficiarios @IdUsuario = {0}", usu.IdUsuario).ToListAsync();
BeneficiarioViewModel bf = new BeneficiarioViewModel();
bf.LosBeneficiarios = newBeneficiarios;
return(View(bf));
}
public async Task <ListViewModel <BeneficiarioViewModel> > GetBeneficiariAsync(BeneficiarioListInputModel model)
{
IQueryable <Beneficiario> baseQuery = dbContext.Beneficiari;
switch (model.OrderBy)
{
case "Beneficiario":
if (model.Ascending)
{
baseQuery = baseQuery.OrderBy(z => z.Sbeneficiario);
}
else
{
baseQuery = baseQuery.OrderByDescending(z => z.Sbeneficiario);
}
break;
case "Descrizione":
if (model.Ascending)
{
baseQuery = baseQuery.OrderBy(z => z.Descrizione);
}
else
{
baseQuery = baseQuery.OrderByDescending(z => z.Descrizione);
}
break;
}
IQueryable <BeneficiarioViewModel> queryLinq = baseQuery
.AsNoTracking()
.Where(beneficiari => beneficiari.Sbeneficiario.Contains(model.Search))
.Select(beneficiari => BeneficiarioViewModel.FromEntity(beneficiari)); //Usando metodi statici come FromEntity, la query potrebbe essere inefficiente. Mantenere il mapping nella lambda oppure usare un extension method personalizzato
List <BeneficiarioViewModel> beneficiari = await queryLinq
.Skip(model.Offset)
.Take(model.Limit)
.ToListAsync(); //La query al database viene inviata qui, quando manifestiamo l'intenzione di voler leggere i risultati
int totalCount = await queryLinq.CountAsync();
ListViewModel <BeneficiarioViewModel> results = new ListViewModel <BeneficiarioViewModel>
{
Results = beneficiari,
TotalCount = totalCount
};
return(results);
}
public async Task <BeneficiarioViewModel> GetBeneficiarioAsync(int id)
{
logger.LogInformation("Ricevuto identificativo beneficiario {id}", id);
IQueryable <BeneficiarioViewModel> queryLinq = dbContext.Beneficiari
.AsNoTracking()
.Where(beneficiario => beneficiario.IDBeneficiario == id)
.Select(beneficiario => BeneficiarioViewModel.FromEntity(beneficiario)); //Usando metodi statici come FromEntity, la query potrebbe essere inefficiente. Mantenere il mapping nella lambda oppure usare un extension method personalizzato
BeneficiarioViewModel viewModel = await queryLinq.FirstOrDefaultAsync();
//.FirstOrDefaultAsync(); //Restituisce null se l'elenco è vuoto e non solleva mai un'eccezione
if (viewModel == null)
{
throw new BeneficiarioNotFoundException(id);
} //.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
return(viewModel);
}
public ActionResult Edit(Guid?id)
{
ViewBag.Acao = "Editar Beneficiário";
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BeneficiarioViewModel beneficiarioViewModel = _beneficiarioAppServico.ObterPorId(id.Value);
if (beneficiarioViewModel == null)
{
return(HttpNotFound());
}
ViewBag.BeneficiarioId = id;
return(View(beneficiarioViewModel));
}
public async Task <IActionResult> AgregarBeneficiario(BeneficiarioViewModel agg)
{
if (agg.NumeroCuenta == null)
{
return(RedirectToAction("Beneficiario"));
}
else
{
var cuenta = await _context.Cuenta.FirstOrDefaultAsync(x => x.NumeroCuenta == agg.NumeroCuenta);
if (cuenta != null)
{
Beneficiario bn = new Beneficiario();
bn.IdUsuarioCliente = agg.IdUsuario;
bn.IdUsuarioBeneficiario = cuenta.IdUsuario;
await _context.Beneficiario.AddAsync(bn);
await _context.SaveChangesAsync();
}
}
return(RedirectToAction("Beneficiario"));
}
public ActionResult Incluir(BeneficiarioViewModel beneficiarioViewModel)
{
if (ModelState.IsValid)
{
var beneficiario = _beneficiarioApplicationService.BeneficiarioAdicionar(beneficiarioViewModel);
if (!beneficiario.ValidationResult.IsValid)
{
foreach (var erro in beneficiario.ValidationResult.Errors)
{
ModelState.AddModelError(string.Empty, erro.ErrorMessage);
}
return(View(beneficiario));
}
if (beneficiario.ValidationResult.ToString() != string.Empty)
{
ViewBag.Sucesso = beneficiario.ValidationResult.Errors.ToList();
return(View(beneficiario));
}
return(RedirectToAction("Index"));
}
return(View(beneficiarioViewModel));
}