public TipoAnunciosDTO Add(string nombre, string duracion, string precio)
        {
            try
            {
                int?            idnombre    = Int32.Parse(nombre);
                int?            idduracion  = Int32.Parse(duracion);
                TipoAnunciosDTO tipoAnuncio = new TipoAnunciosDTO();
                tipoAnuncio.nombre = nombreAnunciosDAO.Find(idnombre);
                var periodo = periodosDAO.Find(idduracion);
                tipoAnuncio.duracion = periodo.nombre;
                tipoAnuncio.precio   = precio;

                TipoAnuncios response = new TipoAnuncios();
                response.nombre        = new NombreAnuncios();
                response.nombre.nombre = tipoAnuncio.nombre.nombre;
                response.precio        = tipoAnuncio.precio;
                response.duracion      = tipoAnuncio.duracion;
                response.nombre        = db.NombreAnuncios.Include(x => x.caracteristicas)
                                         .Include(x => x.noIncluidas).FirstOrDefault(x => x.id == tipoAnuncio.nombre.id);
                db.TiposAnuncio.Add(response);
                db.SaveChanges();
                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.CrearMsgSuccess(entidad), Helpers.InfoMensajes.ConstantsLevels.SUCCESS);
                return(tipoAnuncio);
            }

            catch (Exception)
            {
                throw;
            }
        }
        public TipoAnunciosDTO Update(TipoAnunciosDTO tipoAnuncio)
        {
            try
            {
                TipoAnuncios response = new TipoAnuncios();
                response.id       = tipoAnuncio.id;
                response.duracion = tipoAnuncio.duracion;
                response.nombre   = db.NombreAnuncios.Find(tipoAnuncio.nombreId);
                response.precio   = tipoAnuncio.precio;
                response.nombreId = tipoAnuncio.nombreId;

                db.Entry(tipoAnuncio).State = EntityState.Modified;
                db.SaveChanges();

                tipoAnuncio = this.Find(tipoAnuncio.id);

                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgSuccess(entidad), Helpers.InfoMensajes.ConstantsLevels.SUCCESS);
                return(tipoAnuncio);
            }
            catch (Exception ex)
            {
                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgError(entidad), Helpers.InfoMensajes.ConstantsLevels.ERROR);
                return(tipoAnuncio);
            }
        }
        public CaracteristicasDTO Update(CaracteristicasDTO caracteristicas)
        {
            try
            {
                var config = new MapperConfiguration(cfg =>
                {
                    cfg.CreateMap <CaracteristicasDTO, Caracteristicas>();
                });
                IMapper         mapper = config.CreateMapper();
                Caracteristicas caracteristicasModel = mapper.Map <CaracteristicasDTO, Caracteristicas>(caracteristicas);

                db.Entry(caracteristicasModel).State = EntityState.Modified;
                db.SaveChanges();

                caracteristicas = this.Find(caracteristicas.id);

                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgSuccess(entidad), Helpers.InfoMensajes.ConstantsLevels.SUCCESS);
                return(caracteristicas);
            }
            catch (Exception)
            {
                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgError(entidad), Helpers.InfoMensajes.ConstantsLevels.ERROR);
                return(caracteristicas);
            }
        }
        public NombreAnunciosDTO Add(string nombre, List <string> dataList)
        {
            try
            {
                NombreAnunciosDTO model = new NombreAnunciosDTO();
                model.nombre = nombre;
                List <CaracteristicasDTO> caracteristicas = caracteristicasDAO.getList();
                dataList.ForEach(x =>
                {
                    caracteristicas.ForEach(y =>
                    {
                        if (x == y.id.ToString())
                        {
                            model.caracteristicas.Add(y);
                        }
                    });
                });
                model.noIncluidas = caracteristicas.Except(model.caracteristicas).ToList();
                //var remove = model.noIncluidas.FirstOrDefault(x => x.nombre.Equals("Imagen"));
                //model.noIncluidas.Remove(remove);
                //Mapeo de clase

                NombreAnuncios response = new NombreAnuncios();
                response.nombre = model.nombre;
                model.caracteristicas.ForEach(x =>
                {
                    Caracteristicas item = new Caracteristicas();
                    item.nombre          = x.nombre;
                    item.id = x.id;
                    response.caracteristicas.Add(item);
                });
                model.noIncluidas.ForEach(x =>
                {
                    Caracteristicas item = new Caracteristicas();
                    item.nombre          = x.nombre;
                    item.id = x.id;

                    response.noIncluidas.Add(item);
                });
                db.NombreAnuncios.Add(response);
                db.SaveChanges();
                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.CrearMsgSuccess(entidad), Helpers.InfoMensajes.ConstantsLevels.SUCCESS);
                return(model);
            }

            catch (Exception)
            {
                throw;
            }
        }
 public void Remove(int id)
 {
     try
     {
         Localidades razonsocial = db.Localidades.Find(id);
         razonsocial.estado          = false;
         db.Entry(razonsocial).State = EntityState.Modified;
         db.SaveChanges();
         ViewInfoMensaje.setMensaje(controller, MensajeBuilder.BorrarMsgSuccess(entidad), Helpers.InfoMensajes.ConstantsLevels.SUCCESS);
     }
     catch (Exception)
     {
         ViewInfoMensaje.setMensaje(controller, MensajeBuilder.BorrarMsgError(entidad), Helpers.InfoMensajes.ConstantsLevels.ERROR);
     }
 }
 public void Remove(int id)
 {
     try
     {
         TipoAnuncios tipoAnuncio = db.TiposAnuncio.Find(id);
         tipoAnuncio.estado          = false;
         db.Entry(tipoAnuncio).State = EntityState.Modified;
         db.SaveChanges();
         ViewInfoMensaje.setMensaje(controller, MensajeBuilder.BorrarMsgSuccess(entidad), Helpers.InfoMensajes.ConstantsLevels.SUCCESS);
     }
     catch (Exception)
     {
         ViewInfoMensaje.setMensaje(controller, MensajeBuilder.BorrarMsgError(entidad), Helpers.InfoMensajes.ConstantsLevels.ERROR);
     }
 }
示例#7
0
        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 Add(CaracteristicasDTO caracteristica)
        {
            try
            {
                var config = new MapperConfiguration(cfg =>
                {
                    cfg.CreateMap <CaracteristicasDTO, Caracteristicas>();
                });

                IMapper mapper = config.CreateMapper();
                //Mapeo de clase

                Caracteristicas response = mapper.Map <CaracteristicasDTO, Caracteristicas>(caracteristica);
                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.CrearMsgSuccess(entidad), ConstantsLevels.SUCCESS);
                db.Caracteristicas.Add(response);
                db.SaveChanges();
            }

            catch (Exception)
            {
                throw;
            }
        }
示例#9
0
        public void Add(PeriodosDTO periodo)
        {
            try
            {
                var config = new MapperConfiguration(cfg =>
                {
                    cfg.CreateMap <PeriodosDTO, Periodos>();
                });

                IMapper mapper = config.CreateMapper();
                //Mapeo de clase

                Periodos response = mapper.Map <PeriodosDTO, Periodos>(periodo);
                db.PeriodoAnuncios.Add(response);
                db.SaveChanges();
                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.CrearMsgSuccess(entidad), Helpers.InfoMensajes.ConstantsLevels.SUCCESS);
            }

            catch (Exception)
            {
                throw;
            }
        }
        public LocalidadesDTO Update(LocalidadesDTO localidades)
        {
            try
            {
                var config = new MapperConfiguration(cfg => {
                    cfg.CreateMap <LocalidadesDTO, Localidades>();
                });
                IMapper     mapper           = config.CreateMapper();
                Localidades localidadesModel = mapper.Map <LocalidadesDTO, Localidades>(localidades);

                db.Entry(localidadesModel).State = EntityState.Modified;
                db.SaveChanges();

                localidades = this.Find(localidades.id);

                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgSuccess(entidad), Helpers.InfoMensajes.ConstantsLevels.SUCCESS);
                return(localidades);
            }
            catch (Exception)
            {
                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgError(entidad), Helpers.InfoMensajes.ConstantsLevels.ERROR);
                return(localidades);
            }
        }
示例#11
0
        public AnuncioTrabajoDTO Update(AnuncioTrabajoDTO AnuncioTrabajo)
        {
            try
            {
                var config = new MapperConfiguration(cfg => {
                    cfg.CreateMap <AnuncioTrabajoDTO, AnuncioTrabajo>();
                });
                IMapper        mapper = config.CreateMapper();
                AnuncioTrabajo AnuncioTrabajoModel = mapper.Map <AnuncioTrabajoDTO, AnuncioTrabajo>(AnuncioTrabajo);

                db.Entry(AnuncioTrabajoModel).State = EntityState.Modified;
                db.SaveChanges();

                AnuncioTrabajo = this.Find(AnuncioTrabajo.id);

                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgSuccess(entidad), Helpers.InfoMensajes.ConstantsLevels.SUCCESS);
                return(AnuncioTrabajo);
            }
            catch (Exception ex)
            {
                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgError(entidad), Helpers.InfoMensajes.ConstantsLevels.ERROR);
                return(AnuncioTrabajo);
            }
        }
示例#12
0
        public UsuariosDTO Update(UsuariosDTO periodos, string rol)
        {
            try
            {
                var config = new MapperConfiguration(cfg => {
                    cfg.CreateMap <UsuariosDTO, Usuarios>();
                });
                IMapper  mapper        = config.CreateMapper();
                Usuarios periodosModel = mapper.Map <UsuariosDTO, Usuarios>(periodos);

                db.Entry(periodosModel).State = EntityState.Modified;
                db.SaveChanges();

                periodos = this.Find(periodos.id);

                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgSuccess(entidad), Helpers.InfoMensajes.ConstantsLevels.SUCCESS);
                return(periodos);
            }
            catch (Exception ex)
            {
                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgError(entidad), Helpers.InfoMensajes.ConstantsLevels.ERROR);
                return(periodos);
            }
        }
        public NombreAnunciosDTO Update(int id, string nombre, List <string> dataList)
        {
            NombreAnunciosDTO model = new NombreAnunciosDTO();

            try
            {
                model.nombre = nombre;
                List <CaracteristicasDTO> caracteristicas = caracteristicasDAO.getList();
                dataList.ForEach(x =>
                {
                    caracteristicas.ForEach(y =>
                    {
                        if (x == y.id.ToString())
                        {
                            model.caracteristicas.Add(y);
                        }
                    });
                });
                model.noIncluidas = caracteristicas.Except(model.caracteristicas).ToList();
                //Mapeo de clase

                NombreAnuncios response = db.NombreAnuncios.Include(x => x.caracteristicas).Include(x => x.noIncluidas).First(x => x.id == id);
                response.nombre = model.nombre;
                if (response.caracteristicas.Count == 0)
                {
                    model.caracteristicas.ForEach(y =>
                    {
                        Caracteristicas item = new Caracteristicas();
                        item.nombre          = y.nombre;
                        item.id = y.id;
                        response.caracteristicas.Add(item);
                    });
                }
                else
                {
                    response.caracteristicas.Clear();
                    model.caracteristicas.ForEach(y =>
                    {
                        Caracteristicas item = new Caracteristicas();
                        item.nombre          = y.nombre;
                        item.id = y.id;
                        response.caracteristicas.Add(item);
                    });
                }
                if (response.noIncluidas.Count == 0)
                {
                    model.noIncluidas.ForEach(y =>
                    {
                        Caracteristicas item = new Caracteristicas();
                        item.nombre          = y.nombre;
                        item.id = y.id;
                        response.noIncluidas.Add(item);
                    });
                }
                else
                {
                    response.noIncluidas.Clear();
                    model.noIncluidas.ForEach(x =>
                    {
                        Caracteristicas item = new Caracteristicas();
                        item.nombre          = x.nombre;
                        item.id = x.id;
                        response.noIncluidas.Add(item);
                    });
                }



                db.Entry(response).State = EntityState.Modified;
                db.SaveChanges();

                model = Find(id);

                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgSuccess(entidad), Helpers.InfoMensajes.ConstantsLevels.SUCCESS);
                return(model);
            }
            catch (Exception)
            {
                ViewInfoMensaje.setMensaje(controller, MensajeBuilder.EditarMsgError(entidad), Helpers.InfoMensajes.ConstantsLevels.ERROR);
                return(model);
            }
        }