public async Task Add(Categoria categoria)
{
if (!ExecutarValidacao(new CategoriaValidation(), categoria))
{
return;
}
await _categoriaRepository.Add(categoria);
}
// <summary>
// Obtiene la referencia a la factoría de repositorios de la entidad <see cref="T:Categoria"/>.
// </summary>
//private CategoriaRepositoryFactory CategoriaRepositoryFactory
//{
//get { return this.categoriaRepositoryFactory; }
//}
#endregion
#region Create Method
// from template Application\UpdateBase\I2ServiceRegionCreateMethod.tt
/// <summary>
/// Crea una entidad Categoria.
/// </summary>
/// <param name="categoriaDto">
/// DTO que contiene la información para crear la entidad.
/// </param>
/// <returns>
/// El identificador de la entidad creada.
/// </returns>
public int Create(CategoriaDto categoriaDto)
{
#region Preconditions
// Comprobar el DTO de entrada.
Guard.ArgumentIsNotNull(
categoriaDto,
string.Format(
FrameworkResource.DataTransferObjectIsNull,
SharedResources.CategoriaAlias));
// Comprobar los campos mandatory dentro del DTO.
#endregion
// el dto debe corresponder a un transient el id debe tener el valor por defecto
Guard.Against <ArgumentException>(categoriaDto.Id != default(Int32),
string.Format(
FrameworkResource.IsNotTransient,
SharedResources.CategoriaAlias
)
);
Categoria categoria = CategoriaFactory.Create();
categoria.Name = categoriaDto.Name;
ICategoriaRepository repo = ApplicationLayer.IocContainer.Resolve <ICategoriaRepository>();
repo.Add(categoria);
this.Commit();
return(categoria.Id);
}
public Task <bool> Handle(RegisterNewCategoriaCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Task.FromResult(false));
}
var categoria = new Categoria(Guid.NewGuid(), message.Nome, message.Descricao);
if (_categoriaRepository.GetByDescricao(categoria.Descricao) != null)
{
Bus.RaiseEvent(new DomainNotification(message.MessageType, "A categoria já ja existe. "));
return(Task.FromResult(false));
}
_categoriaRepository.Add(categoria);
if (Commit())
{
Bus.RaiseEvent(new CategoriaRegisteredEvent(categoria.Id, categoria.Nome, categoria.Descricao));
}
return(Task.FromResult(true));
}
public void Cadastrar(string nome)
{
if (!_repository.Existe(nome))
{
_repository.Add(new Categoria(nome));
_repository.SaveChanges();
}
}
public IActionResult Create([FromBody] Categoria categoria)
{
if (categoria == null)
{
return(BadRequest());
}
_repo.Add(categoria);
return(CreatedAtRoute("GetCategoria", new { id = categoria.Id }, categoria));
}
public IActionResult Create([Bind("Id,Nome")] CategoriaModel categoriaModel)
{
if (ModelState.IsValid)
{
repositorio.Add(categoriaModel);
return(RedirectToAction("Index"));
}
return(View(categoriaModel));
}
public Categoria CriarCategoria(Categoria categoria)
{
categoria = _repository.GetById(categoria.Id);
categoria.Descricao += "2";
categoria = _repository.Add(categoria);
_repository.Remove(categoria);
return(categoria);
}
public Categoria Adicionar(Categoria marca)
{
marca.ResultadoValidacao = new CategoriaAptaParaCadastroValidation(_repository).Validate(marca);
if (PossuiConformidade(marca.ResultadoValidacao))
{
_repository.Add(marca);
}
return(marca);
}
public void Handle(CriarCategoriaCommand command)
{
var categoria = new Categoria(command.Nome);
_categoriaRepository.Add(categoria);
Result = categoria;
AddNotifications(categoria.Notifications);
}
public void CadastrarCategoria(CategoriaDTO dto)
{
Categoria categoria = Categoria.Cadastrar(dto, categoriaValidator);
unitOfWork.BeginTransaction();
categoriaRepository.Add(categoria);
unitOfWork.Commit();
}
public IActionResult Create([FromBody] Categoria categoria)
{
if (categoria == null)
{
return(BadRequest());
}
_categoriaRepositoy.Add(categoria);
return(CreatedAtRoute("GetCategoria", new Categoria {
ID = categoria.ID
}, categoria));
}
public ActionResult <CategoriaEntity> Post([FromBody] CategoriaEntity categoria)
{
if (!ValidaCategoria(categoria))
{
categoria.nome = categoria.nome.Trim(' ');
return(new OkObjectResult(_categoriaRepositor.Add(categoria)));
}
else
{
return(new BadRequestObjectResult("Nome inválido!"));
}
}
public IActionResult Add([FromBody] CategoriasAddEdit model)
{
if (ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var data = model.ToCategoria();
_categoriaRepository.Add(data);
return(CreatedAtRoute("GetCategoriaById", new { data.Id }, data.ToCategoriaGet()));
}
public ActionResult <CategoriaEntity> Post([FromBody] CategoriaEntity categoria)
{
var nome = Validacoes.StringValidation(categoria.NOME);
if (nome == true)
{
return(_categoriaRepository.Add(categoria));
}
else
{
return(BadRequest("Não foi possível atualizar esta categoria. Por favor, digite um nome válido."));
}
}
public void Gravar(CategoriaDto categoriaDto)
{
Categoria categoria = Mapper.Map <CategoriaDto, Categoria>(categoriaDto);
if (categoria != null && categoria.CategoriaId > 0)
{
_categoriaRepository.Update(categoria);
}
else
{
_categoriaRepository.Add(categoria);
}
}
public void Add(AddCategoria vmodel)
{
Domain.Categoria.Entity.Categoria model = vmodel;
if (!model.IsValid())
{
NotifyValidationError(model.ValidationResult);
return;
}
_categoriaRepository.Add(model);
Commit();
}
public async Task <IActionResult> AddEdit(int Id, CategoriaAddEditVM model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var cat = model.ToData();
if (Id == 0)
{
_categoriaRepository.Add(cat);
}
else
{
cat.Id = Id;
cat.DataAlteracao = DateTime.Now;
_categoriaRepository.Update(cat);
}
await _uow.CommitAsync();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Add([FromBody] CategoriasAddEditVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var data = model.ToData();
_categRepo.Add(data);
await _uow.CommitAsync();
return(CreatedAtRoute("GetCategoriaById", new { id = data.Id }, data));
}
public CategoriaDto Add(CategoriaDto dto)
{
var obj = new Domain.Entity.Entity.Categoria
{
Descripcion = dto.Descripcion,
EstaEliminado = dto.EstaEliminado,
};
_categoriaRepository.Add(obj);
Save();
dto.Id = obj.Id;
return(dto);
}
public async Task <IActionResult> Add([FromBody] PostCommand model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var data = model.ToData();
_catRepository.Add(data);
await _uow.CommitAsync();
return(CreatedAtRoute("GetCategoriaById", new { data.Id }, data.ToVM()));
}
public async Task <IActionResult> Post([FromBody] CategoriaDTO categoriaDto)
{
var categoria = _mapper.Map <Categoria>(categoriaDto);
_categoriaRepository.Add(categoria);
if (await _categoriaRepository.CommitAsync())
{
var data = _mapper.Map <CategoriaRespostaDTO>(categoria);
return(Ok(data));
}
else
{
return(BadRequest("Falha ao adicionar categoria"));
}
}
public async Task <ValidationResult> Handle(RegisterNewCategoriaCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
return(message.ValidationResult);
}
var categoria = new Categoria(Guid.NewGuid(), message.Descricao);
if (await _categoriaRepository.GetByName(categoria.Descricao) != null)
{
AddError("Esta categoria já existe no sistema.");
return(ValidationResult);
}
categoria.AddDomainEvent(new CategoriaRegisteredEvent(categoria.Id, categoria.Descricao));
_categoriaRepository.Add(categoria);
return(await Commit(_categoriaRepository.UnitOfWork));
}
public async Task <IActionResult> AdicionarCategoria([FromBody] AddCategoria categoriaViewModel)
{
var categoria = _mapper.Map <Categoria>(categoriaViewModel);
var result = new ValidadorCategoria();
var teste = result.Validate(categoria).Errors;
var novaLista = new List <string>();
foreach (var item in teste)
{
novaLista.Add(item.ErrorMessage);
}
if (novaLista.Count > 0)
{
return(Ok(novaLista));
}
_categoriaRepository.Add(categoria);
_categoriaRepository.SaveChanges();
return(Ok());
}
public async Task <Notification> Executar(Categoria entity)
{
_notification.Errors.Clear();
Validate(entity);
if (_notification.HasErrors == true)
{
return(_notification);
}
_repository.Add(entity);
try
{
await _repository.SaveAsync();
}
catch (Exception ex)
{
_notification.Errors.Add(ex.Message);
}
return(_notification);
}
public void RegistrarCategoria(Model.Categoria categoria)
{
_categoriaRepository.Add(categoria);
_unitOfWork.Commit();
}
public async Task Add(Categoria item)
{
await _categoriaRepository.Add(item);
}
public virtual CategoriaModel Add(CategoriaModel cliente)
{
return(CategoriaRepository.Add(cliente.ConvertToUserEntity()).ConvertToUser());
}
public void Add(Categoria entity)
{
_repository.Add(entity);
}
