public void Persistir(CategoriaContabil categoria)
{
var mensagens = new CategoriaValidator().Validate(categoria).Errors;
if (mensagens.Count > 0)
{
foreach (var mensagem in mensagens)
{
_notificationHandler.AddMensagem(mensagem.PropertyName, mensagem.ErrorMessage);
}
return;
}
if ((_categoriaContabilRepository.Validar(categoria)))
{
_notificationHandler.AddMensagem("Sigla", "PERSISTIR_CATEGORIA_DUPLICIDADE");
return;
}
if (categoria.Id == 0)
{
_categoriaContabilRepository.Adicionar(categoria);
}
else
{
_categoriaContabilRepository.Update(categoria);
}
_unitOfWork.Commit();
}
public async Task<IActionResult> PutCategoria(short id, Categoria categoria)
{
if (id != categoria.Id)
return BadRequest();
var validator = new CategoriaValidator();
var isValid = validator.Validate(categoria);
if (!isValid.IsValid)
{
var listaErros = new List<RetornoErrosDTO>();
isValid.Errors.ToList().ForEach(erro => listaErros.Add(new RetornoErrosDTO() { Key = erro.PropertyName.ToLower(), Value = erro.ErrorMessage.Replace("\"", "'") }));
return BadRequest(JsonConvert.SerializeObject(listaErros));
}
_context.Entry(categoria).State = EntityState.Modified;
try
{
_repo.Update(categoria);
await _repo.SaveAsync(categoria);
}
catch (DbUpdateConcurrencyException)
{
if (!CategoriaExists(id))
return NotFound();
else
throw;
}
return NoContent();
}
public void Editar(CategoriaDTO dto, CategoriaValidator validator)
{
validator.ValidarEdicao(dto);
this.Nome = dto.Nome;
this.Tipo = dto.Tipo;
this.UsuarioId = dto.UsuarioId;
this.CategoriaPaiId = dto.CategoriaPaiId;
}
public void Excluir(CategoriaValidator validator)
{
CategoriaDTO dto = new CategoriaDTO
{
Id = this.Id,
UsuarioId = this.UsuarioId
};
validator.ValidarExclusao(dto);
}
public void Registre(Categoria item)
{
//Validacao
FluentValidation.Results.ValidationResult result = new CategoriaValidator().Validate(item);
if (!result.IsValid)
{
throw new CustomException(result);
}
_categoriaRepository.AddOrUpdate(item);
_categoriaRepository.Save();
}
public Categoria_Cadastro_Tests()
{
mockCategoriaRepository = new Mock <ICategoriaRepository>();
mockDespesaRepository = new Mock <IDespesaRepository>();
mockLancamentoRepository = new Mock <ILancamentoRepository>();
mockOrcamentoRepository = new Mock <IOrcamentoRepository>();
validator = new CategoriaValidator(
mockCategoriaRepository.Object,
mockDespesaRepository.Object,
mockLancamentoRepository.Object,
mockOrcamentoRepository.Object);
}
public int insere(Categoria categoria)
{
var validator = new CategoriaValidator();
var validRes = validator.Validate(categoria);
if (validRes.IsValid)
{
return(_repository.InserirCategoria(categoria));
}
else
{
throw new Exception(validRes.Errors.FirstOrDefault().ToString());
}
}
public void InserirCategoria(Categoria categoria)
{
var validator = new CategoriaValidator();
var validRes = validator.Validate(categoria);
if (validRes.IsValid)
{
context.categoria.Add(categoria);
context.SaveChanges();
}
else
{
throw new Exception(validRes.Errors.FirstOrDefault().ToString());
}
}
public async Task<ActionResult<Categoria>> PostCategoria(Categoria categoria)
{
var validator = new CategoriaValidator();
var isValid = validator.Validate(categoria);
if (!isValid.IsValid)
{
var listaErros = new List<RetornoErrosDTO>();
isValid.Errors.ToList().ForEach(erro => listaErros.Add(new RetornoErrosDTO() { Key = erro.PropertyName.ToLower(), Value = erro.ErrorMessage.Replace("\"", "'") }));
return BadRequest(JsonConvert.SerializeObject(listaErros));//(erros, null, 412, "Erros " + isValid.Errors.Count);
}
_repo.Add(categoria);
await _repo.SaveAsync(categoria);
return CreatedAtAction("GetCategoria", new { id = categoria.Id }, categoria);
}
public ActionResult Update(Categoria categoria)
{
CategoriaValidator validator = new CategoriaValidator();
var result = validator.Validate(categoria);
if (!result.IsValid)
{
var errors = new Dictionary <string, string>();
foreach (var error in result.Errors)
{
string message = error.ErrorMessage;
string property = error.PropertyName;
errors.Add(property, message);
}
return(BadRequest(Json(errors)));
}
return(Json(new { id = repository.Update(categoria) }));
}
public CategoriaAppService(
IUnitOfWork unitOfWork,
ICategoriaRepository categoriaRepository,
IDespesaRepository despesaRepository,
ILancamentoRepository lancamentoRepository,
IOrcamentoRepository orcamentoRepository)
{
this.unitOfWork = unitOfWork;
this.categoriaRepository = categoriaRepository;
this.despesaRepository = despesaRepository;
this.lancamentoRepository = lancamentoRepository;
this.orcamentoRepository = orcamentoRepository;
this.categoriaValidator = new CategoriaValidator(
categoriaRepository,
despesaRepository,
lancamentoRepository,
orcamentoRepository);
}
public IActionResult Salvar(CategoriaDomain categoria)
{
try
{
var validador = new CategoriaValidator().Validate(categoria);
if (validador.IsValid)
{
new CategoriaRepository().Salvar(categoria);
}
else
{
return(BadRequest(validador.ToString("\n")));
}
}
catch
{
return(BadRequest());
}
return(Ok(Constantes.msgSucessoAtualizarRegistro));
}
public void Validate()
{
var categoriaValidator = new CategoriaValidator();
categoriaValidator.ValidateAndThrow(this);
}
public CategoriaController()
{
validator = new CategoriaValidator();
}
public static Categoria Cadastrar(CategoriaDTO dto, CategoriaValidator validator)
{
validator.ValidarCadastro(dto);
return(new Categoria(dto));
}
