public async Task <user> AddUser(UserDto model)
{
try
{
user usuario = new user();
usuario.nome = model.nome;
usuario.Id = model.Id;
usuario.Setor = model.Setor;
usuario.Cargo = model.Cargo;
usuario.email = model.email;
usuario.Senha = "Senha@123";
EnviarEmailCadastro(usuario.email);
FGeralPersist.Add <user>(usuario);
if (await FGeralPersist.SaveChangesAsync())
{
var userRetorno = await _userPresist.GetAllUserByIdAsync(model.Id);
return(userRetorno);
}
return(null);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <Cotacao> AddCotacaoProduto(int CotacaoId, int SolicitacaoId)
{
try
{
bool salvar = false;
sps = new List <ItemCotacaoDto>();
var solicitacaoProdutos = await _CotacaoPresist.GetAllSolicitacaoProdutoByIdAsync(SolicitacaoId);
foreach (SolicitacaoProduto prod in solicitacaoProdutos)
{
ItemCotacao itemCot = new ItemCotacao();
itemCot.IdSolicitacaoProduto = prod.Id;
itemCot.IdProduto = prod.Produto_Id;
itemCot.QtdeProduto = prod.QtdeProduto;
itemCot.cotacaoId = Cotacao.Id;
itemCot.TotalItem = 0.0;
itemCot.PrecoUnit = 0.0;
FGeralPersist.Add <ItemCotacao>(itemCot);
salvar = await FGeralPersist.SaveChangesAsync();
}
if (salvar)
{
return(await _CotacaoPresist.GetCotacaoByIdAsync(CotacaoId));
}
return(null);
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException.Message);
throw new Exception(ex.Message);
}
}
/// <summary>
/// Adiciona os lotes caso seja um lote novo.
/// </summary>
/// <param name="eventoId"></param>
/// <param name="model"></param>
/// <returns>É um void, ou seja, não precisa de retorno, ou seja, não precisa de informar o objeto dentro do sinal de maior e menor</returns>
public async Task AddLote(int eventoId, LoteDto model)
{
try
{
var lote = _mapper.Map <Lote>(model);//LE-SE: Vai pegar o "model" que é um "Dto", vai mapear ele para um "Lote" e atribuir a variável "var lote".
lote.EventoId = eventoId;
_geralPersist.Add <Lote>(lote);
await _geralPersist.SaveChangesAsync();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <Loja> AddLoja(Loja model)
{
try{
_geralPersist.Add <Loja>(model);
if (await _geralPersist.SaveChangesAsync())
{
return(await _lojaPersist.GetLojaByIdAsync(model.Id));
}
return(null);
}catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <Evento> AddEvento(Evento model)
{
try
{
_geralpersist.Add <Evento>(model);
if (await _geralpersist.SaveChangesAsync())
{
return(await _eventoPersist.GetEventoByIdAsync(model.Id));
}
return(null);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task AddLote(int eventoId, LoteDto model)
{
try
{
var lote = _mapper.Map <Lote>(model);
lote.EventoId = eventoId;
_geralPersist.Add <Lote>(lote);
await _geralPersist.SaveChangesAsync();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <Biblia> Add(Biblia model)
{
try{
model.CreatedAt = DateTime.Now;
model.UpdatedAt = DateTime.Now;
model.IsActive = true;
_geralPersist.Add <Biblia>(model);
if (await _geralPersist.SaveChangesAsync())
{
return(await _geralPersist.GetById(model.Id));
}
return(null);
}catch (Exception e) {
throw new Exception(e.Message);
}
}
public async Task <ItemPedido[]> AddItemPedido(int PedidoId)
{
try
{
var pedido = await _pedidoPresist.GetPedidoByIdAsync(PedidoId);
if (pedido == null)
{
return(null);
}
var itensCotacao = await _pedidoPresist.GetItemCotacaoByIdCotacaoAsync(pedido.cotacaoId);
bool salvar = false;
foreach (ItemCotacao prod in itensCotacao)
{
ItemPedido itemped = new ItemPedido();
itemped.PedidoId = pedido.Id;
itemped.IdProduto = prod.IdProduto;
itemped.QtdeProduto = prod.QtdeProduto;
itemped.PrecoUnit = prod.PrecoUnit;
itemped.TotalItem = prod.TotalItem;
itemped.itemCotacaoId = prod.Id;
FGeralPersist.Add <ItemPedido>(itemped);
if (await FGeralPersist.SaveChangesAsync())
{
salvar = true;
}
else
{
salvar = false;
}
}
if (salvar == true)
{
return(await _pedidoPresist.GetAllItemPedidoByIdPedidosync(PedidoId));
}
return(null);
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException.Message);
throw new Exception(ex.Message);
}
}
public async Task <Evento> AddEvento(Evento model)
{
try
{
_geralPersist.Add <Evento>(model);
if (await _geralPersist.SaveChangesAsync()) //SaveChangesAsync() == true -> Faz o IF
{
return(await _eventoPersist.GetEventoByIdAsync(model.Id, false)); //Se foi adicionado, retorno o ID do evento(model) após a adição
}
return(null);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <Solicitacao> CreateSolicitacao(int userId, SolicitacaoDTO model)
{
try
{
var user = await _SolicitacaoPresist.GetAllUserByIdAsync(userId);
solicitacao = new Solicitacao();
solicitacao.Observacao = model.Observacao;
var dataN = model.DataNecessidade;
solicitacao.DataNecessidade = dataN;
var data = model.DataSolicitacao;
solicitacao.DataSolicitacao = data;
solicitacao.user_id = user.Id;
solicitacao.StatusAprovacao = model.StatusAprovacao;
FGeralPersist.Add <Solicitacao>(solicitacao);
if (await FGeralPersist.SaveChangesAsync())
{
var SolicitacaoRetorno = await _SolicitacaoPresist.GetAllSolicitacaoByIdAsync(solicitacao.Id);
return(SolicitacaoRetorno);
}
return(null);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <Info> Update(Info model)
{
try
{
var oldResult = await _geralPersist.GetInfo();
model.UpdatedAt = DateTime.Now;
_geralPersist.Update <Info>(model);
if (await _geralPersist.SaveChangesAsync())
{
return(await _geralPersist.GetInfo());
}
return(null);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public async Task <Fornecedor> AddFornecedor(FornecedorDto model)
{
try
{
Fornecedor fornecedor = new Fornecedor();
fornecedor.CNPJ = model.CNPJ;
fornecedor.Nome = model.Nome;
fornecedor.Cidade = model.Cidade;
fornecedor.Endereco = model.Endereco;
fornecedor.Bairro = model.Bairro;
fornecedor.Numero = model.Numero;
fornecedor.Complemento = model.Complemento;
fornecedor.Estado = model.Estado;
fornecedor.CEP = model.CEP;
fornecedor.InscricaoMunicipal = model.InscricaoMunicipal;
fornecedor.InscricaoEstadual = model.InscricaoEstadual;
fornecedor.Email = model.Email;
fornecedor.Telefone = model.Telefone;
fornecedor.Celular = model.Celular;
fornecedor.PontuacaoRanking = model.PontuacaoRanking;
fornecedor.FamiliaProdutoId = model.FamiliaProdutoId;
fornecedor.Senha = "for@123";
int lastPosiciao = await TheLastPosition(fornecedor.FamiliaProdutoId);
fornecedor.Posicao = lastPosiciao + 1;
FGeralPersist.Add <Fornecedor>(fornecedor);
EnviarEmailCadastro(fornecedor.Email);
if (await FGeralPersist.SaveChangesAsync())
{
var FornecedorRetorno = await _FornecedorPresist.GetAllFornecedorByIdAsync(fornecedor.Id);
return(FornecedorRetorno);
}
return(null);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <EventoDto> AddEventos(EventoDto model)
{
try
{
var evento = _mapper.Map <Evento>(model);//LE-SE: Vai pegar o "model" que é um "Dto", vai mapear ele para um "Evento" e atribuir a variável "var evento".
_geralPersist.Add <Evento>(evento);
if (await _geralPersist.SaveChangesAsync())
{
var eventoRetorno = await _eventoPersist.GetEventoByIdAsync(evento.Id, false);
//Faz o mapeamento ao contrário, adicionando o ".ReverseMap()" em ProEventosProfile, fazendo o invérso.
return(_mapper.Map <EventoDto>(eventoRetorno));// LE-SE: Mapeado o evento de retorno para o meu Dto.
}
return(null);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <EventoDto> AddEvento(EventoDto model)
{
try
{
var evento = _mapper.Map <Evento>(model);
_geralPersist.Add <Evento>(evento);
if (await _geralPersist.SaveChangesAsync())
{
var eventoRetorno = await _eventoPersist.GetEventoByIdAsync(evento.Id, false);
return(_mapper.Map <EventoDto>(eventoRetorno));
}
return(null);
}
catch (Exception err)
{
throw new Exception(err.Message);
}
}
public async Task <Evento> AddEventos(Evento model)
{
try
{
//adiciono a model do método para o geralPersist
_geralPersist.Add <Evento>(model);
//se a model for salva
if (await _geralPersist.SaveChangesAsync())
{
//retornar o evento pelo id da model
return(await _eventoPersist.GetEventoByIdAsync(model.Id, false));
}
//se não, retorna nulo
return(null);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <LoteDto[]> SaveLotes(int eventoId, LoteDto[] models)
{
try
{
var lotes = await _lotePersist.GetLotesByEventoIdAsync(eventoId);
if (lotes == null)
{
return(null);
}
foreach (var model in models)
{
if (model.Id == 0)
{
await AdicionarLote(eventoId, model);
}
else
{
var lote = lotes.FirstOrDefault(lote => lote.Id == model.Id);
model.EventoId = eventoId;
_mapper.Map(model, lote);
_geralPersist.Upadate <Lote>(lote);
await _geralPersist.SaveChangesAsync();
}
}
var loteRetorno = await _lotePersist.GetLotesByEventoIdAsync(eventoId);
return(_mapper.Map <LoteDto[]>(loteRetorno));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}