public async Task <ActionResult <FornecedorDto> > Adicionar(FornecedorDto fornecedorDto)
{
//obtendo o nome do usuário autenticado antes da implementação na MainController
//if (User.Identity.IsAuthenticated)
//{
// var userName = User.Identity.Name;
//}
//obtendo o nome do usuário autenticado depois da implementação na MainController
//if (UsuarioAutenticado)
//{
// var nomeUser = AppUser.Name;
// var nomeEmail = AppUser.GetUserEmail();
// var userId = AppUser.GetUserId();
// var userId2 = UsuarioId;
//}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Adicionar(_mapper.Map <Fornecedor>(fornecedorDto));
return(CustomResponse(fornecedorDto));
//Antes de customizar as mensagens
//var fornecedor = _mapper.Map<Fornecedor>(fornecedorDto);
//var result = await _fornecedorService.Adicionar(fornecedor);
//if (!result) return BadRequest();
//return Ok(fornecedor);
}
/// <summary>
/// Converte um fornecedor de Model para Dto
/// </summary>
/// <param name="fornecedorDto"></param>
/// <param name="mensagemErro"></param>
/// <returns></returns>
public bool ConverterModelParaDto(ref FornecedorDto fornecedorDto, ref string mensagemErro)
{
try
{
fornecedorDto.Cnpj = string.IsNullOrWhiteSpace(Cnpj) ? "" : Cnpj.Trim().Replace(".", "").Replace("-", "").Replace("-", "");
fornecedorDto.ComplementoEndereco = string.IsNullOrWhiteSpace(ComplementoEndereco) ? "" : ComplementoEndereco.Trim();
fornecedorDto.NomeFantasia = string.IsNullOrWhiteSpace(NomeFantasia) ? "" : NomeFantasia.Trim();
fornecedorDto.NumeroEndereco = string.IsNullOrWhiteSpace(NumeroEndereco) ? "" : NumeroEndereco.Trim();
fornecedorDto.Obs = string.IsNullOrWhiteSpace(Obs) ? "" : Obs.Trim();
fornecedorDto.RazaoSocial = string.IsNullOrWhiteSpace(RazaoSocial) ? "" : RazaoSocial.Trim();
fornecedorDto.Telefone = string.IsNullOrWhiteSpace(Telefone) ? "" : Telefone.Trim();
fornecedorDto.DataAlteracao = this.DataAlteracao;
fornecedorDto.DataInclusao = this.DataInclusao;
fornecedorDto.Id = this.Id;
fornecedorDto.Inativo = this.Inativo;
fornecedorDto.Endereco.Bairro = string.IsNullOrWhiteSpace(Endereco.Bairro) ? "" : Endereco.Bairro.Trim();
fornecedorDto.Endereco.Cep = string.IsNullOrWhiteSpace(Endereco.Cep) ? "" : Endereco.Cep.Trim().Replace("-", "");
fornecedorDto.Endereco.Cidade = string.IsNullOrWhiteSpace(Endereco.Cidade) ? "" : Endereco.Cidade.Trim();
fornecedorDto.Endereco.Logradouro = string.IsNullOrWhiteSpace(Endereco.Logradouro) ? "" : Endereco.Logradouro.Trim();
fornecedorDto.Endereco.Id = Endereco.Id;
return(true);
}
catch (Exception ex)
{
mensagemErro = ex.Message;
return(false);
}
}
public ActionResult Editar(FornecedorModel model)
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
if (!SessaoUsuario.SessaoLogin.Administrador)
{
ViewBag.MensagemErro = "Para editar um fornecedor é necessário " +
$"logar com um fornecedor administrador.";
return(View("SemPermissao"));
}
//Valida a entidade recebida
if (!ModelState.IsValid)
{
return(View(model));
}
//Converte para DTO
FornecedorDto fornecedorDto = new FornecedorDto();
string mensagemErro = "";
if (!model.ConverterModelParaDto(ref fornecedorDto, ref mensagemErro))
{
ViewBag.MensagemErro = mensagemErro;
return(View("Erro"));
}
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoEntidadeDto <FornecedorDto> requisicaoDto = new RequisicaoEntidadeDto <FornecedorDto>()
{
EntidadeDto = fornecedorDto,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
FornecedorBll fornecedorBll = new FornecedorBll(true);
fornecedorBll.Editar(requisicaoDto, ref retorno);
//Tratar o retorno
if (retorno.Retorno == false)
{
ModelState.AddModelError("", retorno.Mensagem);
return(View(model));
}
TempData["Retorno"] = "ALTERADO";
//Voltar para o visualizar do fornecedor
return(RedirectToAction("Index"));
}
public IActionResult CreateOrEdit(FornecedorViewModel model)
{
FornecedorDto dto = new FornecedorDto();
SetPropriy(model, dto);
_fornecedorstore.Store(dto);
return(RedirectToAction("Index"));
}
public IActionResult EditarFornecedor(int id)
{
var fornecedor = database.Fornecedores.First(forne => forne.Id == id);
FornecedorDto fornecedorView = new FornecedorDto();
fornecedorView.Id = fornecedor.Id;
fornecedorView.Nome = fornecedor.Nome;
fornecedorView.Email = fornecedor.Email;
fornecedorView.Telefone = fornecedor.Telefone;
return(View(fornecedorView));
}
public async Task <ActionResult <FornecedorDto> > Adicionar(FornecedorDto fornecedorDto)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Adicionar(_mapper.Map <Fornecedor>(fornecedorDto));
return(CustomResponse(fornecedorDto));
}
public IActionResult Put(int id, [FromBody] FornecedorDto value)
{
try
{
_cadastros.AlterarFornecedor(id, value);
return(Ok());
}
catch (EntityValidationException e)
{
return(BadRequest(e.Erros));
}
}
public IHttpActionResult PorId(int id)
{
var fornecedor = _fornecedorRepository.GetById(id);
FornecedorDto fornecedorDto = null;
if (fornecedor == null)
{
return(NotFound());
}
fornecedorDto = Mapper.Map <Fornecedor, FornecedorDto>(fornecedor);
return(Ok(fornecedorDto));
}
public void Gravar(FornecedorDto fornecedorDto)
{
Fornecedor fornecedor = Mapper.Map <FornecedorDto, Fornecedor>(fornecedorDto);
if (fornecedor != null && fornecedor.FornecedorId > 0)
{
_fornecedorRepository.Update(fornecedor);
}
else
{
_fornecedorRepository.Add(fornecedor);
}
}
public void AlterarFornecedor(long id, FornecedorDto fornecedor)
{
var fornecedorExistente = _repository.GetById <Fornecedor>(id);
fornecedorExistente.Cnpj = fornecedor.Cnpj ?? fornecedorExistente.Cnpj;
fornecedorExistente.Cpf = fornecedor.Cpf ?? fornecedorExistente.Cpf;
fornecedorExistente.Rg = fornecedor.Rg ?? fornecedorExistente.Rg;
fornecedorExistente.Nome = fornecedor.Nome ?? fornecedorExistente.Nome;
fornecedorExistente.Telefones = fornecedor.Telefones.Any() ? string.Join(';', fornecedor.Telefones) : fornecedorExistente.Telefones;
fornecedorExistente.DataDeNascimento = fornecedor.DataDeNascimento ?? fornecedorExistente.DataDeNascimento;
_repository.SaveOrUpdate(fornecedorExistente);
}
public void Store(FornecedorDto dto)
{
var fornecedor = _fornecedorRepository.GetById(dto.ID);
if (fornecedor == null)
{
fornecedor = new Fornecedor(dto.NOMEFANTASIA, dto.RAZAOSOCIAL, dto.CPFCNPJ, dto.EMAIL, dto.TELEFONE, dto.CELULAR, dto.CEP, dto.ENDERECO, dto.NUMERO, dto.BAIRRO, dto.CIDADE, dto.ESTADO, dto.PAIS);
_fornecedorRepository.Save(fornecedor);
}
else
{
fornecedor.Update(dto.NOMEFANTASIA, dto.RAZAOSOCIAL, dto.CPFCNPJ, dto.EMAIL, dto.TELEFONE, dto.CELULAR, dto.CEP, dto.ENDERECO, dto.NUMERO, dto.BAIRRO, dto.CIDADE, dto.ESTADO, dto.PAIS);
_fornecedorRepository.Save(fornecedor);
}
}
private static void SetPropriy(FornecedorViewModel model, FornecedorDto dto)
{
dto.ID = model.ID;
dto.NOMEFANTASIA = model.NOMEFANTASIA;
dto.RAZAOSOCIAL = model.RAZAOSOCIAL;
dto.CPFCNPJ = model.CPFCNPJ;
dto.TELEFONE = model.TELEFONE;
dto.CELULAR = model.CELULAR;
dto.EMAIL = model.EMAIL;
dto.CEP = model.CEP;
dto.ENDERECO = model.ENDERECO;
dto.NUMERO = model.NUMERO;
dto.BAIRRO = model.BAIRRO;
dto.CIDADE = model.CIDADE;
dto.ESTADO = model.ESTADO;
dto.PAIS = model.PAIS;
}
public async Task <ActionResult <FornecedorDto> > Adicionar(FornecedorDto fornecedorDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorDto);
var result = await _fornecedorService.Adicionar(fornecedor);
if (!result)
{
return(BadRequest());
}
return(Ok(fornecedor));
}
public IActionResult Atualizar(FornecedorDto dadosTemporario)
{
if (ModelState.IsValid)
{
var fornecedor = database.Fornecedores.First(forne => forne.Id == dadosTemporario.Id);
fornecedor.Id = dadosTemporario.Id;
fornecedor.Nome = dadosTemporario.Nome;
fornecedor.Email = dadosTemporario.Email;
fornecedor.Telefone = dadosTemporario.Telefone;
database.SaveChanges();
return(RedirectToAction("ListarFornecedor", "Gestao"));
}
else
{
return(View("../Gestao/EditarFornecedor"));
}
}
public async Task <ActionResult <FornecedorDto> > Atualizar(Guid id, FornecedorDto fornecedorDto)
{
if (id != fornecedorDto.Id)
{
NotificarErro("O id informado não é o mesmo que foi passado na query.");
return(CustomResponse(fornecedorDto));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorDto));
return(CustomResponse(fornecedorDto));
}
public async Task <IActionResult> Post([FromBody] FornecedorDto model)
{
try
{
var fornecedor = await fornecedorService.AddFornecedor(model);
if (fornecedor == null)
{
return(BadRequest("Erro ao tentar Adicionar o Fornecedor."));
}
return(Ok(fornecedor));
}
catch (Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, $"Erro ao tentar adicionar o usuario. Erro: {ex.Message}"));
}
}
/// <summary>
/// Retorna um fornecedor para teste
/// </summary>
/// <returns></returns>
public FornecedorDto RetornarNovoFornecedor()
{
FornecedorDto entidadeDto = new FornecedorDto()
{
NomeFantasia = "Fornecedor teste " + DateTime.Now.ToString(),
RazaoSocial = "Fornecedor razão " + DateTime.Now.ToString(),
Id = Guid.NewGuid(),
Inativo = false,
Cnpj = "",
ComplementoEndereco = "Complemento",
NumeroEndereco = "10",
Obs = "Observações gerais",
Telefone = "(19) 98101-5120"
};
return(entidadeDto);
}
public async Task <ActionResult <FornecedorDto> > Alterar(Guid id, FornecedorDto fornecedorDto)
{
if (id != fornecedorDto.Id)
{
NotificarErro("O identificador informado não corresponde");
return(CustomResponse(fornecedorDto));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorDto);
await _fornecedorService.Atualizar(fornecedor);
return(CustomResponse(fornecedorDto));
}
public async Task <ActionResult <FornecedorDto> > Atualizar(Guid id, FornecedorDto fornecedorDto)
{
if (id != fornecedorDto.Id || !ModelState.IsValid)
{
return(BadRequest());
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorDto);
var result = await _fornecedorService.Atualizar(fornecedor);
if (!result)
{
return(BadRequest());
}
return(Ok(fornecedor));
}
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 <ActionResult <FornecedorDto> > Adicionar(FornecedorDto fornecedorDto)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
if (UsuarioAutenticado)
{
var userId = User.GetUserId();
var email = User.GetUserEmail();
var id = UsuarioId;
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorDto);
await _fornecedorService.Adicionar(fornecedor);
_logger.LogInformation("Inclusão de fornecedor " + fornecedorDto.Nome);
return(CustomResponse(fornecedorDto));
}
public IActionResult Salvar(FornecedorDto dadosTemporario)
{
if (ModelState.IsValid)
{
Fornecedor dados = new Fornecedor();
dados.Nome = dadosTemporario.Nome;
dados.Email = dadosTemporario.Email;
dados.Telefone = dadosTemporario.Telefone;
dados.Status = true;
database.Fornecedores.Add(dados);
database.SaveChanges();
return(RedirectToAction("ListarFornecedor", "Gestao"));
}
else
{
return(View("../Gestao/NovoFornecedor"));
// return RedirectToAction("NovoFornecedor", "Gestao");
}
}
public async Task <ActionResult <FornecedorDto> > Atualizar(Guid id, FornecedorDto fornecedorDto)
{
if (id != fornecedorDto.id)
{
//return BadRequest();
NotificarErro("O id informado não é o mesmo que foi passado na query");
return(CustomResponse(fornecedorDto));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorDto));
return(CustomResponse(fornecedorDto));
//Antes de customizar as mensagens
//var fornecedor = _mapper.Map<Fornecedor>(fornecedorDto);
//var result = await _fornecedorService.Atualizar(fornecedor);
//if (!result) return BadRequest();
//return Ok(fornecedor);
}
public ActionResult Incluir(FornecedorModel model)
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
// Validar inclusão do endereço
Dictionary <string, string> errosEndereco = new Dictionary <string, string>();
if (!Utilidades.ValidarEndereco(model.Endereco, ref errosEndereco))
{
foreach (var erro in errosEndereco)
{
ModelState.AddModelError(erro.Key, erro.Value);
}
}
//Validar a model recebida
if (!ModelState.IsValid)
{
return(View(model));
}
//Converter para DTO
FornecedorDto fornecedorDto = new FornecedorDto();
string mensagemErro = "";
if (!model.ConverterModelParaDto(ref fornecedorDto, ref mensagemErro))
{
ModelState.AddModelError("", $"Erro ao converter para Dto: {mensagemErro}");
return(View(model));
}
fornecedorDto.Id = Guid.NewGuid();
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoEntidadeDto <FornecedorDto> requisicaoDto = new RequisicaoEntidadeDto <FornecedorDto>()
{
EntidadeDto = fornecedorDto,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
FornecedorBll fornecedorBll = new FornecedorBll(true);
fornecedorBll.Incluir(requisicaoDto, ref retorno);
//Verificar o retorno
if (retorno.Retorno == false)
{
//Se houver erro, exibir na tela de inclusão
ModelState.AddModelError("", retorno.Mensagem);
return(View(model));
}
TempData["Retorno"] = "INCLUIDO";
//Retornar para index
return(RedirectToAction("Index"));
}
public void CadastrarFornecedor(FornecedorDto fornecedor)
{
_repository.SaveOrUpdate(_mapper.Map <Fornecedor>(fornecedor));
}