public async Task <WrapperSimpleTypesDTO> EliminarPais(Paises paisParaEliminar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                Archivos archivo = new Archivos
                {
                    Consecutivo = paisParaEliminar.CodigoArchivo
                };

                AdministracionRepository adminRepo = new AdministracionRepository(context);
                PaisesContenidos         paisContenidoParaBorrar = new PaisesContenidos
                {
                    CodigoPais = paisParaEliminar.Consecutivo
                };

                adminRepo.EliminarMultiplesPaisesContenidos(paisContenidoParaBorrar);
                adminRepo.EliminarPais(paisParaEliminar);

                ArchivosRepository archivoRepo = new ArchivosRepository(context);
                archivoRepo.EliminarArchivo(archivo);

                WrapperSimpleTypesDTO wrapperEliminarPais = new WrapperSimpleTypesDTO();

                wrapperEliminarPais.NumeroRegistrosAfectados = await context.SaveChangesAsync();

                if (wrapperEliminarPais.NumeroRegistrosAfectados > 0)
                {
                    wrapperEliminarPais.Exitoso = true;
                }

                return(wrapperEliminarPais);
            }
        }
Esempio n. 2
0
        public async Task <PaisesContenidos> ModificarPaisContenido(PaisesContenidos paisContenidoParaModificar)
        {
            PaisesContenidos paisContenidoExistente = await _context.PaisesContenidos.Where(x => x.Consecutivo == paisContenidoParaModificar.Consecutivo).FirstOrDefaultAsync();

            paisContenidoExistente.Descripcion = paisContenidoParaModificar.Descripcion.Trim();

            return(paisContenidoExistente);
        }
Esempio n. 3
0
        public async Task <List <PaisesContenidos> > ListarContenidoDeUnPais(PaisesContenidos paisContenidoParaListar)
        {
            List <PaisesContenidos> listaPaisContenidos = await(from categoriaContenido in _context.PaisesContenidos
                                                                where categoriaContenido.CodigoPais == paisContenidoParaListar.CodigoPais
                                                                select categoriaContenido).Include(x => x.Idiomas)
                                                          .AsNoTracking()
                                                          .ToListAsync();

            return(listaPaisContenidos);
        }
        public async Task <List <PaisesContenidos> > ListarContenidoDeUnPais(PaisesContenidos paisContenidoParaListar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                AdministracionRepository adminRepo   = new AdministracionRepository(context);
                List <PaisesContenidos>  listaPaises = await adminRepo.ListarContenidoDeUnPais(paisContenidoParaListar);

                return(listaPaises);
            }
        }
        public async Task <PaisesContenidos> BuscarPaisContenido(PaisesContenidos paisContenidoParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                AdministracionRepository adminRepo            = new AdministracionRepository(context);
                PaisesContenidos         paisContenidoBuscado = await adminRepo.BuscarPaisContenido(paisContenidoParaBuscar);

                return(paisContenidoBuscado);
            }
        }
Esempio n. 6
0
        public async Task <PaisesContenidos> BuscarPaisContenido(PaisesContenidos paisContenidoParaBuscar)
        {
            PaisesContenidos paisContenidoBuscada = await(from paisContenido in _context.PaisesContenidos
                                                          where paisContenido.Consecutivo == paisContenidoParaBuscar.Consecutivo
                                                          select paisContenido).Include(x => x.Idiomas)
                                                    .Include(x => x.Paises)
                                                    .AsNoTracking()
                                                    .FirstOrDefaultAsync();

            return(paisContenidoBuscada);
        }
        public async Task <IHttpActionResult> EliminarPaisContenido(PaisesContenidos paisContenidoParaEliminar)
        {
            if (paisContenidoParaEliminar == null || paisContenidoParaEliminar.Consecutivo <= 0)
            {
                return(BadRequest("paisContenidoParaEliminar vacio y/o invalido!."));
            }

            try
            {
                WrapperSimpleTypesDTO wrapperEliminarPaisContenido = await _adminBusiness.EliminarPaisContenido(paisContenidoParaEliminar);

                return(Ok(wrapperEliminarPaisContenido));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
        public async Task <IHttpActionResult> ModificarPaisContenido(PaisesContenidos paisContenidoParaModificar)
        {
            if (paisContenidoParaModificar == null || paisContenidoParaModificar.Consecutivo <= 0 || string.IsNullOrWhiteSpace(paisContenidoParaModificar.Descripcion))
            {
                return(BadRequest("paisContenidoParaModificar vacio y/o invalido!."));
            }

            try
            {
                WrapperSimpleTypesDTO wrapperModificarPaisContenido = await _adminBusiness.ModificarPaisContenido(paisContenidoParaModificar);

                return(Ok(wrapperModificarPaisContenido));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
        public async Task <IHttpActionResult> ListarContenidoDeUnPais(PaisesContenidos paisContenidoParaListar)
        {
            if (paisContenidoParaListar == null || paisContenidoParaListar.CodigoPais <= 0)
            {
                return(BadRequest("paisContenidoParaListar vacio y/o invalido!."));
            }

            try
            {
                List <PaisesContenidos> listaPaisesContenido = await _adminBusiness.ListarContenidoDeUnPais(paisContenidoParaListar);

                return(Ok(listaPaisesContenido));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
        public async Task <IHttpActionResult> BuscarPaisContenido(PaisesContenidos paisContenidoParaBuscar)
        {
            if (paisContenidoParaBuscar == null || paisContenidoParaBuscar.Consecutivo <= 0)
            {
                return(BadRequest("paisContenidoParaBuscar vacio y/o invalido!."));
            }

            try
            {
                PaisesContenidos paisContenidoBuscada = await _adminBusiness.BuscarPaisContenido(paisContenidoParaBuscar);

                return(Ok(paisContenidoBuscada));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
        public async Task <WrapperSimpleTypesDTO> EliminarPaisContenido(PaisesContenidos paisContenidoParaEliminar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                AdministracionRepository adminRepo = new AdministracionRepository(context);
                adminRepo.EliminarPaisContenido(paisContenidoParaEliminar);

                WrapperSimpleTypesDTO wrapperEliminarPaisContenido = new WrapperSimpleTypesDTO();

                wrapperEliminarPaisContenido.NumeroRegistrosAfectados = await context.SaveChangesAsync();

                if (wrapperEliminarPaisContenido.NumeroRegistrosAfectados > 0)
                {
                    wrapperEliminarPaisContenido.Exitoso = true;
                }

                return(wrapperEliminarPaisContenido);
            }
        }
Esempio n. 12
0
 public void EliminarMultiplesPaisesContenidos(PaisesContenidos paisesContenidosParaBorrar)
 {
     _context.PaisesContenidos.RemoveRange(_context.PaisesContenidos.Where(x => x.CodigoPais == paisesContenidosParaBorrar.CodigoPais));
 }
Esempio n. 13
0
 public void EliminarPaisContenido(PaisesContenidos paisContenidoParaEliminar)
 {
     _context.PaisesContenidos.Attach(paisContenidoParaEliminar);
     _context.PaisesContenidos.Remove(paisContenidoParaEliminar);
 }