public async Task <bool> Adicionar(Fornecedor fornecedor)
{
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return(false);
}
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com este documento informado.");
return(false);
}
if (_user.IsAuthenticated())
{
var userId = _user.GetUserId();
var email = _user.GetUserEmail();
}
await _fornecedorRepository.Adicionar(fornecedor);
return(true);
}
public async Task <bool> Adicionar(Fornecedor fornecedor)
{
//// Validar o estado da entidade;
//var validator = new FornecedorValidation();
//var result = validator.Validate(fornecedor);
//if (!result.IsValid)
//{
// // result.Errors;
//}
// validar se não existe fornecedor com o mesmo documento;
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return(false);
}
// O Buscar é um método assíncrono; para pegar o result tem que esperar ele finalizar;
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com este documento informado.");
return(false);
}
await _fornecedorRepository.Adicionar(fornecedor);
return(true);
}
public async Task Adicionar(Fornecedor fornecedor)
{
/**OLD
* //Validar o estado da entidade
* var validator = new FornecedorValidation();
* var result = validator.Validate(fornecedor);
* if(!result.IsValid) { result.Errors; //a lista de erros, caso quisesse disparar para algum lugar.}
*/
//Validar o estado da entidade
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return;
}
//Um dia interessante neste momento é avaliar se nestas validações terá muitos "Ifs", se sim,
//verificar a possiblidade de passar essas regras para um método, deixar tudo encapsulado na
//classe do fornecedor, uma classe de validação ou afins
if (_fornecedorRepository.Buscar(predicate: f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar(mensagem: "Já existe um fornecedor com este documento informado");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
}
public async Task Adicionar(Fornecedor fornecedor)
{
if (!base.ExecutarValidacao(new FornecedorValidation(), fornecedor)
|| !base.ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
return;
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com este documento informado.");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
}
public async Task Adicionar(Fornecedor fornecedor)
{
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor))
{
return;
}
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor cadastrado com esse documento.");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
}
public async Task Adicionar(Fornecedor fornecedor)
{
//Validar o eatado da entidade!
if (!ExecutarValidacao(new ForncecedorValidation(), fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return;
}
//Validar se não existe fornecedor com o mesmo documento
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com este documento informado.");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
}
public async Task <bool> Editar(Fornecedor fornecedor)
{
if (!Validar(new FornecedorValidation(), fornecedor))
{
return(false);
}
if (_fornecedorRepository.Buscar(x => x.Documento == fornecedor.Documento && x.Id != fornecedor.Id).Result.Any())
{
Notificar($"Já existe um fornecedor cadastrado com o Documento ({fornecedor.Documento})");
return(false);
}
await _fornecedorRepository.Editar(fornecedor);
return(true);
}
public async Task <bool> Editar(Fornecedor fornecedor)
{
if (!EfetuarValidacao(new FornecedorValidation(), fornecedor))
{
return(false);
}
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento && f.Id != fornecedor.Id).Result.Any())
{
Notificar("Documento Inválido");
return(false);
}
await _fornecedorRepository.Editar(fornecedor);
return(true);
}
public async Task Adicionar(Fornecedor fornecedor)
{
//validar o estado da entidade
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return;
}
if (_fornecedorRepository.Buscar(x => x.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com o documento informado");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
}
public async Task <bool> Adicionar(Fornecedor fornecedor)
{
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor))
{
return(false);
}
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com este documento informado.");
return(false);
}
await _fornecedorRepository.Adicionar(fornecedor);
return(true);
}
public async Task <bool> Editar(Fornecedor fornecedor)
{
//Validar se o documento é valido
new FornecedorValidation().Validate(fornecedor);
// valida se ja existe o fornecedor com esse documento
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento && f.Id != fornecedor.Id).Result.Any()) // retorna verdadeiro se existe o documento
{
Notificar("Já existe um fornecedor com este documento");
return(false);
}
await _fornecedorRepository.Editar(fornecedor);
return(true);
}
public async Task Adicionar(Fornecedor fornecedor)
{
//VERIFICA SE NÃO EXISTE O FORNECEDOR
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return;
}
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com este documento infomado.");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
}
public async Task Adicionar(Fornecedor fornecedor)
{
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return;
}
var fornecedorBase = _fornecedorRepository.Buscar(e => e.Documento == fornecedor.Documento).Result;
if (fornecedorBase.Any())
{
Notificar($"Já existe um fornecedor de nome {fornecedorBase.FirstOrDefault()?.Nome} cadastrado com esse documento.");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
}
public async Task <bool> Adicionar(Fornecedor fornecedor)
{
//Validar o estado da entidade
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return(false);
}
//Valida se o documento está igual.
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com este documento informado");
return(false);
}
return(await _fornecedorRepository.Adicionar(fornecedor) > 0);
}
public async Task Adicionar(Fornecedor fornecedor)
{
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return;
}
var checkExists = (await _fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento)).Any();
if (checkExists)
{
Notificar("Já existe um fornecedor com o documento informado");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
}
public async Task Adicionar(Fornecedor fornecedor)
{
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com este documento infomado.");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
}
public async Task Adicionar(Fornecedor fornecedor)
{
// Valida o estado da entidade
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return;
}
// Verifica se já existe o documento fornecido
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com o documento informado.");
return;
}
// Salva os dados no banco
await _fornecedorRepository.Adicionar(fornecedor);
}
public async Task <bool> Editar(Fornecedor fornecedor)
{
//Validar se o documento é valido (CPF/CNPJ)
if (!EfetuarValidacao(new FornecedorValidation(), fornecedor))
{
return(false);
}
//Validar se ja existe registro com o documento
if (_fornecedorRepository
.Buscar(f => f.Documento == fornecedor.Documento && f.Id != fornecedor.Id).Result.Any())
{
Notificar("Já existe um fornecedor com este documento");
return(false);
}
await _fornecedorRepository.Editar(fornecedor);
return(true);
}
public async Task <ActionResult <FornecedorViewModel> > ObterPorId(Guid id)
{
var fornecedor = (await _fornecedorRepository.Buscar(f => f.Id == id)).FirstOrDefault();
var fornecedorViewModel = _mapper.Map <FornecedorViewModel>(fornecedor);
if (fornecedorViewModel == null)
{
return(NotFound());
}
return(fornecedorViewModel);
}
public async Task <bool> Adicionar(Fornecedor fornecedor)
{
// validar o estado da entidade.
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return(false);
}
// verificar se existe fornecedor com o mesmo documento.
if (_fornecedorRepository.Buscar(predicate: f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar(mensagem: "Já existe um fornecedor com este documento informado.");
return(false);
}
await _fornecedorRepository.Adicionar(fornecedor);
return(true);
}
public async Task Adicionar(Fornecedor fornecedor)
{
//Validando entidade
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) || !ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return;
}
//Verificando se o documento nao existe
var fornecedorExistente = await _fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento);
if (fornecedorExistente != null)
{
NotificarErro("Ja existe um fornecedor com este documento cadastrado.");
return;
}
//Cadastrando fornecedor
await _fornecedorRepository.Adicionar(fornecedor);
} //Adicionar
public async Task Adicionar(Fornecedor fornecedor)
{
//Validar estado da unidade
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) &&
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return;
}
//Se nao existe fornecedor com o mesmo documento
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com este número de documento.");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
return;
}
public async Task <IActionResult> Index(string nome)
{
if (!String.IsNullOrEmpty(nome))
{
return(View(_mapper.Map <IEnumerable <FornecedorViewModel> >(await _fornecedorRepository.Buscar(c => c.Nome.Contains(nome)))));
}
ViewBag.numeroChamado = nome;
return(View(_mapper.Map <IEnumerable <FornecedorViewModel> >(await _fornecedorRepository.ObterTodos())));
}
private async Task <bool> FornecedorExistente(Fornecedor fornecedor)
{
var resultado = await _fornecedorRepository.Buscar(f =>
f.Documento.Equals(fornecedor.Documento) && !f.Id.Equals(fornecedor.Id));
if (!resultado.Any())
{
return(false);
}
Notificar("Já existe um fornecedor com o documento informado!");
return(false);
}
private bool ValidarFornecedor(Fornecedor fornecedor, string action)
{
if (action == nameof(Adicionar))
{
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com este documento informado.");
return(false);
}
}
if (action == nameof(Atualizar))
{
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento && f.Id != fornecedor.Id).Result.Any())
{
Notificar("Já existe um fornecedor com este documento informado.");
return(false);
}
}
return(true);
}
public async Task Adicionar(Fornecedor fornecedor)
{
var validatorFornecedor = new FornecedorValidation();
var validatorEndereco = new EnderecoValidation();
if (!ExecutarValidacao(validatorFornecedor, fornecedor) ||
!ExecutarValidacao(validatorEndereco, fornecedor.Endereco))
{
return;
}
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com este documento informado.");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
return;
}
public async Task Atualizar(Fornecedor fornecedor)
{
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor))
{
return;
}
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento && f.Id != fornecedor.Id).Result.Any())
{
Notificar("Já existe um fornecedor com o documento: " + fornecedor.Documento + " cadastrado.");
return;
}
await _fornecedorRepository.Atualizar(fornecedor);
}
public async Task Adicionar(Fornecedor fornecedor)
{
//Validar o estado da entidade
/*var validator = new FornecedorValidation();
* var result = validator.Validate(fornecedor);
* if(!result.IsValid)
* result.Errors; //--> coleção de erros...*/
if (!ExecutarValidacao(new FornecedorValidation(), fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return;
}
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento).Result.Any())
{
Notificar("Já existe um fornecedor com este documento infomado.");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar([FromRoute] Guid id, [FromBody] FornecedorViewModel fornecedorVM)
{
if (id != fornecedorVM.Id)
{
return(CustomErrorResponse("O ID informado não é o mesmo que foi passado na rota!"));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
if (await _fornecedorRepository.Buscar(p => p.Id == id) == null)
{
return(NotFound("O fornecedor não foi encontrado."));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorVM);
await _fornecedorService.Atualizar(fornecedor);
return(CustomResponse(fornecedorVM));
}
private bool FornecedorExists(Guid id)
{
return(_fornecedorRepository.Buscar(f => f.Id == id).Result.Any());
}