public ActionResult Transferencia(TransferenciaViewModel transferencia)
{
if (ModelState.IsValid)
{
var contaDestino = GetConta(contas, transferencia.ContaDestino);
var contaOrigem = GetConta(contas, transferencia.ContaOrigem);
var valor_transferir = Math.Abs(transferencia.Montante);
if (contaOrigem.Saldo < valor_transferir)
{
valor_transferir = contaOrigem.Saldo;
}
contaOrigem.Saldo -= valor_transferir;
contaDestino.Saldo += valor_transferir;
transacoes.Add(new Transacao()
{
Montante = -valor_transferir, Conta = contaOrigem, Tipo = TipoTransacao.Transferencia
});
transacoes.Add(new Transacao()
{
Montante = valor_transferir, Conta = contaDestino, Tipo = TipoTransacao.Transferencia
});
return(RedirectToAction("SelecionarConta", "Home"));
}
return(View());
}
public IActionResult OnGet(int?id)
{
if (id == null)
{
return(NotFound());
}
var _modelo =
_context.Tranferencias
.Include(x => x.BlocoProjInvestimentos)
.Where(x => x.Id == id)
.FirstOrDefault();
var _usu = _context.Users
.Where(x => x.Id == _modelo.IdUsu)
.FirstOrDefault();
if (_modelo == null || _usu == null)
{
return(NotFound());
}
modelo = new TransferenciaViewModel()
{
Id = _modelo.Id,
IDUSU = _usu.Id,
Montante = _modelo.Valor
};
return(Page());
}
public HttpResponseMessage CreateTransferencia(HttpRequestMessage request, [FromBody] TransferenciaViewModel transferenciaViewModel)
{
TransactionalInformation transaction;
_transferenciaService = new TransferenciaBusinessService();
Transferencia transferencia = new Transferencia();
transferencia.CuentaIdDestino = transferenciaViewModel.CuentaIdDestino;
transferencia.CuentaIdOrigen = transferenciaViewModel.CuentaIdOrigen;
transferencia.Descripcion = transferenciaViewModel.Descripcion;
transferencia.Fecha = DateTime.Now;// transferenciaViewModel.Fecha;
transferencia.Monto = transferenciaViewModel.Monto;
//transferencia.TransferenciaID = transferenciaViewModel.TransferenciaID;
_transferenciaService.SaveTransferencia(transferencia, out transaction);
if (transaction.ReturnStatus == false)
{
transferenciaViewModel.ReturnStatus = false;
transferenciaViewModel.ReturnMessage = transaction.ReturnMessage;
transferenciaViewModel.ValidationErrors = transaction.ValidationErrors;
var responseError = Request.CreateResponse <TransferenciaViewModel>(HttpStatusCode.BadRequest, transferenciaViewModel);
return(responseError);
}
transferenciaViewModel.ReturnStatus = true;
transferenciaViewModel.ReturnMessage = transaction.ReturnMessage;
var response = Request.CreateResponse <TransferenciaViewModel>(HttpStatusCode.OK, transferenciaViewModel);
return(response);
}
public ActionResult Transferencias()
{
var viewModel = new TransferenciaViewModel
{
};
return(View());
}
public ActionResult Post([FromBody] TransferenciaViewModel transferencia)
{
var contaOrigem = transferencia.ContaOrigem?.ParaEntidade();
var contaDestino = transferencia.ContaDestino?.ParaEntidade();
_transferenciaService.Transferir(contaOrigem, contaDestino, transferencia.Valor);
return(Ok());
}
public IActionResult Post([FromBody] TransferenciaViewModel transferenciaViewModel)
{
if (ValidarViewModel(ModelState))
{
var transferencia = _mapper.Map <TransferenciaDTO>(transferenciaViewModel);
_contaService.Transferir(transferencia);
}
return(ProcessarRetorno("Transferência realizada com sucesso"));
}
public async Task <IActionResult> RealizarTransferencia([FromBody, SwaggerParameter("Informações da transferência.", Required = true)] TransferenciaViewModel model)
{
var entrada = new TransferenciaEntrada(
base.ObterIdUsuarioClaim(),
model.IdContaOrigem.Value,
model.IdContaDestino.Value,
model.Data.Value,
model.Valor.Value,
model.Observacao);
return(new ApiResult(await _contaServico.RealizarTransferencia(entrada)));
}
public TransferenciaViewModel Transferir(TransferenciaViewModel transferencia)
{
TransferirLotes(transferencia);
var retornoTransferencia = Mapper.Map <TransferenciaViewModel>(_transferenciaServices
.Transferir(Mapper.Map <Transferencia>(transferencia)));
if (retornoTransferencia.ValidationResult.IsValid)
{
Commit();
}
return(retornoTransferencia);
}
private void TransferirLotes(TransferenciaViewModel transferencia)
{
var categoria = _categoriaAppServices.ObterPorId(transferencia.CategoriaId);
if (categoria.Descricao == "Romaneio")
{
transferencia.Lotes = AtualizarLotes(transferencia.Lotes, transferencia.ArmazemDestino, 3, transferencia.NumeroDocumento, "R");
}
else if (categoria.Descricao == "Ordem de Expedição")
{
transferencia.Lotes = AtualizarLotes(transferencia.Lotes, transferencia.ArmazemDestino, 4, transferencia.NumeroDocumento, "O");
}
}
public IActionResult Transferir(TransferenciaViewModel model)
{
if (!ModelState.IsValid)
{
CarregarDropUsuario();
return(View(model));
}
var transferenciaCommand = new TransferenciaCommand(model.ContaDebitoId, model.ContaCreditoId, model.Valor);
_movimentacaoAppServico.Transferir(transferenciaCommand);
return(RedirectToAction(nameof(Index), nameof(Usuario)));
}
public async Task <IActionResult> Transferencia()
{
ViewData["Nombre"] = User.Identity.Name;
var cuentaUsuario = await _cuentaRepository.GetCuentaUsuario(await IdUsuarioClienteAsync());
TransferenciaViewModel tranferir = new TransferenciaViewModel();
tranferir.cuenta = cuentaUsuario;
tranferir.cuentaMismoCliente = cuentaUsuario;
return(View(tranferir));
}
public async Task <IActionResult> Transferencia(TransferenciaViewModel tf)
{
var cuentaUsuario = await _cuentaRepository.GetCuentaUsuario(await IdUsuarioClienteAsync());
tf.cuenta = cuentaUsuario;
tf.cuentaMismoCliente = cuentaUsuario;
ViewBag.exists = "";
ViewData["Nombre"] = User.Identity.Name;
if (ModelState.IsValid)
{
if (tf.NumeroCuenta == tf.NumeroCuentaDestinatario)
{
ModelState.AddModelError("", "La cuenta destinataria es igual a la cuenta de origen, transferencia invalida");
return(View(tf));
}
var cuentaOrigen = await _cuentaRepository.GetByIdAsync(tf.NumeroCuenta.Value);
var cuentaDestinada = await _cuentaRepository.GetByIdAsync(tf.NumeroCuentaDestinatario.Value);
if (tf.Monto > cuentaOrigen.Balance)
{
ModelState.AddModelError("", "La cuenta de ahorro de origen no cuenta con ese monto.");
return(View(tf));
}
else
{
cuentaOrigen.Balance = cuentaOrigen.Balance - tf.Monto;
cuentaDestinada.Balance = cuentaDestinada.Balance + tf.Monto;
await _cuentaRepository.Update(cuentaOrigen);
await _cuentaRepository.Update(cuentaDestinada);
var transacciones = _mapper.Map <Transacciones>(tf);
await _transaccionesRepository.AddAsync(transacciones);
ViewBag.exists = "Transferencia realizada sastifactoriamente.";
return(View(tf));
}
}
ModelState.AddModelError("", "Revisa esta pasando un error");
return(View(tf));
}
public ActionResult Transferir(TransferenciaViewModel model)
{
return(View(model));
}
public HttpResponseMessage GetTransferenciasByUsuario(HttpRequestMessage request, [FromBody] TransferenciaViewModel transferenciaViewModel)
{
TransactionalInformation transaction;
int currentPageNumber = transferenciaViewModel.CurrentPageNumber;
int pageSize = transferenciaViewModel.PageSize;
string sortExpression = transferenciaViewModel.SortExpression;
string sortDirection = transferenciaViewModel.SortDirection;
_transferenciaService = new TransferenciaBusinessService();
List <Transferencia> transferencias = _transferenciaService.GetTransferenciasByUsuario(1, currentPageNumber, pageSize, sortExpression, sortDirection, out transaction);
if (transaction.ReturnStatus == false)
{
transferenciaViewModel.ReturnStatus = false;
transferenciaViewModel.ReturnMessage = transaction.ReturnMessage;
transferenciaViewModel.ValidationErrors = transaction.ValidationErrors;
var responseError = Request.CreateResponse <TransferenciaViewModel>(HttpStatusCode.BadRequest, transferenciaViewModel);
return(responseError);
}
transferenciaViewModel.TotalPages = transaction.TotalPages;
transferenciaViewModel.TotalRows = transaction.TotalRows;
transferenciaViewModel.Transferencias = transferencias;
transferenciaViewModel.ReturnStatus = true;
transferenciaViewModel.ReturnMessage = transaction.ReturnMessage;
var response = Request.CreateResponse <TransferenciaViewModel>(HttpStatusCode.OK, transferenciaViewModel);
return(response);
}
