public IActionResult Form([FromQuery] AccionesCRUD accionCRUD, int?Id)
{
try
{
if (accionCRUD.Equals(AccionesCRUD.AGREGAR) || accionCRUD.Equals(AccionesCRUD.MODIFICAR))
{
ViewData["accionCRUD"] = accionCRUD;
if (accionCRUD.Equals(AccionesCRUD.AGREGAR))
{
return(View());
}
if (accionCRUD.Equals(AccionesCRUD.MODIFICAR))
{
CategoriaDTO categoriaDTO = this._categoriaService.getCategoria((int)Id);
CategoriaViewModel categoriaViewModel = this._mapper.Map <CategoriaViewModel>(categoriaDTO);
return(View(categoriaViewModel));
}
}
throw new Exception("Ocurrio un error inesperado.");
}
catch (Exception ex)
{
ViewBag.error = ex.Message;
return(View("index"));
}
}
public IActionResult Modificar(CategoriaViewModel p_categoriaVM)
{
try
{
if (!ModelState.IsValid)
{
return(View("error"));
}
else
{
CategoriaDTO categoriaDTO = this._mapper.Map <CategoriaDTO>(p_categoriaVM);
int result = this._categoriaService.ModificarCategoria(categoriaDTO);
ViewBag.result = "Accion realizada con exito.";
List <CategoriaViewModel> categoriaViewModel = this._categoriaService.getCategorias()
.Select(x => this._mapper.Map <CategoriaViewModel>(x)).ToList();
return(View("index", categoriaViewModel));
}
}
catch (Exception ex)
{
ViewBag.error = ex.InnerException.Message;
ViewData["accionCRUD"] = AccionesCRUD.MODIFICAR;
return(View("form", p_categoriaVM));
}
}
public JsonResult GetById(CategoriaDTO categoriaDTO)
{
var jsonResponse = new JsonResponse {
Success = true
};
try
{
var categoria = MapperHelper.Map <CategoriaDTO, Categoria>(categoriaDTO);
var categoriaI = CategoriaBL.Instancia.GetById(categoria);
if (categoriaI != null)
{
categoriaDTO = MapperHelper.Map <Categoria, CategoriaDTO>(categoriaI);
jsonResponse.Data = categoriaDTO;
}
else
{
jsonResponse.Warning = true;
jsonResponse.Message = Mensajes.UsuarioNoExiste;
}
}
catch (Exception ex)
{
LogError(ex);
jsonResponse.Success = false;
jsonResponse.Message = Mensajes.IntenteloMasTarde;
}
return(Json(jsonResponse));
}
public void Alterar(CategoriaDTO categoria)
{
string sql = string.Format($@"UPDATE categoria SET nome= '{categoria.Nome}',
descricao= '{categoria.Descricao}';");
con.ExecutarSQL(sql);
}
public CategoriaDTO ObterPorPK(CategoriaDTO dto)
{
try
{
ComandText = "stp_AUTO_CATEGORIA_OBTERPORPK";
AddParameter("CODIGO", dto.Codigo);
MySqlDataReader dr = ExecuteReader();
dto = new CategoriaDTO();
if (dr.Read())
{
dto.Codigo = int.Parse(dr[0].ToString());
dto.Descricao = dr[1].ToString();
dto.Sigla = dr[2].ToString();
dto.Estado = int.Parse(dr[3].ToString());
}
}
catch (Exception ex)
{
dto.Sucesso = false;
dto.MensagemErro = ex.Message.Replace("'", "");
}
finally
{
FecharConexao();
}
return(dto);
}
public List <CategoriaDTO> ListTop8ProductsOfAllCategories()
{
List <CategoriaDTO> categorias = new List <CategoriaDTO>();
List <ProdutoCategoria> entities = _repository.ListTopSellsProductsOfAllCategories();
IEnumerable <int> ids = from e in entities
group e by e.Id into i
select i.Key;
foreach (int id in ids)
{
List <ProdutoCategoria> entitiesByCat = entities.Where(e => e.Id == id).ToList();
CategoriaDTO categoria = new CategoriaDTO()
{
Id = id
};
foreach (ProdutoCategoria entity in entitiesByCat)
{
categoria.Produtos.Add(new ProdutoDTO()
{
CategoriaId = id,
Id = entity.ProdutoId,
Descricao = entity.Descricao,
ImagemPrincipal = entity.ImagemPrincipal,
MarcaId = entity.MarcaId,
Nome = entity.Nome,
Preco = entity.Preco
});
}
categorias.Add(categoria);
}
return(categorias);
}
protected void rptCategoriaInactivo_OnItemCommand(object sender, RepeaterCommandEventArgs e)
{
if (e.CommandName == "Activar")
{
HiddenField hdnIdCategoria = new HiddenField();
hdnIdCategoria = (HiddenField)e.Item.FindControl("hdnIdCategoria");
CategoriaDTO theCategoriaDTO = new CategoriaDTO();
theCategoriaDTO.IdCategoria = decimal.Parse(hdnIdCategoria.Value);
theCategoriaDTO.UsuarioModificacion = myUsuario.Rut;
bool respuesta = YouCom.bll.CategoriaBLL.ActivaCategoria(theCategoriaDTO);
if (respuesta)
{
cargarCategoriaInactivo();
if (!Page.ClientScript.IsClientScriptBlockRegistered("SET"))
{
string script = "alert('Categoria Activada correctamente.');";
Page.ClientScript.RegisterStartupScript(this.GetType(), "SET", script, true);
}
}
else
{
}
}
}
public IList <ProductoDTO> ObtenerPorCategoria(CategoriaDTO categoria)
{
ProductoServicio serv = new ProductoServicio();
IList <ProductoDTO> producto = serv.ObtenerPorCategoria(categoria);
return(producto);
}
public IHttpActionResult PutCategoria(int id, CategoriaDTO categoriaDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != categoriaDTO.CategoriaId)
{
return(BadRequest());
}
try
{
var categoriaDomain = AutoMapper.Mapper.Map <Categoria>(categoriaDTO);
//var tagBase = _categoriaService.ObterPorId(id);
//tagBase.(categoriaDomain);
_categoriaService.Alterar(categoriaDomain);
}
catch (Exception)
{
return(BadRequest());
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult <CategoriaViewModel> Post([FromBody] CategoriaDTO dto)
{
var categoria = new Categoria(dto.Nome);
_categoriaApp.Save(categoria);
return(Ok("Categoria salva com sucesso"));
}
public CategoriaDTO Adicionar(CategoriaDTO dto)
{
try
{
ComandText = "stp_GER_GRUPO_CLIENTE_ADICIONAR";
AddParameter("@CODIGO", dto.Codigo);
AddParameter("@DESCRICAO", dto.Descricao);
AddParameter("@SIGLA", dto.Sigla ?? string.Empty);
AddParameter("@SITUACAO", dto.Estado);
AddParameter("@TABELA_PRECO", dto.TablePriceID);
AddParameter("@CONDICAO_PAGAMENTO", dto.PaymentTermsID);
AddParameter("@LIMITE_CREDITO", dto.LimiteCredito);
AddParameter("@PROMOCAO_ID", dto.PromocaoID);
AddParameter("@VALOR_DESCONTO", dto.ValorDesconto);
AddParameter("@UTILIZADOR", dto.Utilizador);
dto.Codigo = ExecuteInsert();
dto.Sucesso = true;
}
catch (Exception ex)
{
dto.Sucesso = false;
dto.MensagemErro = ex.Message.Replace("'", "");
}
finally
{
FecharConexao();
}
return(dto);
}
protected void btnEditar_Click(object sender, EventArgs e)
{
UserControl wucCondominio = (UserControl)Page.Master.FindControl("ContentPlaceHolder1").FindControl("wucCondominio1");
DropDownList ddlCondominio = (DropDownList)wucCondominio.FindControl("ddlCondominio");
DropDownList ddlComunidad = (DropDownList)wucCondominio.FindControl("ddlComunidad");
btnEditar.Visible = false;
btnGrabar.Visible = true;
ArchivoDTO theArchivoDTO = new ArchivoDTO();
theArchivoDTO.ArchivoId = decimal.Parse(this.hdnArchivoId.Value);
theArchivoDTO.ArchivoTitulo = this.txtArchivoTitulo.Text.ToUpper();
theArchivoDTO.ArchivoDescripcion = this.txtArchivoDescripcion.Text.ToUpper();
YouCom.DTO.Seguridad.CondominioDTO myCondominioDTO = new YouCom.DTO.Seguridad.CondominioDTO();
myCondominioDTO.IdCondominio = decimal.Parse(ddlCondominio.SelectedValue);
theArchivoDTO.TheCondominioDTO = myCondominioDTO;
YouCom.DTO.Seguridad.ComunidadDTO myComunidadDTO = new YouCom.DTO.Seguridad.ComunidadDTO();
myComunidadDTO.IdComunidad = decimal.Parse(ddlComunidad.SelectedValue);
theArchivoDTO.TheComunidadDTO = myComunidadDTO;
CategoriaDTO myCategoria = new CategoriaDTO();
myCategoria.IdCategoria = decimal.Parse(this.ddlCategoria.SelectedValue);
theArchivoDTO.TheCategoriaDTO = myCategoria;
theArchivoDTO.UsuarioModificacion = myUsuario.Rut;
if (this.FileArchivo.HasFile)
{
theArchivoDTO.ArchivoNombre = this.ProcessOtherFile(FileArchivo, null, YouCom.Service.Generales.General.GetPropiedad("UploadsPathBann"));
}
else
{
YouCom.DTO.ArchivoDTO myArchivoDTO = new YouCom.DTO.ArchivoDTO();
myArchivoDTO = YouCom.bll.ArchivoBLL.detalleArchivo(decimal.Parse(hdnArchivoId.Value));
theArchivoDTO.ArchivoNombre = myArchivoDTO.ArchivoNombre;
}
bool respuesta = YouCom.bll.ArchivoBLL.Update(theArchivoDTO);
if (respuesta)
{
cargarArchivo();
this.txtArchivoTitulo.Text = string.Empty;
this.txtArchivoDescripcion.Text = string.Empty;
if (!Page.ClientScript.IsClientScriptBlockRegistered("SET"))
{
string script = "alert('Archivo editado correctamente.');";
Page.ClientScript.RegisterStartupScript(this.GetType(), "SET", script, true);
}
}
else
{
}
}
private Categoria(CategoriaDTO dto)
{
this.Nome = dto.Nome;
this.Tipo = dto.Tipo;
this.UsuarioId = dto.UsuarioId;
this.CategoriaPaiId = dto.CategoriaPaiId;
}
public async Task <ActionResult> Post([FromBody] CategoriaDTO categoriaDto)
{
try
{
//desde q use a anotação [ApiController] e seja aspNet core 2.1 ou mais, a validação do modelo é feita automaticamente
//if (!ModelState.IsValid)
//{
// return BadRequest(ModelState);
//}
//inclui o produto no contexto e SaveChange "commita" essa adição
var categoria = _mapper.Map <Categoria>(categoriaDto);
_uof.CategoriaRepository.Add(categoria);
await _uof.Commit();
var categoriaDTO = _mapper.Map <CategoriaDTO>(categoria);
return(new CreatedAtRouteResult("ObterCategoria", new { id = categoria.CategoriaId }, categoriaDTO));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError,
"Erro ao tentar criar uma nova categoria"));
}
}
public CategoriaDTO ObtenerPorId(int categoriaId)
{
CategoriaServicio serv = new CategoriaServicio();
CategoriaDTO categoria = serv.ObtenerPorId(categoriaId);
return(categoria);
}
public async void Post_Categoria_AddValidData_Return_CreatedResult()
{
//Arrange
var controller = new CategoriasController(_repositoryMock.Object, _mapperMock.Object);
var cat = new Categoria()
{
Nome = "Teste2", ImagemUrl = "http://www.delsivan.net/Imagens/2.jpg"
};
var catDTO = new CategoriaDTO()
{
Nome = "Teste2", ImagemUrl = "http://www.delsivan.net/Imagens/2.jpg"
};
_repositoryMock.Setup(x => x.CategoriaRepository.Add(cat));
_repositoryMock.Setup(x => x.Commit());
_mapperMock.Setup(x => x.Map <Categoria>(catDTO))
.Returns(cat);
//Act
var data = await controller.Post(catDTO);
//Assert
Assert.IsType <CreatedAtRouteResult>(data);
_repositoryMock.Verify(x => x.CategoriaRepository.Add(cat), Times.Once);
_repositoryMock.Verify(x => x.Commit(), Times.Once);
}
public ResultadoOperacion BorrarCategoria(CategoriaDTO _categoriaDTO)
{
CategoriaServicio serv = new CategoriaServicio();
ResultadoOperacion resultado = serv.BorrarCategoria(_categoriaDTO);
return(resultado);
}
public IHttpActionResult CargarCategoria(CategoriaDTO categoria)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (var context = new EcommerceDbContext())
{
//Instanciando un objeto de la clase categoria
try
{
var catDB = new Categoria()
{
Descripcion = categoria.Nombre
};
context.Categorias.Add(catDB);
context.SaveChanges();
//Guardar el id de la categoria registrada
categoria.CategoriaId = catDB.CategoriaId;
}
catch (Exception e)
{
return(BadRequest(e.InnerException.InnerException.Message));
}
}
return(Ok(categoria));
}
public async Task <ActionResult> Cadastrar(CategoriaViewModel viewModel)
{
CategoriaService svc = new CategoriaService();
var configuration = new MapperConfiguration(cfg =>
{
cfg.CreateMap <CategoriaViewModel, CategoriaDTO>();
});
IMapper mapper = configuration.CreateMapper();
//Transforma o ClienteViewModel em um ClienteDTO.
CategoriaDTO dto = mapper.Map <CategoriaDTO>(viewModel);
try
{
await svc.Insert(dto);
//Se funcionou, para a página inicial.
return(RedirectToAction("Index", "Categoria"));
}
catch (NecoException ex)
{
//Se caiu aqui, o ClienteService lançou a exceção por validação de campos.
ViewBag.ValidationErrors = ex.Erros;
}
catch (Exception ex)
{
//Se caiu aqui, o ClienteService lançou a exceção genérica, provavelmente por falha de acesso ao banco.
ViewBag.ErrorMessage = ex.Message;
}
//Se chegou aqui temos erros.
return(View());
}
public CategoriaDTO Alterar(CategoriaDTO dto)
{
try
{
ComandText = "stp_AUTO_CATEGORIA_ALTERAR";
AddParameter("DESCRICAO", dto.Descricao);
AddParameter("SIGLA", dto.Sigla);
AddParameter("SITUACAO", dto.Estado);
AddParameter("@UTILIZADOR", dto.Utilizador);
AddParameter("CODIGO", dto.Codigo);
dto.Codigo = ExecuteNonQuery();
dto.Sucesso = true;
}
catch (Exception ex)
{
dto.Sucesso = false;
dto.MensagemErro = ex.Message.Replace("'", "");
}
finally
{
FecharConexao();
}
return(dto);
}
public static SolicitudDTO TransferirSolicitud(Solicitud solicitud)
{
CategoriaDTO categoriaDTO = new CategoriaDTO(solicitud.Categoria.Id, solicitud.Categoria.Nombre);
CarreraDTO carreraDTO = new CarreraDTO(solicitud.Carrera.Id, solicitud.Carrera.Nombre,
TransferirDTO.TransferirUsuario(solicitud.Carrera.Usuario));
EventoDTO eventoDTO = new EventoDTO(solicitud.Evento.Id, solicitud.Evento.Nombre, solicitud.Evento.Costo,
solicitud.Evento.Lugar, solicitud.Evento.Fecha_Hora_Salida, solicitud.Evento.Fecha_Hora_Regreso);
RecursoDTO recursoDTO = new RecursoDTO(solicitud.Recurso.Id, solicitud.Recurso.Hospedaje, solicitud.Recurso.Transporte,
solicitud.Recurso.Combustible, solicitud.Recurso.Viatico, solicitud.Recurso.Oficio_Comision,
solicitud.Recurso.Otro);
ActividadDTO actividadDTO = new ActividadDTO(solicitud.Actividad.Id, solicitud.Actividad.CACEI,
solicitud.Actividad.Licenciatura, solicitud.Actividad.Personal,
solicitud.Actividad.ISO, solicitud.Actividad.Posgrado,
solicitud.Actividad.Otro);
ValidacionDTO validacionDTO = new ValidacionDTO(solicitud.Validacion.Id, solicitud.Validacion.Coordinador, solicitud.Validacion.Subdirector,
solicitud.Validacion.Administrador, solicitud.Validacion.Director, solicitud.Validacion.Posgrado);
EstadoDTO estadoDTO = new EstadoDTO(solicitud.Estado.Id, solicitud.Estado.Tipo);
SolicitudDTO solicitudDTO = new SolicitudDTO(solicitud.Correo_Solicitante, solicitud.Id, solicitud.Folio, solicitud.Nombre_Solicitante, solicitud.Numero_Empleado,
categoriaDTO, carreraDTO, eventoDTO, recursoDTO, actividadDTO, validacionDTO, estadoDTO, solicitud.Fecha_Creacion, solicitud.Fecha_Modificacion, solicitud.Comentario_Rechazado);
return(solicitudDTO);
}
public async Task <ActionResult> Cadastrar(CategoriaInsertViewModel viewModel)
{
var configuration = new MapperConfiguration(cfg =>
{
cfg.CreateMap <CategoriaInsertViewModel, CategoriaDTO>();
});
IMapper mapper = configuration.CreateMapper();
// new SERService().GetSERByID(4);
//Transforma o ClienteInsertViewModel em um ClienteDTO
CategoriaDTO dto = mapper.Map <CategoriaDTO>(viewModel);
CategoriaService svc = new CategoriaService();
try
{
await svc.Insert(dto);
return(RedirectToAction("Index", "Produto"));
}
catch (Exception ex)
{
ViewBag.Erros = ex.Message;
}
return(View());
}
public async Task <ActionResult> Put(int id, [FromBody] CategoriaDTO categoriaDto)
{
try
{
//Eu preciso validar se o id é o mesmo do produto informado no Body
if (id != categoriaDto.CategoriaId)
{
return(BadRequest($"Não foi possível atualizar a categoria com id: {id}"));
}
var categoria = _mapper.Map <Categoria>(categoriaDto);
//aqui eu altero o estado da Entidade, para alterado
_uof.CategoriaRepository.Update(categoria);
//em sequida eu preciso savar salvar, "commitar"
await _uof.Commit();
return(Ok($"Categoria com id: {id} foi atualizada com sucesso"));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError,
$"Erro ao tentar atualizar a categoria com id: {id}"));
}
}
private void btnExcluir_Click(object sender, EventArgs e)
{
try
{
if (txtID.Text.Trim().Length == 0)
{
MessageBox.Show("Você deve escolher uma categoria para poder excluir!");
}
else
{
if (MessageBox.Show("Deseja realmente excluir este cara??", "Excluir", MessageBoxButtons.YesNo, MessageBoxIcon.Stop) == DialogResult.Yes)
{
CategoriaDTO categoriaDTO = new CategoriaDTO();
categoriaDTO.Id_categoria = Convert.ToInt32(txtID.Text);
new CategoriaBLL().ExcluirCategoria(categoriaDTO);
gridCategoria.DataSource = new CategoriaBLL().ListarTodasCategorias();
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
new LimpaForm(this);
}
public async void GetCategoriaById_Return_OkResult()
{
//Arrange
var controller = new CategoriasController(_repositoryMock.Object, _mapperMock.Object);
var catId = 10;
var categoriaEsperada = new Categoria {
CategoriaId = 10, Nome = "Teste"
};
var categoriaEsperadaDTO = new CategoriaDTO {
CategoriaId = 10, Nome = "Teste"
};
_repositoryMock.Setup(x => x.CategoriaRepository.GetById(c => c.CategoriaId == catId)).ReturnsAsync(categoriaEsperada);
_mapperMock.Setup(x => x.Map <CategoriaDTO>(categoriaEsperada))
.Returns(categoriaEsperadaDTO);
//Act
var data = await controller.Get(catId);
//Assert
Assert.IsType <CategoriaDTO>(data.Value);
Assert.Equal(catId, data.Value.CategoriaId);
Assert.Equal("Teste", data.Value.Nome);
}
public DocumentoDTO(Documento doc, Mensajeria mensajeria)
{
id = doc.Id;
numero = doc.numero;
tipo = new TipoDeDocumentoDTO(doc.tipoDeDocumento);
categoria = new CategoriaDTO(doc.categoriaDeDocumento);
ticket = doc.ticket;
extracto = doc.extracto;
fechaDeAlta = doc.fecha.ToString("dd/MM/yyyy");
areaCreadora = new AreaDTO(mensajeria.SeOriginoEnArea(doc));
areaActual = new AreaDTO(mensajeria.EstaEnElArea(doc));
areaDestino = new AreaDTO(mensajeria.AreaDestinoPara(doc));
enAreaActualHace = new TiempoEnAreaDTO(mensajeria.TiempoEnElAreaActualPara(doc));
comentarios = doc.comentarios;
if (doc.fecha_documento.ToString() != "")
{
FechaDocumento = doc.fecha_documento.ToString();
}
estado = "Recibido";
if (areaDestino.id > -1)
{
estado = "A remitir";
}
historial = new List <TransicionDeDocumentoDTO>();
mensajeria.HistorialDetransicionesPara(doc).ForEach(t => historial.Add(new TransicionDeDocumentoDTO(t)));
}
public IActionResult Put([FromBody] CategoriaDTO categoryTemporary)
{
if (categoryTemporary.Id > 0)
{
try{
var category = database.Categorias.First(cat => cat.Id == categoryTemporary.Id);
if (categoryTemporary != null)
{
category.Nome = categoryTemporary.Nome;
database.SaveChanges();
return(Ok());
}
else
{
Response.StatusCode = 400;
return(new ObjectResult(new { msg = "Categoria não encontrada!" }));
}
}catch (Exception) {
Response.StatusCode = 400;
return(new ObjectResult(new { msg = "Categoria não encontrada!" }));
}
}
else
{
Response.StatusCode = 400;
return(new ObjectResult(new { msg = "Id de Categoria inválido!" }));
}
}
public async Task <IActionResult> Create([FromBody] CategoriaDTO categoriadto)
{
Categoria cat;
if (categoriadto.SuperCategoria == null)
{
cat = new Categoria {
Nome = categoriadto.Nome, SuperCatID = null
};
await _repository.Create(cat);
}
else
{
cat = new Categoria {
Nome = categoriadto.Nome, SuperCatID = categoriadto.SuperCategoria.Value
};
int SuperCategoriaID = categoriadto.SuperCategoria.Value;
var SuperCategoria = await _repository.GetById(SuperCategoriaID);
SuperCategoria.AdicionarSubCategoria(cat);
await _repository.SaveChangesAsync();
}
var dto = _mapper.Map <Categoria, CategoriaDTO>(cat);
return(Created("Categoria criada", dto));
}
private void btnCONFIRMAR_Click(object sender, EventArgs e)
{
CategoriaDTO categoriaDTO = new CategoriaDTO
{
Categoria = txtNome.Text
};
try
{
if (Resposta == "Sem alterações")
{
categoriaDTO.ID_Categoria = ID;
}
if (ID > 0)
{
business.Alterar(categoriaDTO);
string mensagem = "Alterado com sucesso";
Mbox.Info(mensagem);
Resposta = "Alterado";
Close();
}
_ = business.Salvar(categoriaDTO);
}
catch (Exception a)
{
MessageBox.Show(a.Message);
}
}
public CategoriaDTO Adicionar(CategoriaDTO dto)
{
try
{
ComandText = "stp_CLI_LABORATORIO_CATEGORIA_EXAME_ADICIONAR";
AddParameter("@CODIGO", dto.Codigo);
AddParameter("DESCRICAO", dto.Descricao);
AddParameter("SIGLA", dto.Sigla);
AddParameter("SITUACAO", dto.Estado);
AddParameter("@CATEGORIA", dto.Categoria);
AddParameter("@UTILIZADOR", dto.Utilizador);
AddParameter("@FILIAL", dto.Filial);
dto.Codigo = ExecuteInsert();
dto.Sucesso = true;
}
catch (Exception ex)
{
dto.Sucesso = false;
dto.MensagemErro = ex.Message.Replace("'", "");
}
finally
{
FecharConexao();
}
return(dto);
}
public void RegistrarCategoria()
{
var proxiesCategoria = new CategoriaServiceClient();
var addCategoria = new CategoriaDTO()
{
CategoriaId = CategoriaId,
Descripcion = Descripcion
};
proxiesCategoria.CrearCategoriaAsync(addCategoria);
ListCategoria.Add(addCategoria);
MessageBox.Show("La Categoria ha sido Registrado");
}
public void ObtenerCqategoria()
{
var proxiesCategoria = new CategoriaServiceClient();
var Categoria = proxiesCategoria.ObtenerCategoria();
if (Categoria!=null)
{
foreach (var item in Categoria)
{
var obtenerCategoria = new CategoriaDTO
{
CategoriaId = item.CategoriaId,
Descripcion = item.Descripcion
};
ListCategoria.Add(obtenerCategoria);
ListCategoriaOriginal.Add(obtenerCategoria);
}
}
proxiesCategoria.ObtenerCategoriaAsync();
}
