Esempio n. 1
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);
        }
Esempio n. 2
0
        public IActionResult CrearCategoria([FromBody] CategoriaDto categoriaDto)
        {
            if (categoriaDto == null)
            {
                return(BadRequest(ModelState));
            }

            if (_ctRepo.ExisteCategoria(categoriaDto.Nombre))
            {
                ModelState.AddModelError("", "La categoría ya existe");
                return(StatusCode(404, ModelState));
            }

            var categoria = _mapper.Map <Categoria>(categoriaDto);

            if (!_ctRepo.CrearCategoria(categoria))
            {
                ModelState.AddModelError("", $"Algo salio mal guardando el registro {categoria.Nombre}");
                return(StatusCode(500, ModelState));
            }

            //return Ok();

            //Retorna el último registro insertado.
            return(CreatedAtRoute("GetCategoria", new { categoriaId = categoria.Id }, categoria));
        }
Esempio n. 3
0
        public void AtualizarCategoria(CategoriaDto categoria)
        {
            var tabela = AutoMapper.Mapper.Map <Categoria>(categoria);

            tabela.DataAtualizacao = DateTime.Now;
            Dao.Atualizar(tabela);
        }
Esempio n. 4
0
        private Categoria TrataAtualizacaoForm(CategoriaDto categForm, int id)
        {
            var categSelecionada = _repo.ObterCategoriaPorID(id);

            if (categSelecionada == null)
            {
                return(null);
            }
            if (categForm.Id < 1)
            {
                categForm.Id = id;
            }
            if (categForm.Descricao != "" && categForm.Descricao != null)
            {
                categSelecionada.Descricao = categSelecionada.Descricao;
            }
            if (categForm.Sigla != "" && categForm.Sigla != null)
            {
                categSelecionada.Sigla = categSelecionada.Sigla;
            }

            var categoria = _mapper.Map(categForm, categSelecionada);

            return(categoria);
        }
        public async Task <IActionResult> Put(int CategoriaId, CategoriaDto model)
        {
            try
            {
                var categoria = await _repo.GetAllCategoriaAsyncById(CategoriaId);

                if (categoria == null)
                {
                    return(NotFound());
                }

                _mapper.Map(model, categoria);

                _repo.Update(categoria);

                if (await _repo.SaveChangesAsync())
                {
                    return(Created($"/api/categoria/{model.Id}", _mapper.Map <CategoriaDto>(categoria)));
                }
            }
            catch (System.Exception)
            {
                return(this.StatusCode(StatusCodes.Status500InternalServerError, "Banco de Dados Falhou"));
            }

            return(BadRequest());
        }
 public void put(CategoriaDto categoria)
 {
     ExecuteProcedure("UpdCategoria");
     AddParameter("@Num_Id", categoria.Num_IdCategoria);
     AddParameter("@Nom_Nome", categoria.Nom_Nome);
     ExecuteNonQuery();
 }
Esempio n. 7
0
 public async Task Insertar(CategoriaDto dto)
 {
     using (var context = new DataContext())
     {
         var categoria = _mapper.Map <Dominio.Entidades.Categoria>(dto);
         await _categoriaRepositorio.Create(categoria);
     }
 }
Esempio n. 8
0
 public static Categoria toModel(CategoriaDto categoriaDto)
 {
     return(new Categoria()
     {
         descricao = categoriaDto.descricao,
         id = categoriaDto.id
     });
 }
Esempio n. 9
0
        public void Insert(CategoriaDto categoriaDto)
        {
            Categoria categoria = CategoriaAdapter.toDomain(categoriaDto);

            categoria.id = Guid.NewGuid();

            categoriaRepositorio.Inserir(categoria);
        }
Esempio n. 10
0
        public CategoriaDto Create(CategoriaDto categoriadto)
        {
            var entity = Mapper.Map <CategoriaDto, Categoria>(categoriadto);

            _context.Categoria.Add(entity);
            _context.SaveChanges();
            return(Mapper.Map <Categoria, CategoriaDto>(entity));
        }
Esempio n. 11
0
        public CategoriaDto Dto()
        {
            CategoriaDto dto = new CategoriaDto();

            dto.ID      = ID;
            dto.Nombre  = Nombre;
            dto.Anulado = Anulado;
        }
        public IActionResult EditarCategoria(int id)
        {
            var          categoria     = database.Categorias.First(cat => cat.Id == id);
            CategoriaDto categoriaView = new CategoriaDto();

            categoriaView.Id   = categoria.Id;
            categoriaView.Nome = categoria.Nome;
            return(View(categoriaView));
        }
        public void Update(CategoriaDto dto, int id)
        {
            var query = _uow.CategoriaRepository.GetById(id);

            var categoria = query.FirstOrDefault();

            categoria.Nome = dto.Nome;
            _uow.Commit();
        }
Esempio n. 14
0
 public async Task Modificar(CategoriaDto dto)
 {
     using (var context = new DataContext())
     {
         var categoria = context.Categorias.FirstOrDefault(x => x.Id == dto.Id);
         categoria.Descripcion = dto.Descripcion;
         await _categoriaRepositorio.Update(categoria);
     }
 }
 public override bool Equals(object obj)
 {
     if (obj is CategoriaDto)
     {
         CategoriaDto zona = obj as CategoriaDto;
         return(zona.Id == Id && zona.Descripcion == Descripcion && zona.SalarioMinimoId == SalarioMinimoId && zona.EstaEliminado == EstaEliminado);
     }
     return(false);
 }
Esempio n. 16
0
        public void SalvarCategoria(string nome, string descricao)
        {
            CategoriaDto c = new CategoriaDto();

            c.Nome      = nome;
            c.Descricao = descricao;

            categoriaBo.SalvarCategoria(c);
        }
        public void Insert(CategoriaDto dto)
        {
            var categoriadb = new CategoriaDB
            {
                Nome = dto.Nome,
            };

            _uow.CategoriaRepository.Add(categoriadb);
            _uow.Commit();
        }
Esempio n. 18
0
        public void SalvarCategoria(CategoriaDto categoria)
        {
            var tabela = AutoMapper.Mapper.Map <Categoria>(categoria);

            tabela.DataAtualizacao = DateTime.Now;
            tabela.DataCriacao     = DateTime.Now;
            //tabela.Anuncios = new List<Anuncio>();
            //tabela.Categorias = new List<Categoria>();
            Dao.Inserir(tabela);
        }
Esempio n. 19
0
        public void Edit(CategoriaDto dto)
        {
            Categoria categoria = ValidaCategoria(dto.Id);

            categoria.Ativo = dto.Ativo;
            categoria.Nome  = dto.Nome;

            _repository.Edit(categoria);
            _repository.Commit();
        }
        public ActionResult Post([FromBody] CategoriaDto model)
        {
            var categoria = _mapper.Map <Categoria>(model);

            _uof.CategoriaRepository.Add(categoria);
            _uof.Commit();

            var categoriaDto = _mapper.Map <CategoriaDto>(categoria);

            return(Created($"api/categoria/{categoria.CategoriaId}", categoriaDto));
        }
Esempio n. 21
0
        public IActionResult Update(Categoria categoria)
        {
            CategoriaRepositorio categoriaRepositorio = new CategoriaRepositorio(this.configuration.GetConnectionString("default"));
            CategoriaAplicacao   categoriaAplicacao   = new CategoriaAplicacao(categoriaRepositorio);

            CategoriaDto categoriaDto = CategoriaMapping.toDto(categoria);

            categoriaAplicacao.Update(categoriaDto);

            return(RedirectToAction("Index"));
        }
        protected async override Task CrearNuevoElemento()
        {
            if (!string.IsNullOrWhiteSpace(Categoria.Descripcion))
            {
                await Servicios.ApiProcessor.PostApi(Categoria, "Categoria/Insert");
                await Inicializar();

                Categoria = null;
                Categoria = new CategoriaDto();
            }
        }
Esempio n. 23
0
 public BusinessResult <CategoriaDto> Create(CategoriaDto entityDto)
 {
     try
     {
         var result = _icategoriadata.Create(entityDto);
         return(BusinessResult <CategoriaDto> .Success(result, "Operación correcta"));
     }
     catch (Exception ex)
     {
         return(BusinessResult <CategoriaDto> .Issue(null, "Operación incorrecta", ex));
     }
 }
Esempio n. 24
0
 public BusinessResult <bool> Update(CategoriaDto entityDto)
 {
     try
     {
         _icategoriadata.Update(entityDto);
         return(BusinessResult <bool> .Success(true, "Operación correcta"));
     }
     catch (Exception ex)
     {
         return(BusinessResult <bool> .Issue(false, "Operación incorrecta", ex));
     }
 }
Esempio n. 25
0
 public ActionResult Edit(CategoriaDto dto)
 {
     try
     {
         _service.Update(dto);
         return(RedirectToAction(nameof(Index)));
     }
     catch
     {
         return(View());
     }
 }
Esempio n. 26
0
 public ActionResult DeleteConfirmed(CategoriaDto dto)
 {
     try
     {
         _service.Remove(dto.Codigo);
         return(RedirectToAction(nameof(Index)));
     }
     catch
     {
         return(View());
     }
 }
 public IHttpActionResult Post(CategoriaDto categoria)
 {
     try
     {
         _categoriaRepository.post(categoria);
         return(Ok());
     }
     catch (Exception ex)
     {
         return(BadRequest(ex.Message));
     }
 }
Esempio n. 28
0
        public CategoriaDto Modificar(CategoriaDto dto)
        {
            var entity = _categoriaRepositorio.ObtenerPorId(dto.Id);

            entity.Descripcion = dto.Descripcion;
            entity.EmpresaId   = dto.EmpresaId;

            _categoriaRepositorio.Modificar(entity);
            Guardar();

            return(dto);
        }
Esempio n. 29
0
        // PUT: api/Categoria/5
        public void Put([FromBody] CategoriaDto dto)
        {
            var categoria = _uow._categoriaRepositorio.ObterPorId(dto.Id.ToString());

            if (categoria != null)
            {
                categoria.Nome      = dto.Nome;
                categoria.Descricao = dto.Descricao;
            }

            _uow.Salvar();
        }
Esempio n. 30
0
        public IActionResult Post(CategoriaDto cDto)
        {
            var categoria = _mapper.Map <Categoria>(cDto);

            _repo.Add(categoria);
            if (_repo.SaveChanges())
            {
                return(Created($"/api/categoria/{cDto.Id}", _mapper.Map <CategoriaDto>(categoria)));
            }
            //return Ok($"Categoria: {categoriaDto.Descricao} Adicionada com Sucesso!");
            return(BadRequest($"Falha ao tentar cadastrar a Categoria: {categoria.Descricao}"));
        }
Esempio n. 31
0
        } // end Create


        /// <summary>
        /// Función encargada de la actualziación de una entidad de tipo Categoria.
        /// </summary>
        /// <param name="categoriaDto">
        /// Parámetro de tipo <see cref="CategoriaDto"/> con los datos necesarios
        /// para el borrado de la entidad Categoriar.
        /// </param>
        /// <returns>
        /// Devuelve <b>true</b> si la actualización ha sido correcta y
        /// <b>false</b> en caso contrario.
        /// </returns>
        public bool Update( CategoriaDto categoriaDto)
        {
            // opción 1
            // Instanciamos el servicio de aplicación de actualización mediante el contenedor de IoC.
            // var data = ManagerIoC.Container.Resolve<IUpdateCategoria>();
            // Ejecutamos el servicio y obtenemos la respuesta.
            // bool response = data.Execute( categoriaDto);
            // Devolvemos la respuesta.
            // return response;

            // opción 2
            return this.service.Update(categoriaDto);
        } // end Update
Esempio n. 32
0
        } // end CategoriaService Constructor

        #endregion

        #region Methods
        /// <summary>
        /// Función encargada de la creación de una entidad de tipo Categoria.
        /// </summary>
        /// <param name="categoriaDto">
        /// Parámetro de tipo <see cref="CategoriaDto"/> con los datos necesarios
        /// para la creación de la entidad Categoria.
        /// </param>
        /// <return>
        /// Devuelve el identificador único de la entidad creada.
        /// </return>
        public int Create( CategoriaDto categoriaDto)
        {
            // opción 1
            // Instanciamos el servicio de aplicación de creación mediante el contenedor de IoC.
            // var data = ManagerIoC.Container.Resolve<ICreateCategoria>();
            // Ejecutamos el servicio y obtenemos la respuesta.
            // int identifier = data.Execute( categoriaDto);
            // Devolvemos la respuesta.
            // return identifier;

            //opción 2
            return this.service.Create(categoriaDto);

        } // end Create