public async Task <IActionResult> Create([FromBody] ContaContabil contaContabil)
{
try
{
bool usuarioExists = await context.Usuario.AnyAsync(u => u.Id.Equals(contaContabil.UsuarioId));
if (usuarioExists)
{
bool contaExists = await context.ContaContabil.AnyAsync(c => c.Nome.Equals(contaContabil.Nome) && c.UsuarioId.Equals(contaContabil.UsuarioId));
if (!contaExists)
{
context.ContaContabil.Add(contaContabil);
await context.SaveChangesAsync();
return(CreatedAtAction("Create", contaContabil));
}
else
{
ModelState.AddModelError("Nome", "Esse nome de conta já esta sendo utilizado");
return(BadRequest(ModelState.Values.SelectMany(e => e.Errors)));
}
}
else
{
ModelState.AddModelError("Usuario", "Usuário não cadastrado no sistema.");
return(NotFound(ModelState.Values.SelectMany(e => e.Errors)));
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> Create([FromBody] GrupoMovimentacoes grupo)
{
try
{
var usuarioExists = await context.Usuario.AnyAsync(u => u.Id.Equals(grupo.UsuarioId));
if (usuarioExists)
{
var nomeExists = await context.GrupoMovimentacoes.AnyAsync(g => g.Nome.Equals(grupo.Nome) && g.UsuarioId.Equals(grupo.UsuarioId));
if (!nomeExists)
{
context.GrupoMovimentacoes.Add(grupo);
await context.SaveChangesAsync();
return(CreatedAtAction("Create", grupo));
}
else
{
ModelState.AddModelError("Nome", "Esse nome de grupo de movimentações já esta sendo utilizado");
return(BadRequest(ModelState.Values.SelectMany(e => e.Errors)));
}
}
else
{
ModelState.AddModelError("Usuario", "Usuário não cadastrado no sistema.");
return(NotFound(ModelState.Values.SelectMany(e => e.Errors)));
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> Create([FromBody] Movimentacao movimentacao)
{
try
{
var conta = await context.ContaContabil.FirstOrDefaultAsync(c => c.Id.Equals(movimentacao.ContaContabilId));
if (conta != null)
{
bool usuarioExists = await context.Usuario.AnyAsync(u => u.Id.Equals(conta.UsuarioId));
if (usuarioExists)
{
if (movimentacao.TipoMovimentacao == TipoMovimentacao.Receita)
{
conta.Saldo += movimentacao.Valor;
}
else if (movimentacao.TipoMovimentacao == TipoMovimentacao.Despesa)
{
if (VerificarSaldo(conta, movimentacao.Valor))
{
conta.Saldo -= movimentacao.Valor;
}
else
{
ModelState.AddModelError("Conta", "Saldo insuficiente.");
return(BadRequest(ModelState.Values.SelectMany(e => e.Errors)));
}
}
else
{
ModelState.AddModelError("Movimentação", "Informe um tipo de movimentação válido");
return(BadRequest(ModelState.Values.SelectMany(e => e.Errors)));
}
context.Movimentacao.Add(movimentacao);
context.ContaContabil.Update(conta);
await context.SaveChangesAsync();
return(CreatedAtAction("Create", movimentacao));
}
else
{
ModelState.AddModelError("Usuario", "Usuário não cadastrado no sistema.");
return(NotFound(ModelState.Values.SelectMany(e => e.Errors)));
}
}
else
{
ModelState.AddModelError("Conta", "Conta não cadastrada no sistema.");
return(NotFound(ModelState.Values.SelectMany(e => e.Errors)));
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> Create([FromBody] Investimento investimento)
{
try
{
bool usuarioExists = await context.Usuario.AnyAsync(u => u.Id.Equals(investimento.UsuarioId));
if (usuarioExists)
{
investimento.UltimaAtualizacao = investimento.DataInicio;
context.Investimento.Add(investimento);
await context.SaveChangesAsync();
return(CreatedAtAction("Create", investimento));
}
else
{
ModelState.AddModelError("Usuario", "Usuário não cadastrado no sistema.");
return(NotFound(ModelState.Values.SelectMany(e => e.Errors)));
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> UpdateCotacoes([FromBody] Moeda moeda)
{
try
{
var moedaAux = await context.Moeda.AsNoTracking().FirstOrDefaultAsync(m => m.Nome.Equals(moeda.Nome));
if (moedaAux != null)
{
moeda.Id = moedaAux.Id;
moedaAux = moeda;
context.Moeda.Update(moedaAux);
}
else
{
context.Moeda.Add(moeda);
}
await context.SaveChangesAsync();
return(Ok(moeda));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> EditPerfil([FromRoute] string id, [FromBody] Perfil perfil)
{
try
{
Usuario usuario = await context.Usuario
.Include(u => u.Perfil)
.FirstOrDefaultAsync(u => u.Id.Equals(id));
if (usuario != null)
{
//Caso o usuário não tenha um perfil, é necessário uma instancia, para poder passar os valores
if (usuario.Perfil == null)
{
usuario.Perfil = new Perfil();
}
//Se passar o objeto inteiro, o entity framework ignora o antigo e cria um novo perfil, com nova ID
usuario.Perfil.Valor = perfil.Valor;
usuario.Perfil.MoedaId = perfil.MoedaId;
usuario.Perfil.RendaFixa = perfil.RendaFixa;
usuario.Perfil.Profissao = perfil.Profissao;
usuario.Perfil.FaixaEtaria = perfil.FaixaEtaria;
usuario.Perfil.EscalaTempo = perfil.EscalaTempo;
usuario.Perfil.Escolaridade = perfil.Escolaridade;
usuario.Perfil.Filhos = perfil.Filhos;
context.Usuario.Update(usuario);
//Retorna as informações corretas da moeda aplicada ao perfil
usuario.Perfil.Moeda = await context.Moeda.FirstOrDefaultAsync(m => m.Id.Equals(usuario.Perfil.MoedaId));
await context.SaveChangesAsync();
return(Ok(usuario));
}
else
{
ModelState.AddModelError("Usuario", "Usuário não encontrado");
}
return(BadRequest(ModelState.Values.SelectMany(v => v.Errors)));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> Create([FromBody] Objetivo objetivo)
{
try
{
var usuarioExists = await context.Usuario.AnyAsync(u => u.Id == objetivo.UsuarioId);
if (!usuarioExists)
{
ModelState.AddModelError("Usuario", "Usuário não encontrado");
return(NotFound(ModelState.Values.SelectMany(v => v.Errors)));
}
var moedaExists = await context.Moeda.AnyAsync(m => m.Id == objetivo.MoedaId);
if (!moedaExists)
{
ModelState.AddModelError("Usuario", "Moeda não encontrada");
return(NotFound(ModelState.Values.SelectMany(v => v.Errors)));
}
context.Objetivo.Add(objetivo);
await context.SaveChangesAsync();
return(CreatedAtAction("Create", objetivo));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> Create([FromBody] Configuracoes config)
{
try
{
bool usuarioExists = await context
.Users
.AnyAsync(u => u.Id.Equals(config.UsuarioId));
if (usuarioExists)
{
var usuarioHasConfig = await context
.Configuracoes
.AnyAsync(cfg => cfg.UsuarioId.Equals(config.UsuarioId));
if (!usuarioHasConfig)
{
context.Configuracoes.Add(config);
await context.SaveChangesAsync();
return(CreatedAtAction("Create", config));
}
else
{
ModelState.AddModelError(
"Configuracoes", "Configurações de usuário já existentes."
);
return(BadRequest(ModelState.Values.SelectMany(v => v.Errors)));
}
}
else
{
ModelState.AddModelError(
"Usuario", "Usuário não cadastrado no sistema."
);
return(NotFound(ModelState.Values.SelectMany(v => v.Errors)));
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}