public List <CategoriasDTO> GetAll()
{
con.Open();
SqlCommand cmd = new SqlCommand();
SqlDataReader reader;
cmd.CommandText = "select c.*, (select count(*) as Cantidad from Productos p where p.CodCategoria = c.CodGrupo) as Cantidad from Categoria c where c.Estado = 1";
cmd.CommandType = CommandType.Text;
cmd.Connection = con;
reader = cmd.ExecuteReader();
List <CategoriasDTO> retorno = new List <CategoriasDTO>();
while (reader.Read())
{
CategoriasDTO item = new CategoriasDTO();
item.Id = Convert.ToInt32(reader["Id"]);
item.CodGrupo = reader["CodGrupo"].ToString();
item.DesGrupo = reader["DesGrupo"].ToString();
item.Imagen = reader["Imagen"].ToString();
item.Estado = Convert.ToInt32(reader["Estado"]);
item.Cantidad = Convert.ToInt32(reader["Cantidad"]);
retorno.Add(item);
}
reader.Close();
con.Close();
return(retorno);
}
public List <CategoriasDTO> getList()
{
try
{
List <Categorias> categoriasModel = db.Categorias.Where(x => x.estado == true).ToList();
categoriasModel = categoriasModel.GroupBy(x => x.nombre).Select(x => x.FirstOrDefault()).ToList();
List <CategoriasDTO> responseList = new List <CategoriasDTO>();
foreach (var item in categoriasModel)
{
CategoriasDTO anuncioModel = new CategoriasDTO();
anuncioModel.nombre = item.nombre;
anuncioModel.id = item.id;
if (item.icono != null)
{
anuncioModel.path = imageHelper.GetImageFromByteArray(item.icono);
}
responseList.Add(anuncioModel);
}
return(responseList);
}
catch (Exception)
{
throw;
}
}
public ActionResult Categoria(int idCat, string SearchString, int?Tipo, string min, string max, int?page, int?rows)
{
user_sitio = Session["usuario"] as UsuarioSite;
List <CategoriasDTO> cat = proIBL.ObtenerCategoriasPorTienda(user_sitio.idTienda);
CategoriasDTO aux = cat.FirstOrDefault(c => c.CategoriaId == idCat);
ViewBag.idCat = idCat;
ViewBag.nomCat = aux.Nombre;
if (page == null)
{
page = 1;
}
if (rows == null)
{
rows = 10;
}
var lista = subIBL.ObtenerSubastasPorCriterio(user_sitio.Dominio, idCat, SearchString, Tipo, min, max).ToList();
//var lista = subIBL.ObtenerSubastasCompleto(user_sitio.Dominio, idCat, SearchString, Tipo, min, max, (int)page, (int)rows).ToList();
//ViewBag.ListaSubastas = lista;
var totalRows = lista.Count();
var totalPages = (int)Math.Ceiling((double)totalRows / (int)rows);
//var pageIndex = (page ?? 1) - 1;
//var usersAsIPagedList = new StaticPagedList<Subasta>(lista, (int)pageIndex, totalPages, totalRows);
var usersAsIPagedList = lista.ToPagedList((int)page, (int)rows);
ViewBag.ListaSubastas = usersAsIPagedList;
return(View());
}
public CategoriasDTO Update(CategoriasDTO categorias)
{
try
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <CategoriasDTO, Categorias>();
});
IMapper mapper = config.CreateMapper();
Categorias categoriasModel = mapper.Map <CategoriasDTO, Categorias>(categorias);
db.Entry(categoriasModel).State = EntityState.Modified;
db.SaveChanges();
categorias = this.Find(categorias.id);
ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgSuccess(entidad), Helpers.InfoMensajes.ConstantsLevels.SUCCESS);
return(categorias);
}
catch (Exception ex)
{
ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgError(entidad), Helpers.InfoMensajes.ConstantsLevels.ERROR);
return(categorias);
}
}
public ActionResult EditCategoria([Bind(Include = "CategoriaId,TiendaId,Nombre")] CategoriasDTO categoriasDTO)
{
if (ModelState.IsValid)
{
_blcategoria.ActualizarCategoria(categoriasDTO);
return(RedirectToAction("Index", new { id = this.Session["_tiendaSesion"] }));
}
return(View(categoriasDTO));
}
public ActionResult EditItem([Bind(Include = "id,nombre")] CategoriasDTO periodos)
{
if (ModelState.IsValid)
{
periodos = categoriasDAO.Update(periodos);
return(PartialView("Confirm", periodos));
}
return(PartialView("Edit", periodos));
}
public CategoriasDTO PostCategoria(Categoria nova_categoria)
{
CategoriasDTO categoriaDTO = categoriaRepository.InsertCategoria(nova_categoria);
categoriaRepository.SaveCategoria();
categoriaDTO.CategoriaID = nova_categoria.CategoriaID;
return(categoriaDTO);
}
// GET: Categorias/Delete/5
public ActionResult DeleteCategoria(int id)
{
CategoriasDTO categoriasDTO = _blcategoria.ObtenerCategoria(id);
if (categoriasDTO == null)
{
return(HttpNotFound());
}
return(View(categoriasDTO));
}
private static CategoriasDTO filaDTOCategoria(Categorias_DS.CategoriasRow filas)
{
CategoriasDTO objCate = new CategoriasDTO();
objCate.id_categoria = filas.id_categoria;
objCate.nombre_categoria = filas.nombre_categoria;
objCate.descripcion = filas.descripcion;
objCate.codigo = filas.codigo;
return(objCate);
}
public ActionResult CreateCategoria([Bind(Include = "CategoriaId,TiendaId,Nombre")] CategoriasDTO categoriasDTO)
{
if (ModelState.IsValid)
{
categoriasDTO.TiendaId = Int32.Parse(this.Session["_tiendaSesion"].ToString());
_blcategoria.AgregarCategoria(categoriasDTO);
return(RedirectToAction("Index", new { id = this.Session["_tiendaSesion"] }));
}
return(View(categoriasDTO));
}
public void AgregarCategoria(CategoriasDTO categoriaDTO)
{
try
{
db.Categorias.Add(categoriaDTO);
db.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CategoriasDTO peridos = categoriasDAO.Find(id);
if (peridos == null)
{
return(HttpNotFound());
}
return(PartialView(peridos));
}
public CategoriasDTO ObtenerCategoriaByNombre(int tenant, String nombre)
{
CategoriasDTO Cat = null;
try
{
Cat = db.Categorias.Where(c => c.TiendaId == tenant && c.Nombre == nombre).First();
return(Cat);
}
catch (Exception e)
{
throw e;
}
}
// GET: ConfiguracionEmpresa/RazonesSociales/Delete/5
public ActionResult DeleteItem(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CategoriasDTO categoria = categoriasDAO.Find(id);
if (categoria == null)
{
return(HttpNotFound());
}
return(PartialView("Delete", categoria));
}
public CategoriasDTO PutCategoria(int id, Categoria categoriaEditada)
{
Categoria categoria = new Categoria()
{
CategoriaID = categoriaEditada.CategoriaID,
Nome = categoriaEditada.Nome
};
categoriaRepository.UpdateCategoria(categoria);
categoriaRepository.SaveCategoria();
CategoriasDTO categoriaDTO = categoriaRepository.GetCategoriaByID(categoriaEditada.CategoriaID);
return(categoriaDTO);
}
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CategoriasDTO periodo = categoriasDAO.Find(id);
if (periodo == null)
{
return(HttpNotFound());
}
return(PartialView("Details", periodo));
}
public async Task <CategoriasDTO> BuscarCategoria(CategoriasDTO categoriaParaBuscar)
{
if (categoriaParaBuscar == null)
{
throw new ArgumentNullException("No puedes buscar una categoria si categoriaParaBuscar es nulo!.");
}
if (categoriaParaBuscar.Consecutivo <= 0)
{
throw new ArgumentException("categoriaParaBuscar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
CategoriasDTO categoriaBuscada = await client.PostAsync("Categorias/BuscarCategoria", categoriaParaBuscar);
return(categoriaBuscada);
}
public void ActualizarCategoria(CategoriasDTO categoriaDTO)
{
try
{
var categoria = db.Categorias.FirstOrDefault(r => r.CategoriaId == categoriaDTO.CategoriaId);
if (categoria != null)
{
categoria.Nombre = categoriaDTO.Nombre;
db.SaveChanges();
}
}
catch (Exception e)
{
throw e;
}
}
public async Task <WrapperSimpleTypesDTO> EliminarCategoria(CategoriasDTO categoriaParaEliminar)
{
if (categoriaParaEliminar == null)
{
throw new ArgumentNullException("No puedes eliminar una categoria si categoriaParaEliminar es nulo!.");
}
if (categoriaParaEliminar.Consecutivo <= 0 || categoriaParaEliminar.CodigoArchivo <= 0)
{
throw new ArgumentException("categoriaParaEliminar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
WrapperSimpleTypesDTO wrapperEliminarCategoria = await client.PostAsync <CategoriasDTO, WrapperSimpleTypesDTO>("Categorias/EliminarCategoria", categoriaParaEliminar);
return(wrapperEliminarCategoria);
}
public async Task <List <CategoriasDTO> > ListarCategoriasPorIdioma(CategoriasDTO categoriaParaListar)
{
if (categoriaParaListar == null)
{
throw new ArgumentNullException("No puedes listar una categoria si categoriaParaListar es nulo!.");
}
if (categoriaParaListar.IdiomaBase == Idioma.SinIdioma)
{
throw new ArgumentException("categoriaParaListar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
List <CategoriasDTO> listaCategorias = await client.PostAsync <CategoriasDTO, List <CategoriasDTO> >("Categorias/ListarCategoriasPorIdioma", categoriaParaListar);
return(listaCategorias);
}
public async Task <WrapperSimpleTypesDTO> CrearCategoria(CategoriasDTO categoriaParaCrear)
{
if (categoriaParaCrear == null || categoriaParaCrear.CategoriasContenidos == null)
{
throw new ArgumentNullException("No puedes crear una categoria si categoriaParaCrear o su contenido es nula!.");
}
if (categoriaParaCrear.CategoriasContenidos.Count <= 0 || !categoriaParaCrear.CategoriasContenidos.All(x => !string.IsNullOrWhiteSpace(x.Descripcion) && x.CodigoIdioma > 0) ||
categoriaParaCrear.Archivos == null || categoriaParaCrear.Archivos.ArchivoContenido == null)
{
throw new ArgumentException("categoriaParaCrear vacia y/o invalida!.");
}
IHttpClient client = ConfigurarHttpClient();
WrapperSimpleTypesDTO wrapperCrearCategoria = await client.PostAsync <CategoriasDTO, WrapperSimpleTypesDTO>("Categorias/CrearCategoria", categoriaParaCrear);
return(wrapperCrearCategoria);
}
public List <AnuncioDTO> filterByCategoriaName(string nombre)
{
try
{
CategoriasDTO categoria = categoriasDAO.FindByName(nombre);
List <AnuncioDTO> response = ListarAnuncios();
response = response.Where(x => x.categoria.nombre.Equals(nombre)).ToList();
//if (response == null)
//{
// response = new List<AnuncioDTO>();
//}
return(response);
}
catch (Exception)
{
throw;
}
}
internal CategoriasDTO FindByName(string name)
{
try
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Categorias, CategoriasDTO>();
});
IMapper mapper = config.CreateMapper();
//Mapeo de clase
Categorias model = db.Categorias.FirstOrDefault(x => x.nombre.Equals(name));
CategoriasDTO response = mapper.Map <Categorias, CategoriasDTO>(model);
return(response);
}
catch (Exception)
{
throw;
}
}
public CategoriasDTO Find(int?id)
{
try
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Categorias, CategoriasDTO>();
});
IMapper mapper = config.CreateMapper();
//Mapeo de clase
Categorias model = db.Categorias.Find(id);
CategoriasDTO response = mapper.Map <Categorias, CategoriasDTO>(model);
return(response);
}
catch (Exception)
{
throw;
}
}
public ActionResult CreateNew([Bind(Include = "id,nombre")] object sender, EventArgs e)
{
try
{
// TODO: Add insert logic here
CategoriasDTO categoria = new CategoriasDTO();
categoria.nombre = Request.Form["nombre"];
if (categoria.nombre != "")
{
var binaryReader = new BinaryReader(Request.Files["imagen"].InputStream);
categoria.icono = binaryReader.ReadBytes(Request.Files["imagen"].ContentLength);
categoriasDAO.Add(categoria);
return(RedirectToAction("Index"));
}
return(PartialView("Create", categoria));
}
catch
{
return(View());
}
}
public override async void Init(object initData)
{
base.Init(initData);
CategoriasDTO categoria = new CategoriasDTO
{
IdiomaBase = App.IdiomaPersona
};
try
{
if (IsNotConnected)
{
return;
}
Categorias = new ObservableCollection <CategoriasModel>(CategoriasModel.CrearListaCategorias(await _categoriaService.ListarCategoriasPorIdioma(categoria)));
}
catch (Exception)
{
}
}
public void Add(CategoriasDTO categoria)
{
try
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <CategoriasDTO, Categorias>();
});
IMapper mapper = config.CreateMapper();
//Mapeo de clase
Categorias anunciolModel = mapper.Map <CategoriasDTO, Categorias>(categoria);
ViewInfoMensaje.setMensaje(controller, MensajeBuilder.CrearMsgSuccess(entidad), ConstantsLevels.SUCCESS);
db.Categorias.Add(anunciolModel);
db.SaveChanges();
}
catch (Exception ex)
{
throw ex;
}
}
public void GuardarAnuncio(string user, AnuncioDTO anuncio, string categoria, string duracion, string localidad)
{
try
{
int categoriaId = Int32.Parse(categoria);
CategoriasDTO cat = categoriasDAO.Find(categoriaId);
anuncio.categoria = cat;
anuncio.fechaActivacion = DateTime.Today;
int localidadId = Int32.Parse(localidad);
LocalidadesDTO loc = localidadesDAO.Find(localidadId);
anuncio.localidad = loc;
anuncio.fechaCancelacion = anuncio.fechaActivacion.AddDays(60);
Anuncio anuncioModel = new Anuncio();
anuncioModel.titulo = anuncio.titulo;
anuncioModel.imagen = anuncio.imagen;
anuncioModel.descripcion = anuncio.descripcion;
anuncioModel.actImagen = anuncio.actImagen;
anuncioModel.nombreContacto = anuncio.nombreContacto;
anuncioModel.telefono = anuncio.telefono;
anuncioModel.celularContacto = anuncio.celularContacto;
anuncioModel.actCatalogo = anuncio.actCatalogo;
anuncioModel.fechaActivacion = anuncio.fechaActivacion;
anuncioModel.fechaCancelacion = anuncio.fechaCancelacion;
anuncioModel.categoria = db.Categorias.Find(anuncio.categoria.id);
anuncioModel.localidad = db.Localidades.Find(anuncio.localidad.id);
Usuarios usuario = db.Usuarios.FirstOrDefault(x => x.correo.Equals(user));
usuario.anuncios.Add(anuncioModel);
db.Entry(usuario).State = EntityState.Modified;
db.SaveChanges();
}
catch (Exception ex)
{
throw;
}
}
public void ActualizarCategoria(CategoriasDTO categoriaDTO)
{
_dal.ActualizarCategoria(categoriaDTO);
}
public void AgregarCategoria(CategoriasDTO categoriaDTO)
{
_dal.AgregarCategoria(categoriaDTO);
}