//=============================================================================================================
public void LoadAcao(LancamentoViewModel lancamento)
{
var resposta = Requisicao.Get("http://localhost:5000/api/Acao");
var Acao = JsonConvert.DeserializeObject <IEnumerable <AcaoViewModel> >(resposta.Content.ReadAsStringAsync().Result);
lancamento.ListaAcao = Acao.ToList();
}
public void LoadUsuario(LancamentoViewModel testmodel)
{
var resposta = Requisicao.Get("http://localhost:5000/api/Usuario");
var Usuario = JsonConvert.DeserializeObject <IEnumerable <UsuarioViewModel> >(resposta.Content.ReadAsStringAsync().Result);
testmodel.ListaUsuario = Usuario.ToList();
}
public void LoadCategoria(LancamentoViewModel testmodel)
{
var resposta = Requisicao.Get("http://localhost:5000/api/Categoria");
var Categoria = JsonConvert.DeserializeObject <IEnumerable <CategoriaViewModel> >(resposta.Content.ReadAsStringAsync().Result);
testmodel.ListaCategoria = Categoria.ToList();
}
public ActionResult BuscarDados(int?IdLancamento, DropDownList dll)
{
try
{
var lancamento = new LancamentoViewModel();
if (IdLancamento.HasValue)
{
var resposta = Requisicao.Get("http://localhost:5000/api/Lancamento?id=" + IdLancamento);
if (!resposta.IsSuccessStatusCode)
{
return(View("Error", "Erro ao buscar dados"));
}
lancamento = JsonConvert.DeserializeObject <LancamentoViewModel>(resposta.Content.ReadAsStringAsync().Result);
}
LoadCategoria(lancamento);
LoadAcao(lancamento);
LoadConta(lancamento);
LoadUsuario(lancamento);
return(View("_Dados", lancamento));
}
catch (Exception ex)
{
return(View("Error:", ex.Message));
}
}
public RetornoViewModel EnviarDinheiro(LancamentoViewModel lancamentoViewModel)
{
try
{
var contaOrigem = _contaCorrenteRepository.GetByNumero(lancamentoViewModel.ContaCorrenteOrigem);
var contaDestino = _contaCorrenteRepository.GetByNumero(lancamentoViewModel.ContaCorrenteDestino);
var lancamento = _mapper.Map <Lancamento>(lancamentoViewModel);
lancamento.DataHora = DateTime.Now;
lancamento.ContaCorrenteId = contaDestino.Id;
_lancamentoRepository.EnviarDinheiro(contaOrigem.Id, lancamento);
return(new RetornoViewModel
{
Message = "Enviado"
});
}
catch (Exception ex)
{
return(new RetornoViewModel
{
Error = true,
Message = ex.ToString()
});
}
}
public RequestResult Add(LancamentoViewModel entidade)
{
var lista = new List <string>();
try
{
entidade.DataInclusao = DateTime.Now.ToString("yyyy-MM-dd hh:MM");
entidade = mapper.Map <LancamentoViewModel>(service.Add(mapper.Map <Lancamento>(entidade)));
var contaOrigem = serviceConta.GetByConta(entidade.ContaOrigem);
var contaDestino = serviceConta.GetByConta(entidade.ContaDestino);
if (contaDestino == null || contaOrigem == null)
{
lista.Add("Conta de Origem ou Destino não localizadas!");
return(new RequestResult(lista, entidade, StatusMensagem.Erro));
}
if (contaOrigem.Saldo < entidade.Valor)
{
lista.Add("Conta de origem não possue saldo suficiente para está transação!");
return(new RequestResult(lista, entidade, StatusMensagem.Erro));
}
contaDestino.Saldo += entidade.Valor;
contaOrigem.Saldo -= entidade.Valor;
var entidadeContaOrigem = serviceConta.Update(contaOrigem);
if (entidadeContaOrigem.ValidationResult.Errors.Any())
{
return(new RequestResult(entidadeContaOrigem.ValidationResult.Errors, entidadeContaOrigem, StatusMensagem.Erro));
}
var entidadeContaDestino = serviceConta.Update(contaDestino);
if (entidadeContaDestino.ValidationResult.Errors.Any())
{
return(new RequestResult(entidadeContaDestino.ValidationResult.Errors, entidadeContaDestino, StatusMensagem.Erro));
}
uow.Commit(entidade.ValidationResult);
if (!entidade.ValidationResult.Errors.Any())
{
lista.Add("Sucesso!");
return(new RequestResult(lista, entidade, StatusMensagem.Ok));
}
else
{
return(new RequestResult(entidade.ValidationResult.Errors, entidade, StatusMensagem.Erro));
}
}
catch (Exception ex)
{
lista.Add(ex.Message.ToString());
return(new RequestResult(lista, entidade, StatusMensagem.Erro));
}
}
public IActionResult Post([FromBody] LancamentoViewModel lancamentoViewModel)
{
var service = new LancamentoService(_lancamentoRepository,
_usuarioRepository,
_folhaPontoRepository);
var retorno = service.InserirLancamento(lancamentoViewModel);
return(Ok());
}
public ActionResult Incluir(LancamentoViewModel model)
{
if (ModelState.IsValid)
{
var lancamento = new Lancamento(model.Descricao, model.Valor, model.Data, model.Categoria, model.LancamentoMensal);
_repositorio.Incluir(lancamento);
return(RedirectToAction("Index"));
}
return(View(model));
}
public IActionResult Post([FromBody] LancamentoViewModel model)
{
try
{
return(Ok(app.Add(model)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public JsonResult Entrada(LancamentoViewModel model)
{
try
{
_lancamentoService.Entrada(_lancamentoMapper.Mapear(model));
return(Json("sucesso"));
}
catch (Exception ex)
{
return(Json(ex.Message));
}
}
public async Task <ActionResult <LancamentoViewModel> > Adicionar(LancamentoViewModel lancamentoViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var lancamento = _mapper.Map <Lancamento>(lancamentoViewModel);
await _lancamentoService.Add(lancamento);
return(CustomResponse(lancamentoViewModel));
}
public async Task <ActionResult <LancamentoViewModel> > Addlancamento(LancamentoViewModel lancamentoViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
lancamentoViewModel =
_mapper.Map <LancamentoViewModel>(
await _lancamentoService.AddLancamento(_mapper.Map <Lancamento>(lancamentoViewModel)));
return(CustomResponse(lancamentoViewModel));
}
public async Task <ActionResult <LancamentoViewModel> > Transferencia([FromBody] LancamentoViewModel lancamentoViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var LancamentoCommand = _mapper.Map <AdicionarLancamentoCommand>(lancamentoViewModel);
await _mediator.Send(LancamentoCommand);
return(CustomResponse(lancamentoViewModel));
}
public async Task <ActionResult <IEnumerable <LancamentoViewModel> > > GetLancamentos()
{
if (User.Identity.IsAuthenticated)
{
var userId = this.GetUsuarioLogado();
List <LancamentoViewModel> lancamentoViewModel = new List <LancamentoViewModel>();
var lista = await(from lanc in _context.Lancamentos
join user in _context.Usuarios on lanc.Usuario.Id equals user.Id
join catl in _context.CategoriaLancamentos on lanc.Id equals catl.LancamentoId
join cate in _context.Categorias on catl.CategoriaId equals cate.Id
join conl in _context.ContaLancamentos on lanc.Id equals conl.LancamentoId
join cont in _context.Contas on conl.ContaId equals cont.Id
where (user.Id == userId)
select new
{
lanc.Id,
lanc.Descricao,
lanc.Valor,
lanc.Data,
lanc.DespesaReceita,
lanc.TipoLancamento,
cate.DescCategoria,
cont.DescConta
}
).OrderBy(x => x.Data).ToListAsync();
foreach (var item in lista)
{
LancamentoViewModel lvm = new LancamentoViewModel();
lvm.Id = item.Id;
lvm.Descricao = item.Descricao;
lvm.Valor = item.Valor;
lvm.Data = item.Data;
lvm.DespesaReceita = item.DespesaReceita;
lvm.TipoLancamento = item.TipoLancamento;
lvm.Categoria = item.DescCategoria;
lvm.Conta = item.DescConta;
lancamentoViewModel.Add(lvm);
}
return(lancamentoViewModel);
}
else
{
return(NotFound());
}
}
private LancamentoViewModel Buscar(int id)
{
var lancamento = _repositorio.Buscar(id);
var model = new LancamentoViewModel()
{
Id = lancamento.Id,
Descricao = lancamento.Descricao,
Valor = lancamento.Valor,
Data = lancamento.Data,
Categoria = lancamento.Categoria,
LancamentoMensal = lancamento.LancamentoMensal
};
return(model);
}
public async Task <IActionResult> CadastrarLancamento([FromBody, SwaggerParameter("Informações de cadastro do lançamento.", Required = true)] LancamentoViewModel model)
{
var entrada = new LancamentoEntrada(
base.ObterIdUsuarioClaim(),
model.IdConta.Value,
model.IdCategoria.Value,
model.Data.Value,
model.Valor.Value,
model.QuantidadeAcoes,
model.IdPessoa,
null,
model.Observacao);
return(new ApiResult(await _lancamentoServico.CadastrarLancamento(entrada)));
}
public JsonResult Saida(LancamentoViewModel model)
{
try
{
if (ModelState.IsValid)
{
_lancamentoService.Saida(_lancamentoMapper.Mapear(model));
return(Json("sucesso"));
}
return(Json("inconsistente"));
}
catch (Exception ex)
{
return(Json(ex.Message));
}
}
public void Update()
{
var lancamentoViewModel = new LancamentoViewModel
{
Ativo = true,
Valor = 1000,
DataInclusao = System.DateTime.Now.ToString("yyyMMdd"),
ContaDestino = "1234567",
ContaOrigem = "7654321",
UsuarioAlteracaoId = 1,
UsuarioInclusaoId = 1
};
var requestResult = app.Update(lancamentoViewModel);
Assert.True(requestResult.Mensagens.Any(), (requestResult.Mensagens.Any() ? requestResult.Mensagens[0] : "Sucesso"));
}
public IActionResult EnviarDinheiro(LancamentoViewModel lancamentoViewModel)
{
var identity = (ClaimsIdentity)User.Identity;
var userId = identity.Claims.ToList()[0].Value;
if (!User.IsInRole("Admin"))
{
if (!_contaCorrenteService.ContaPertenceAoUsuario(userId, lancamentoViewModel.ContaCorrenteOrigem))
{
return(BadRequest("Esta conta não pode ser movimentada por este usuário"));
}
}
return(!ModelState.IsValid
? CustomResponse(ModelState)
: CustomResponse(_contaCorrenteService.EnviarDinheiro(lancamentoViewModel)));
}
public async Task <ActionResult <LancamentoViewModel> > Atualizar(Guid id, LancamentoViewModel lancamentoViewModel)
{
if (id != lancamentoViewModel.Id)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var lancamento = _mapper.Map <Lancamento>(lancamentoViewModel);
await _lancamentoService.Update(lancamento);
return(CustomResponse(lancamentoViewModel));
}
public JsonResult ConsultarUltimoLancamento(int contratoId, int profissionalId)
{
LancamentoViewModel ultimoLancamento = new LancamentoViewModel();
var dominio = _lancamentoService.ConsultarUltimoLancamento(contratoId, profissionalId);
if (dominio != null)
{
ultimoLancamento = _lancamentoMapper.Mapear(dominio);
}
else
{
ultimoLancamento.ContratoID = contratoId;
ultimoLancamento.ProfissionalID = profissionalId;
ultimoLancamento.PermitirEntrada = true;
}
return(Json(ultimoLancamento));
}
/// <summary>
/// Pagina de apontamento de hóras
/// </summary>
/// <returns></returns>
public ActionResult Index()
{
if (!ValidarUsuario())
{
Session["usuario"] = null;
return(RedirectToAction("Index", "Home"));
}
var model = new LancamentoViewModel();
model.ProfissionalID = ((UsuarioViewModel)Session["usuario"]).Profissional.ProfissionalID;
model.Profissional = ((UsuarioViewModel)Session["usuario"]).Profissional;
model.Contratos = new SelectList(_alocacaoService.ListarContratos(model.ProfissionalID), "ContratoID", "DescricaoCompleta", model.ContratoID);
return(View(model));
}
public LancamentoViewModel GerarLancamento()
{
var transf = new LancamentoViewModel()
{
Valor = valor,
ContaOrigem = new ContaOrigemViewModel()
{
Numero = numeroOrigem,
Cpf = cpforigem
},
ContaDestino = new ContaDestinoViewModel()
{
Numero = numeroDestino,
Cpf = cpfDestino
}
};
return(transf);
}
public async Task <ActionResult> Post([FromBody] LancamentoViewModel model)
{
try
{
var validator = new LancamentoValidator();
var result = await validator.ValidateAsync(model);
if (!result.IsValid)
{
return(BadRequest(new ApiBadRequestResponse(result.Errors)));
}
var lancamento = await _lancamentoAppService.Add(model.ToEntity());
return(Created("Lancamento efetuado com sucesso.", new ApiCreatedResponse(lancamento)));
}
catch (Exception ex)
{
throw ex;
}
}
public JsonResult ObterLancamento(int id)
{
try
{
Lancamento lancamento = _lancamentoAppService.GetById(id);
LancamentoViewModel lancamentoViewModel = new LancamentoViewModel();
lancamentoViewModel.LancamentoId = lancamento.Id;
lancamentoViewModel.LancamentoData = lancamento.Data.ToString("dd/MM/yyyy");
lancamentoViewModel.LancamentoDescricao = lancamento.Descricao;
lancamentoViewModel.LancamentoCategoriaId = lancamento.CategoriaId;
lancamentoViewModel.LancamentoTipo = lancamento.Tipo;
lancamentoViewModel.LancamentoValor = lancamento.Valor;
return(Json(lancamentoViewModel, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(new { success = false, responseText = ex.InnerException }, JsonRequestBehavior.AllowGet));
}
}
public List <LancamentoViewModel> TempoParaLancamento()
{
List <LancamentoViewModel> Lancamentos = new List <LancamentoViewModel>();
using (SqlConnection con = new SqlConnection(StringConexao))
{
string Query = "SELECT J.JogoId , J.NomeJogo , J.DataLancamento FROM Jogos J";
con.Open();
SqlDataReader rdr;
using (SqlCommand cmd = new SqlCommand(Query, con))
{
rdr = cmd.ExecuteReader();
while (rdr.Read())
{
LancamentoViewModel lancamento = new LancamentoViewModel
{
JogoId = Convert.ToInt32(rdr["JogoId"]),
NomeJogo = rdr["NomeJogo"].ToString(),
TempoRestante = DateTime.Parse(rdr["DataLancamento"].ToString())
};
Lancamentos.Add(lancamento);
}
;
}
}
foreach (var items in Lancamentos)
{
}
return(Lancamentos);
}
public async Task <IActionResult> Create(LancamentoViewModel lancamentoViewModel)
{
if (!ModelState.IsValid)
{
return(View(lancamentoViewModel));
}
DateTime novaDtaVencimento = lancamentoViewModel.DataVencimento;
for (int i = 0; i <= lancamentoViewModel.QtdeParcela; i++)
{
lancamentoViewModel.Ativo = true;
lancamentoViewModel.DataCadastro = DateTime.Now;
lancamentoViewModel.DataVencimento = novaDtaVencimento.AddMonths(i);
var lancamento = _mapper.Map <Lancamento>(lancamentoViewModel);
await _lancamentoRepository.Adicionar(lancamento);
}
TempData["MensagemSucesso"] = "Salvo com sucesso";
return(RedirectToAction(nameof(Index)));
}
public ActionResult Put(LancamentoViewModel lancamento)
{
try
{
var resposta = Requisicao.Put("http://localhost:5000/api/Lancamento", lancamento);
if (!resposta.IsSuccessStatusCode)
{
Response.StatusCode = 400;
Response.TrySkipIisCustomErrors = true;
return(Content("Erro ao editar lancamento"));
}
Response.StatusCode = 200;
return(Content(""));
}
catch (Exception ex)
{
Response.StatusCode = 500;
Response.TrySkipIisCustomErrors = true;
return(Content(ex.Message));
}
}
public bool InserirLancamento(LancamentoViewModel lancamentoViewModel)
{
var usuario = _usuarioRepository.GetUsuarioLogin(lancamentoViewModel.Login);
var lancamento = new Lancamento();
lancamento.FolhaPonto = new FolhaPonto();
lancamento.FolhaPonto.FlpData = DateTime.Now;
lancamento.FolhaPonto.Usuario = usuario;
if (!_folhaPontoRepository.VerificarExisteFolhaDia(lancamento.FolhaPonto))
{
lancamento.FolhaPonto.FlpData = DateTime.Now;
lancamento.FolhaPonto.FlpTrabalhadas = 0;
lancamento.FolhaPonto.FlpAbonadas = 0;
lancamento.FolhaPonto.FlpHorasPlanoIncentivo = 0;
lancamento.FolhaPonto.FlpEntradas = 0;
lancamento.FolhaPonto.FlpSaidas = 0;
lancamento.FolhaPonto.FlpAbonos = 0;
lancamento.FolhaPonto.FlpCumpriuPlanoIncentivo = false;
_folhaPontoRepository.Add(lancamento.FolhaPonto);
}
lancamento.LanDataHora = DateTime.Now;
lancamento.LanTipo = (ETipoLancamento)Convert.ToInt32(lancamentoViewModel.LanTipo);
lancamento.LanEdicaoManual = false;
lancamento.LanObservacao = "";
_lancamentoRepository.Add(lancamento);
//RecalcularDadosFolhaPonto2018(lancamento);
return(true);
}
public RequestResult Update(LancamentoViewModel entidade)
{
var lista = new List <string>();
try
{
entidade = mapper.Map <LancamentoViewModel>(service.Update(mapper.Map <Lancamento>(entidade)));
uow.Commit(entidade.ValidationResult);
if (!entidade.ValidationResult.Errors.Any())
{
lista.Add("Sucesso!");
return(new RequestResult(lista, entidade, StatusMensagem.Ok));
}
else
{
return(new RequestResult(entidade.ValidationResult.Errors, entidade, StatusMensagem.Erro));
}
}
catch (Exception ex)
{
lista.Add(ex.Message.ToString());
return(new RequestResult(lista, entidade, StatusMensagem.Erro));
}
}