// <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 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)); }
public void AtualizarCategoria(CategoriaDto categoria) { var tabela = AutoMapper.Mapper.Map <Categoria>(categoria); tabela.DataAtualizacao = DateTime.Now; Dao.Atualizar(tabela); }
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(); }
public async Task Insertar(CategoriaDto dto) { using (var context = new DataContext()) { var categoria = _mapper.Map <Dominio.Entidades.Categoria>(dto); await _categoriaRepositorio.Create(categoria); } }
public static Categoria toModel(CategoriaDto categoriaDto) { return(new Categoria() { descricao = categoriaDto.descricao, id = categoriaDto.id }); }
public void Insert(CategoriaDto categoriaDto) { Categoria categoria = CategoriaAdapter.toDomain(categoriaDto); categoria.id = Guid.NewGuid(); categoriaRepositorio.Inserir(categoria); }
public CategoriaDto Create(CategoriaDto categoriadto) { var entity = Mapper.Map <CategoriaDto, Categoria>(categoriadto); _context.Categoria.Add(entity); _context.SaveChanges(); return(Mapper.Map <Categoria, CategoriaDto>(entity)); }
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(); }
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); }
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(); }
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); }
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)); }
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(); } }
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)); } }
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)); } }
public ActionResult Edit(CategoriaDto dto) { try { _service.Update(dto); return(RedirectToAction(nameof(Index))); } catch { return(View()); } }
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)); } }
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); }
// 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(); }
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}")); }
} // 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
} // 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