public async Task <CategoriasContenidos> ModificarCategoriaContenido(CategoriasContenidos categoriaContenidoParaModificar)
{
CategoriasContenidos categoriaContenidoExistente = await _context.CategoriasContenidos.Where(x => x.Consecutivo == categoriaContenidoParaModificar.Consecutivo).FirstOrDefaultAsync();
categoriaContenidoExistente.Descripcion = categoriaContenidoParaModificar.Descripcion.Trim();
return(categoriaContenidoExistente);
}
public async Task <CategoriasContenidos> BuscarCategoriaContenido(CategoriasContenidos categoriaContenidoParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
CategoriasContenidos categoriaContenidoBuscada = await categoriasRepo.BuscarCategoriaContenido(categoriaContenidoParaBuscar);
return(categoriaContenidoBuscada);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarCategoria(Categorias categoriaParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
if (categoriaParaEliminar.Consecutivo == 3 && categoriaParaEliminar.Consecutivo == 5 &&
categoriaParaEliminar.Consecutivo == 6 && categoriaParaEliminar.Consecutivo == 7)
{
throw new InvalidOperationException("Estas categorias deben existir y si o si ya que son las definidas para la posicion");
}
Archivos archivo = new Archivos
{
Consecutivo = categoriaParaEliminar.CodigoArchivo
};
HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);
Habilidades habilidadesParaBorrar = new Habilidades
{
CodigoCategoria = categoriaParaEliminar.Consecutivo
};
List <int> listaCodigoHabilidades = await habilidadesRepo.ListarCodigoHabilidadesPorCategoria(habilidadesParaBorrar);
foreach (var codigo in listaCodigoHabilidades)
{
habilidadesRepo.EliminarMultiplesHabilidadesContenidosPorCodigoHabilidad(codigo);
}
habilidadesRepo.EliminarMultiplesHabilidadesPorCodigoCategoria(habilidadesParaBorrar);
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
CategoriasContenidos categoriaContenidoParaBorrar = new CategoriasContenidos
{
CodigoCategoria = categoriaParaEliminar.Consecutivo
};
categoriasRepo.EliminarMultiplesCategoriasContenidos(categoriaContenidoParaBorrar);
categoriasRepo.EliminarCategoria(categoriaParaEliminar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
archivoRepo.EliminarArchivo(archivo);
WrapperSimpleTypesDTO wrapperEliminarCategoria = new WrapperSimpleTypesDTO();
wrapperEliminarCategoria.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarCategoria.NumeroRegistrosAfectados > 0)
{
wrapperEliminarCategoria.Exitoso = true;
}
return(wrapperEliminarCategoria);
}
}
public async Task <CategoriasContenidos> BuscarCategoriaContenido(CategoriasContenidos categoriaContenidoParaBuscar)
{
CategoriasContenidos categoriaContenidoBuscada = await(from categoriaContenido in _context.CategoriasContenidos
where categoriaContenido.Consecutivo == categoriaContenidoParaBuscar.Consecutivo
select categoriaContenido).Include(x => x.Idiomas)
.Include(x => x.Categorias)
.AsNoTracking()
.FirstOrDefaultAsync();
return(categoriaContenidoBuscada);
}
public async Task <IHttpActionResult> EliminarCategoriaContenido(CategoriasContenidos categoriaContenidoParaEliminar)
{
if (categoriaContenidoParaEliminar == null || categoriaContenidoParaEliminar.Consecutivo <= 0)
{
return(BadRequest("categoriaContenidoParaEliminar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperEliminarCategoriaContenido = await _categoriasBusiness.EliminarCategoriaContenido(categoriaContenidoParaEliminar);
return(Ok(wrapperEliminarCategoriaContenido));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> ModificarCategoriaContenido(CategoriasContenidos categoriaContenidoParaModificar)
{
if (categoriaContenidoParaModificar == null || categoriaContenidoParaModificar.Consecutivo <= 0 || string.IsNullOrWhiteSpace(categoriaContenidoParaModificar.Descripcion))
{
return(BadRequest("categoriaParaModificar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperModificarCategoriaContenido = await _categoriasBusiness.ModificarCategoriaContenido(categoriaContenidoParaModificar);
return(Ok(wrapperModificarCategoriaContenido));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> ListarContenidoDeUnaCategoria(CategoriasContenidos categoriaContenidoParaListar)
{
if (categoriaContenidoParaListar == null || categoriaContenidoParaListar.CodigoCategoria <= 0)
{
return(BadRequest("categoriaContenidoParaListar vacio y/o invalido!."));
}
try
{
List <CategoriasContenidos> listaCategoriasContenido = await _categoriasBusiness.ListarContenidoDeUnaCategoria(categoriaContenidoParaListar);
return(Ok(listaCategoriasContenido));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> BuscarCategoriaContenido(CategoriasContenidos categoriaContenidoParaBuscar)
{
if (categoriaContenidoParaBuscar == null || categoriaContenidoParaBuscar.Consecutivo <= 0)
{
return(BadRequest("categoriaContenidoParaBuscar vacio y/o invalido!."));
}
try
{
CategoriasContenidos categoriaContenidoBuscada = await _categoriasBusiness.BuscarCategoriaContenido(categoriaContenidoParaBuscar);
return(Ok(categoriaContenidoBuscada));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <WrapperSimpleTypesDTO> EliminarCategoriaContenido(CategoriasContenidos categoriaContenidoParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
categoriasRepo.EliminarCategoriaContenido(categoriaContenidoParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarCategoriaContenido = new WrapperSimpleTypesDTO();
wrapperEliminarCategoriaContenido.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarCategoriaContenido.NumeroRegistrosAfectados > 0)
{
wrapperEliminarCategoriaContenido.Exitoso = true;
}
return(wrapperEliminarCategoriaContenido);
}
}
public async Task <List <CategoriasContenidos> > ListarContenidoDeUnaCategoria(CategoriasContenidos categoriaContenidoParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
List <CategoriasContenidos> listaCategorias = await categoriasRepo.ListarContenidoDeUnaCategoria(categoriaContenidoParaListar);
return(listaCategorias);
}
}
public async Task <List <CategoriasContenidos> > ListarContenidoDeUnaCategoria(CategoriasContenidos categoriaContenidoParaListar)
{
List <CategoriasContenidos> listaCategoriasContenidos = await(from categoriaContenido in _context.CategoriasContenidos
where categoriaContenido.CodigoCategoria == categoriaContenidoParaListar.CodigoCategoria
select categoriaContenido).Include(x => x.Idiomas)
.AsNoTracking()
.ToListAsync();
return(listaCategoriasContenidos);
}
public void EliminarMultiplesCategoriasContenidos(CategoriasContenidos categoriaContenidoParaBorrar)
{
_context.CategoriasContenidos.RemoveRange(_context.CategoriasContenidos.Where(x => x.CodigoCategoria == categoriaContenidoParaBorrar.CodigoCategoria));
}
public void EliminarCategoriaContenido(CategoriasContenidos categoriaContenidoParaEliminar)
{
_context.CategoriasContenidos.Attach(categoriaContenidoParaEliminar);
_context.CategoriasContenidos.Remove(categoriaContenidoParaEliminar);
}
