public async Task Add(Categoria categoria)
        {
            if (!ExecutarValidacao(new CategoriaValidation(), categoria))
            {
                return;
            }

            await _categoriaRepository.Add(categoria);
        }
Exemplo n.º 2
0
        // <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);
        }
Exemplo n.º 3
0
        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));
        }
Exemplo n.º 4
0
 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));
 }
Exemplo n.º 6
0
 public IActionResult Create([Bind("Id,Nome")] CategoriaModel categoriaModel)
 {
     if (ModelState.IsValid)
     {
         repositorio.Add(categoriaModel);
         return(RedirectToAction("Index"));
     }
     return(View(categoriaModel));
 }
Exemplo n.º 7
0
        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);
 }
Exemplo n.º 9
0
        public void Handle(CriarCategoriaCommand command)
        {
            var categoria = new Categoria(command.Nome);

            _categoriaRepository.Add(categoria);

            Result = categoria;

            AddNotifications(categoria.Notifications);
        }
Exemplo n.º 10
0
        public void CadastrarCategoria(CategoriaDTO dto)
        {
            Categoria categoria = Categoria.Cadastrar(dto, categoriaValidator);

            unitOfWork.BeginTransaction();

            categoriaRepository.Add(categoria);

            unitOfWork.Commit();
        }
Exemplo n.º 11
0
 public IActionResult Create([FromBody] Categoria categoria)
 {
     if (categoria == null)
     {
         return(BadRequest());
     }
     _categoriaRepositoy.Add(categoria);
     return(CreatedAtRoute("GetCategoria", new Categoria {
         ID = categoria.ID
     }, categoria));
 }
Exemplo n.º 12
0
 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!"));
     }
 }
Exemplo n.º 13
0
        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()));
        }
Exemplo n.º 14
0
        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."));
            }
        }
Exemplo n.º 15
0
        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();
        }
Exemplo n.º 17
0
        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"));
        }
Exemplo n.º 18
0
        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));
        }
Exemplo n.º 19
0
        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()));
        }
Exemplo n.º 21
0
        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));
        }
Exemplo n.º 23
0
        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());
        }
Exemplo n.º 24
0
        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);
        }
Exemplo n.º 25
0
 public void RegistrarCategoria(Model.Categoria categoria)
 {
     _categoriaRepository.Add(categoria);
     _unitOfWork.Commit();
 }
 public async Task Add(Categoria item)
 {
     await _categoriaRepository.Add(item);
 }
Exemplo n.º 27
0
 public virtual CategoriaModel Add(CategoriaModel cliente)
 {
     return(CategoriaRepository.Add(cliente.ConvertToUserEntity()).ConvertToUser());
 }
Exemplo n.º 28
0
 public void Add(Categoria entity)
 {
     _repository.Add(entity);
 }