public void LoadUsuario(ContaViewModel Conta)
{
var resposta = Requisicao.Get("http://localhost:5000/api/Usuario");
var Usuario = JsonConvert.DeserializeObject <IEnumerable <UsuarioViewModel> >(resposta.Content.ReadAsStringAsync().Result);
Conta.ListaUsuario = Usuario.ToList();
}
public ActionResult Create(ContaViewModel contaViewModel)
{
if (ModelState.IsValid)
{
contaViewModel = _clienteAppService.Adicionar(contaViewModel);
if (!contaViewModel.ValidationResult.IsValid)
{
foreach (var erro in contaViewModel.ValidationResult.Erros)
{
ModelState.AddModelError(string.Empty, erro.Message);
}
return(View(contaViewModel));
}
if (!contaViewModel.ValidationResult.Message.IsNullOrWhiteSpace())
{
ViewBag.Sucesso = contaViewModel.ValidationResult.Message;
return(View(contaViewModel));
}
return(RedirectToAction("Index"));
}
return(View(contaViewModel));
}
public IActionResult EfetivarSaque(ContaViewModel contaVM)
{
var contaContract = HttpContext.Session.GetObject <ContaContract>("_contaContract");
string valor1 = contaVM.Valor.Replace(".", "");
string valor = valor1.Replace(",", ".");
if (contaContract.Object.Saldo < Convert.ToDecimal(valor))
{
TempData["MsgOperacao"] = "Valor do saque não pode ser maior que saldo disponível em conta corrente";
return(RedirectToAction("Deposita", "ContaDigital"));
}
bool retOp = Sacar(new HttpHelper().ConfigurarHttpClient(), valor, Convert.ToString(contaContract.Object.IdConta), urlBaseApi);
if (retOp)
{
TempData["MsgOperacao"] = "Saque feito com sucesso";
}
else
{
TempData["MsgOperacao"] = "Problemas de operação de Saque";
}
return(RedirectToAction("Deposita", "ContaDigital"));
}
public ActionResult BuscarDados(int?IdConta)
{
try
{
var conta = new ContaViewModel();
if (IdConta.HasValue)
{
var resposta = Requisicao.Get("http://localhost:5000/api/Conta?id=" + IdConta);
if (!resposta.IsSuccessStatusCode)
{
return(View("Error", "Erro ao buscar dados"));
}
conta = JsonConvert.DeserializeObject <ContaViewModel>(resposta.Content.ReadAsStringAsync().Result);
}
LoadUsuario(conta);
return(View("_Dados", conta));
}
catch (Exception ex)
{
return(View("Error:", ex.Message));
}
}
public async Task <IActionResult> AddConta(ContaDTO conta)
{
if (!ModelState.IsValid)
{
ContaViewModel vm = new ContaViewModel();
vm.Conta = conta;
return(RedirectToAction("Index", vm));
}
else
{
try
{
ContaService service = new ContaService();
string response = await service.Post(conta);
TempData["Mensagem"] = response;
TempData["Alerta"] = true;
TempData["Classe"] = "sucesso";
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
TempData["Mensagem"] = ex.Message;
TempData["Alerta"] = true;
TempData["Classe"] = "atencao";
return(RedirectToAction("Index"));
}
}
}
public IActionResult Cadastrar(ContaViewModel contaViewModel)
{
if (ModelState.IsValid)
{
Usuario usuario = new Usuario
{
NmEmail = contaViewModel.Nm_email,
NmSenha = contaViewModel.Nm_senha,
NmUsuario = contaViewModel.Nm_usuario,
DvAtivo = true,
};
var retorno = _usuarioAppService.AdicionarUsuario(usuario);
ViewBag.Codigo = retorno.cdretorno;
ViewBag.Mensagem = retorno.mensagem;
}
else
{
//erro
ViewBag.Mensagem = "Cadastro não está valido!";
ViewBag.Codigo = 1;
}
return(View(contaViewModel));
}
public async Task <IActionResult> Index()
{
if (!HttpContext.Session.Keys.Any())
{
return(RedirectToAction("Index", "Login", new { area = "" }));
}
else
{
ContaViewModel vm = new ContaViewModel
{
Filtros = new ContaQuery()
{
IdPessoa = HttpContext.Session.GetInt32("Id").Value
}
};
string nomePessoa = HttpContext.Session.GetString("nome");
string genero = HttpContext.Session.GetString("genero") == "masculino" ? "Sr." : "Sra.";
ViewBag.Pessoa = genero + " " + nomePessoa;
ViewBag.Id = HttpContext.Session.GetInt32("Id").Value;
ViewBag.Url = $"{this.Request.Scheme}://{Request.Host}{Request.PathBase}";
try
{
await vm.GetContas();
}
catch (Exception ex)
{
ViewBag.ErrorMessage = ex.Message;
}
return(View(vm));
}
}
public ActionResult DeleteConfirmed(Guid id)
{
ContaViewModel contaViewModel = _contaAppService.ObterPorId(id);
_contaAppService.Remover(id);
return(RedirectToAction("Index"));
}
public ContaViewModel Transferir(ContaViewModel contaOrigem, ContaViewModel contaDestino, double valor)
{
var contaDomainOrigem = this._mapper.Map <Conta>(contaOrigem);
var contaDomainDestino = this._mapper.Map <Conta>(contaDestino);
return(this._mapper.Map <ContaViewModel>(this._contaService.Transferir(contaDomainOrigem, contaDomainDestino, valor)));
}
// GET: contas/Cadastro
public ActionResult Cadastro()
{
var modelo = new conta();
var model = new ContaViewModel();
return(View(model));
}
public HttpResponseMessage SalvarConta(ContaViewModel model)
{
try
{
if (model.IdConta > 0)
{
var conta = _financeiroService.ObterContaPorId(model.IdConta);
if (conta == null)
{
throw new Exception("Não foi possivel recuperar dados da conta");
}
conta.SetNmConta(model.Nome);
conta.SetSituacao(model.Situacao);
_financeiroService.SalvarConta(conta);
return(Request.CreateResponse(HttpStatusCode.OK, model));
}
else
{
var conta = new Conta(model.Nome, base.GetUsuarioLogado().Clinica);
_financeiroService.SalvarConta(conta);
return(Request.CreateResponse(HttpStatusCode.OK, model));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public IActionResult CreateOrEdit(int id, ContaViewModel contasViewModel)
{
if (!ModelState.IsValid)
{
AddErrorsFromModel(ModelState.Values);
return(View(contasViewModel));
}
var conta = Mapper.Map <Conta>(contasViewModel);
try
{
_context.Contas.Update(conta);
_context.SaveChanges();
TempData["alert-success"] = "Operação realizada com sucesso!";
}
catch (DbUpdateConcurrencyException)
{
if (!_context.Contas.Any(x => x.ContaId == conta.ContaId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
public IActionResult Update(ContaViewModel contaModel)
{
var conta = _mapper.Map <Conta>(contaModel);
_contaRepository.Update(conta);
_contaRepository.Commit();
return(RedirectToAction("Index"));
}
private void PreencherViewModel(ContaViewModel viewModel)
{
viewModel.ContaCorrenteList = correnteApp.ObterTodos(usuario.Id).ToList();
viewModel.ContaCategoriaList = categoriaApp.ObterTodos(usuario.Id).ToList();
viewModel.ContatoList = contatoApp.ObterTodos(usuario.Id).ToList();
}
public ActionResult Edit(ContaViewModel contaViewModel)
{
if (ModelState.IsValid)
{
_clienteAppService.Atualizar(contaViewModel);
return(RedirectToAction("Index"));
}
return(View(contaViewModel));
}
public IActionResult Delete(int id)
{
var contaViewModel = new ContaViewModel {
Id = id
};
_contaAppService.Excluir(contaViewModel.Id);
return(Response(contaViewModel));
}
public ActionResult FormCreate()
{
var tiposCobranca = _contaRepository.GetCobranca();
var tiposPgto = _contaRepository.GetTiposPgto();
var funcionarios = _funcionarioRepository.GetAll().OrderBy(x => x.Nome_Func);
var model = new ContaViewModel(null, tiposCobranca, tiposPgto, funcionarios);
return View("FormConta", model);
}
public ActionResult Edit(ContaViewModel contaViewModel)
{
if (ModelState.IsValid)
{
_contaAppService.Atualizar(contaViewModel);
return(RedirectToAction("Index"));
}
ViewBag.ClienteId = new SelectList(_ClienteAppService.ObterTodos(), "Id", "Nome", contaViewModel.ClienteId);
return(View(contaViewModel));
}
public IActionResult Post([FromBody] ContaViewModel contaViewModel)
{
if (!ModelStateValida())
{
return(Response());
}
contaViewModel = _contaAppService.Adicionar(contaViewModel);
return(Response(contaViewModel));
}
public ContaViewModel Atualizar(ContaViewModel contaViewModel)
{
var conta = Mapper.Map <Conta>(contaViewModel);
var ClienteRet = _contaService.Atualizar(conta);
Commit();
return(contaViewModel);
}
// Método para obter uma conta no serviço pelo CPF informado
public async Task <ContaViewModel> ObterContaAsync(string CPF)
{
// Chamada ao método para realização de um HTTP Post enviando o CPF como paâmetro
ContaDTO dto = await Post <ContaDTO>("cliente", CPF);
// Transforma o DTO recebido do serviço em ViewModel para uso no app
ContaViewModel contaVM = ParseToVM(dto);
return(contaVM);
}
public IActionResult Delete(Guid id)
{
var contaViewModel = new ContaViewModel {
Id = id
};
var contaCommand = _mapper.Map <ExcluirContaCommand>(contaViewModel);
_mediator.EnviarComando(contaCommand);
return(Response(contaCommand));
}
public IActionResult Put([FromBody] ContaViewModel contaViewModel)
{
if (!ModelStateValida())
{
return(Response());
}
_contaAppService.Atualizar(contaViewModel);
return(Response(contaViewModel));
}
public ActionResult Atualizar(int?id)
{
if (id == null)
{
return(RedirectToAction(nameof(Index)));
}
var conta = _contaRepositorio.ObterContaPorId(id.Value);
if (conta == null)
{
RegistroNaoEncontrado();
}
var viewModel = new ContaViewModel
{
Id = conta.Id,
Descricao = conta.Descricao,
SituacaoCadastral = conta.SituacaoCadastral,
Segmento = conta.Segmento,
ClassificacaoFiscal = conta.ClassificacaoFiscal,
Documento = conta.Documento,
InscricaoEstadual = conta.InscricaoEstadual,
NomeFantasia = conta.NomeFantasia,
Telefone = conta.Telefone,
VendedorId = conta.VendedorId,
CEP = conta.CEP,
Logradouro = conta.Logradouro,
Numero = conta.Numero,
Bairro = conta.Bairro,
Estado = conta.Estado,
CidadeId = conta.CidadeId,
PaisId = conta.PaisId,
Complemento = conta.Complemento,
CriadoPor = conta.CriadoPor,
Blacklist = conta.Blacklist
};
var usuario = _usuarioRepositorio.ObterUsuarioPorId(conta.CriadoPor);
if (usuario != null)
{
ViewBag.UsuarioCriacao = usuario.Login;
ViewBag.DataCriacao = conta.DataCriacao.DataHoraFormatada();
}
PopularCidades(viewModel);
PopularPaises(viewModel);
PopularVendedores(viewModel);
PopularContatos(viewModel);
PopularOportunidades(viewModel);
PopularVinculosIPs(viewModel);
return(View(viewModel));
}
public IActionResult Put(Guid id, [FromBody] ContaViewModel contaViewModel)
{
if (!IsModelStateValid())
{
return(Response());
}
var contaCommand = _mapper.Map <AtualizarContaCommand>(contaViewModel);
_mediator.EnviarComando(contaCommand);
return(Response(contaCommand));
}
public static Dominio.Transferencia.Entidades.ContaCorrente ParaEntidade(this ContaViewModel conta)
{
var ret = new Dominio.Transferencia.Entidades.ContaCorrente
{
Banco = conta.Banco,
Agencia = conta.Agencia,
Conta = conta.Conta
};
return(ret);
}
public ActionResult Incluir()
{
if (usuario == null)
{
return(RedirectToAction("Login", "App"));
}
var viewModel = new ContaViewModel();
PreencherViewModel(viewModel);
return(View(viewModel));
}
// PUT: api/Conta/5
public void Put(ContaViewModel contaVM)
{
var conta = _contaApp.GetById(Convert.ToInt32(contaVM.Id));
conta.Nome = contaVM.Nome;
conta.Status = contaVM.Status;
conta.PessoaTipo = contaVM.PessoaTipo;
conta.Ancestry = contaVM.Ancestry;
conta.IdPessoa = Convert.ToInt32(contaVM.IdPessoa);
_contaApp.Update(conta);
}
public ActionResult Alterar(string id)
{
if (usuario == null)
{
return(RedirectToAction("Login", "App"));
}
var viewModel = new ContaViewModel();
viewModel.ContaInstancia = contaApp.ObterPorId(id);
PreencherViewModel(viewModel);
return(View(viewModel));
}
public IActionResult CreateOrEdit(int?id)
{
var contasViewModel = new ContaViewModel();
if (id > 0)
{
Conta conta = _context.Contas.SingleOrDefault(m => m.ContaId == id);
contasViewModel = Mapper.Map <ContaViewModel>(conta);
}
return(View(contasViewModel));
}
public async Task <ActionResult <ContaViewModel> > AddConta(ContaViewModel contaViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
contaViewModel = _mapper.Map <ContaViewModel>
(await _contaService.AddConta(_mapper.Map <Conta>(contaViewModel)));
return(CustomResponse(contaViewModel));
}
public ActionResult Get(DateTime inicio, DateTime fim)
{
try
{
var contas = _contaRepository.Get(inicio, fim).OrderBy(x=>x.DataVenci_Cont);
var tiposCobranca = _contaRepository.GetCobranca();
var tiposPgto = _contaRepository.GetTiposPgto();
var funcionarios = _funcionarioRepository.GetAll();
var model = new ContaViewModel(contas, tiposCobranca, tiposPgto, funcionarios);
return View("_GridConta", model);
}
catch (Exception ex)
{
throw;
}
}
public ActionResult GetTodas()
{
var contas = _contaRepository.Get().OrderBy(x=>x.DataVenci_Cont);
var tiposCobranca = _contaRepository.GetCobranca();
var tiposPgto = _contaRepository.GetTiposPgto();
var funcionarios = _funcionarioRepository.GetAll();
var model = new ContaViewModel(contas, tiposCobranca, tiposPgto, funcionarios);
return View("_GridConta", model);
}
public ActionResult GetByCod(int codigoConta)
{
var conta = _contaRepository.GetByCod(codigoConta);
var tiposCobranca = _contaRepository.GetCobranca();
var tiposPgto = _contaRepository.GetTiposPgto();
var funcionarios = _funcionarioRepository.GetAll();
var model = new ContaViewModel(conta, tiposCobranca, tiposPgto, funcionarios);
return View("FormConta", model);
}
