public async Task <IActionResult> Create([FromBody] ProdutoResource produtoResource)
{
if (produtoResource == null)
{
return(NotFound());
}
try
{
var produto = new Produto();
if (ModelState.IsValid)
{
produto = ProdutoMapper.ResourceToModel(produtoResource, produto);
}
_unitOfWork.Produtos.Add(produto);
//var carrinhoDeCompra = await _unitOfWork.CarrinhoDeCompras.GetByIdAsync(produto.CarrinhoDeCompraId);
//CarrinhoDeCompraMapper
// .ResourceToModel(CarrinhoDeCompraMapper.ModelToResource(carrinhoDeCompra), carrinhoDeCompra);
await _unitOfWork.CompleteAsync();
return(Ok(produto));
}
catch (Exception exception)
{
LogError.LogErrorWithSentry(exception);
return(BadRequest());
}
}
public async Task <IActionResult> GetAll()
{
try
{
var carrinhoDeCompras = await _unitOfWork.CarrinhoDeCompras.GetAllWithProdutosAsync();
List <CarrinhoDeCompraResource> carrinhoDeCompraResource = new List <CarrinhoDeCompraResource>();
if (carrinhoDeCompras == null)
{
return(NoContent());
}
foreach (var carrinhoDeCompra in carrinhoDeCompras)
{
if (carrinhoDeCompra.IsAtivo)
{
carrinhoDeCompraResource.Add(CarrinhoDeCompraMapper.ModelToResource(carrinhoDeCompra));
}
}
return(Ok(carrinhoDeCompraResource));
}
catch (Exception exception)
{
LogError.LogErrorWithSentry(exception);
return(BadRequest());
}
}
public async Task <IActionResult> Delete(int id)
{
try
{
var usuario = await _unitOfWork.Usuarios.GetByIdAsync(id);
if (usuario == null)
{
return(BadRequest("Não existe usuario com este Id"));
}
else
{
usuario.IsAtivo = false;
await _unitOfWork.CompleteAsync();
return(Ok(usuario));
}
}
catch (Exception e)
{
LogError.LogErrorWithSentry(e);
return(BadRequest());
}
}
public async Task <IActionResult> GetAll()
{
try
{
var contas = await _unitOfWork.Contas.GetAllContaWithPagarEReceberEUsuario();
List <ContaResource> contaResource = new List <ContaResource>();
if (contas == null)
{
return(NoContent());
}
foreach (var conta in contas)
{
if (conta.IsAtivo)
{
contaResource.Add(ContaMapper.ModelToResource(conta));
}
}
return(Ok(contaResource));
}
catch (Exception exception)
{
LogError.LogErrorWithSentry(exception);
return(BadRequest());
}
}
public async Task <IActionResult> Create([FromBody] RepublicaResource republicaResource)
{
if (republicaResource == null)
{
return(NotFound());
}
try
{
var republica = new Republica();
if (ModelState.IsValid)
{
republica = RepublicaMapper.ResourceToModel(republicaResource, republica);
}
_unitOfWork.Republicas.Add(republica);
await _unitOfWork.CompleteAsync();
RepublicaMapper.ModelToResource(republica);
return(Ok(republica));
}
catch (Exception exception)
{
LogError.LogErrorWithSentry(exception);
return(BadRequest());
}
}
public async Task <IActionResult> Create([FromBody] ContaResource contaResource)
{
if (contaResource == null)
{
return(NotFound());
}
try
{
var conta = new Conta();
if (ModelState.IsValid)
{
conta = ContaMapper.ResourceToModel(contaResource, conta);
}
_unitOfWork.Contas.Add(conta);
await _unitOfWork.CompleteAsync();
Usuario u = await _unitOfWork.Usuarios.GetByIdAsync(conta.UsuarioId);
u.ContaId = conta.Id;
_unitOfWork.Usuarios.Update(u);
await _unitOfWork.CompleteAsync();
ContaMapper.ModelToResource(conta);
return(Ok(conta));
}
catch (Exception exception)
{
LogError.LogErrorWithSentry(exception);
return(BadRequest());
}
}
public async Task <IActionResult> Create([FromBody] AvisoResource avisoResource)
{
if (avisoResource == null)
{
return(NotFound());
}
try
{
var aviso = new Aviso();
if (ModelState.IsValid)
{
aviso = AvisoMapper.ResourceToModel(avisoResource, aviso);
}
_unitOfWork.Avisos.Add(aviso);
await _unitOfWork.CompleteAsync();
return(Ok(aviso));
}
catch (Exception exception)
{
LogError.LogErrorWithSentry(exception);
return(BadRequest());
}
}
public async Task <IActionResult> Create([FromBody] TarefaResource tarefaResource)
{
if (tarefaResource == null)
{
return(NotFound());
}
try
{
var tarefa = new Tarefa();
if (ModelState.IsValid)
{
tarefa = TarefaMapper.ResourceToModel(tarefaResource, tarefa);
}
_unitOfWork.Tarefas.Add(tarefa);
await _unitOfWork.CompleteAsync();
TarefaMapper.ModelToResource(tarefa);
return(Ok(tarefa));
}
catch (Exception exception)
{
LogError.LogErrorWithSentry(exception);
return(BadRequest());
}
}
public async Task <IActionResult> Create([FromBody] UsuarioResource usuarioResource)
{
if (usuarioResource == null)
{
return(NotFound());
}
try
{
var usuario = new Usuario();
var listOfUsuarioRoles = new List <UsuarioRole>();
if (ModelState.IsValid)
{
usuario = UsuarioMapper.ResourceToModel(usuarioResource, usuario);
}
_unitOfWork.Usuarios.Add(usuario);
await _unitOfWork.CompleteAsync();
foreach (int roleId in usuarioResource.RoleIds)
{
listOfUsuarioRoles.Add(new UsuarioRole()
{
RoleId = roleId,
UsuarioId = usuario.Id
});
}
_unitOfWork.UsuarioRoles.AddRange(listOfUsuarioRoles);
await _unitOfWork.CompleteAsync();
UsuarioMapper.ModelToResource(usuario);
return(Ok(usuario));
}
catch (Exception exception)
{
LogError.LogErrorWithSentry(exception);
return(BadRequest());
}
}
public async Task <IActionResult> Delete(int id)
{
try
{
var tarefa = await _unitOfWork.Tarefas.GetByIdAsync(id);
if (tarefa != null)
{
tarefa.IsAtivo = false;
}
await _unitOfWork.CompleteAsync();
return(Ok(tarefa));
}
catch (Exception e)
{
LogError.LogErrorWithSentry(e);
return(BadRequest());
}
}
public async Task <IActionResult> Delete(int id)
{
try
{
var produto = await _unitOfWork.Produtos.GetByIdAsync(id);
if (produto != null)
{
produto.IsAtivo = false;
}
await _unitOfWork.CompleteAsync();
return(Ok(produto));
}
catch (Exception e)
{
LogError.LogErrorWithSentry(e);
return(BadRequest());
}
}
public async Task <IActionResult> Delete(int id)
{
try
{
var contaAReceber = await _unitOfWork.ContasAReceber.GetByIdAsync(id);
if (contaAReceber != null)
{
contaAReceber.IsAtivo = false;
}
await _unitOfWork.CompleteAsync();
return(Ok(contaAReceber));
}
catch (Exception e)
{
LogError.LogErrorWithSentry(e);
return(BadRequest());
}
}
public async Task <IActionResult> Edit(int id, [FromBody] TipoContaResource tipoContaResource)
{
try
{
var tipoConta = await _unitOfWork.TipoContas.GetByIdAsync(id);
if (ModelState.IsValid)
{
tipoConta = TipoContaMapper.ResourceToModel(tipoContaResource, tipoConta);
await _unitOfWork.CompleteAsync();
TipoContaMapper.ModelToResource(tipoConta);
}
return(Ok(tipoConta));
}
catch (Exception e)
{
LogError.LogErrorWithSentry(e);
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> Edit(int id, [FromBody] TarefaUsuarioResource tarefaUsuarioResource)
{
try
{
var tarefaUsuario = await _unitOfWork.TarefasUsuario.GetByIdWithTarefaEUsuarioAsync(id, id);
if (ModelState.IsValid)
{
tarefaUsuario = TarefaUsuarioMapper.ResourceToModel(tarefaUsuarioResource, tarefaUsuario);
await _unitOfWork.CompleteAsync();
TarefaUsuarioMapper.ModelToResource(tarefaUsuario);
}
return(Ok());
}
catch (Exception e)
{
LogError.LogErrorWithSentry(e);
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> Edit(int id, [FromBody] AvisoResource avisoResource)
{
try
{
var aviso = await _unitOfWork.Avisos.GetByIdAsync(id);
if (ModelState.IsValid)
{
aviso = AvisoMapper.ResourceToModel(avisoResource, aviso);
await _unitOfWork.CompleteAsync();
AvisoMapper.ModelToResource(aviso);
}
return(Ok(aviso));
}
catch (Exception e)
{
LogError.LogErrorWithSentry(e);
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> Edit(int id, [FromBody] ProdutoResource produtoResource)
{
try
{
var produto = await _unitOfWork.Produtos.GetByIdAsync(id);
if (ModelState.IsValid)
{
produto = ProdutoMapper.ResourceToModel(produtoResource, produto);
await _unitOfWork.CompleteAsync();
ProdutoMapper.ModelToResource(produto);
}
return(Ok(produto));
}
catch (Exception e)
{
LogError.LogErrorWithSentry(e);
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> Edit(int id, [FromBody] CarrinhoDeCompraResource carrinhoDeCompraResource)
{
try
{
var carrinhoDeCompra = await _unitOfWork.CarrinhoDeCompras.GetByIdAsync(id);
if (ModelState.IsValid)
{
carrinhoDeCompra = CarrinhoDeCompraMapper.ResourceToModel(carrinhoDeCompraResource, carrinhoDeCompra);
await _unitOfWork.CompleteAsync();
CarrinhoDeCompraMapper.ModelToResource(carrinhoDeCompra);
}
return(Ok(carrinhoDeCompra));
}
catch (Exception e)
{
LogError.LogErrorWithSentry(e);
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> Edit(int id, [FromBody] RepublicaResource republicaResource)
{
try
{
var republica = await _unitOfWork.Republicas.GetByIdAsync(id);
if (ModelState.IsValid)
{
republica = RepublicaMapper.ResourceToModel(republicaResource, republica);
await _unitOfWork.CompleteAsync();
RepublicaMapper.ModelToResource(republica);
}
return(Ok(republica));
}
catch (Exception e)
{
LogError.LogErrorWithSentry(e);
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> Edit(int id, [FromBody] UsuarioResource usuarioResource)
{
try
{
var usuario = await _unitOfWork.Usuarios.GetByIdAsync(id);
if (ModelState.IsValid)
{
usuario = UsuarioMapper.ResourceToModel(usuarioResource, usuario);
await _unitOfWork.CompleteAsync();
UsuarioMapper.ModelToResource(usuario);
}
return(Ok(usuario));
}
catch (Exception e)
{
LogError.LogErrorWithSentry(e);
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> Edit(int id, [FromBody] ContaAReceberResource contaAReceberResource)
{
try
{
var contaAReceber = await _unitOfWork.ContasAReceber.GetByIdAsync(id);
if (ModelState.IsValid)
{
contaAReceber = ContaAReceberMapper.ResourceToModel(contaAReceberResource, contaAReceber);
await _unitOfWork.CompleteAsync();
contaAReceber.TipoConta = await _unitOfWork.TipoContas.GetByIdAsync(contaAReceber.TipoContaId);
ContaAReceberMapper.ModelToResource(contaAReceber);
}
return(Ok(contaAReceber));
}
catch (Exception e)
{
LogError.LogErrorWithSentry(e);
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> Create([FromBody] ContaAReceberResource contaAReceberResource)
{
if (contaAReceberResource == null)
{
return(NotFound());
}
try
{
var contaAReceber = new ContaAReceber();
if (ModelState.IsValid)
{
contaAReceber = ContaAReceberMapper.ResourceToModel(contaAReceberResource, contaAReceber);
}
_unitOfWork.ContasAReceber.Add(contaAReceber);
await _unitOfWork.CompleteAsync();
return(Ok(contaAReceber));
}
catch (Exception exception)
{
LogError.LogErrorWithSentry(exception);
return(BadRequest());
}
}
public async Task <IActionResult> Create([FromBody] CarrinhoDeCompraResource carrinhoDeCompraResource)
{
if (carrinhoDeCompraResource == null)
{
return(NotFound());
}
try
{
var carrinhoDeCompra = new CarrinhoDeCompra();
if (ModelState.IsValid)
{
carrinhoDeCompra = CarrinhoDeCompraMapper.ResourceToModel(carrinhoDeCompraResource, carrinhoDeCompra);
}
_unitOfWork.CarrinhoDeCompras.Add(carrinhoDeCompra);
await _unitOfWork.CompleteAsync();
return(Ok(carrinhoDeCompra));
}
catch (Exception exception)
{
LogError.LogErrorWithSentry(exception);
return(BadRequest());
}
}
