public async Task <CategoriasEventos> ModificarCategoriaEvento(CategoriasEventos categoriaEventoParaModificar)
{
CategoriasEventos categoriaEventoExistente = await _context.CategoriasEventos.Where(x => x.Consecutivo == categoriaEventoParaModificar.Consecutivo).FirstOrDefaultAsync();
categoriaEventoExistente.CodigoCategoria = categoriaEventoParaModificar.CodigoCategoria;
return(categoriaEventoExistente);
}
public async Task <WrapperSimpleTypesDTO> EliminarGrupoEvento(GruposEventos grupoEventoParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
CategoriasRepository categoriaRepo = new CategoriasRepository(context);
CategoriasEventos categoriaGrupoParaBorrar = new CategoriasEventos
{
CodigoEvento = grupoEventoParaEliminar.Consecutivo
};
categoriaRepo.EliminarMultiplesCategoriasEventos(categoriaGrupoParaBorrar);
GruposRepository grupoRepository = new GruposRepository(context);
GruposEventosAsistentes gruposAsistentesParaBorrar = new GruposEventosAsistentes
{
CodigoEvento = grupoEventoParaEliminar.Consecutivo
};
grupoRepository.EliminarMultiplesGrupoEventoAsistente(gruposAsistentesParaBorrar);
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Notificaciones notificacionEvento = new Notificaciones
{
CodigoEvento = grupoEventoParaEliminar.Consecutivo
};
noticiasRepo.EliminarNotificacionesDeUnEvento(notificacionEvento);
int?archivoGrupoEvento = await grupoRepository.BuscarArchivoGrupoEvento(grupoEventoParaEliminar);
grupoRepository.EliminarGrupoEvento(grupoEventoParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarGrupoEvento = new WrapperSimpleTypesDTO();
wrapperEliminarGrupoEvento.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (archivoGrupoEvento.HasValue)
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivoParaEliminar = new Archivos
{
Consecutivo = archivoGrupoEvento.Value,
};
archivoRepo.EliminarArchivo(archivoParaEliminar);
}
wrapperEliminarGrupoEvento.NumeroRegistrosAfectados += await context.SaveChangesAsync();
if (wrapperEliminarGrupoEvento.NumeroRegistrosAfectados > 0)
{
wrapperEliminarGrupoEvento.Exitoso = true;
}
return(wrapperEliminarGrupoEvento);
}
}
public async Task <WrapperSimpleTypesDTO> ModificarInformacionGrupoEvento(GruposEventos grupoEventoParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
GruposRepository grupoRepository = new GruposRepository(context);
if (!grupoEventoParaModificar.CodigoArchivo.HasValue || grupoEventoParaModificar.CodigoArchivo <= 0)
{
int?codigoArchivo = await grupoRepository.BuscarArchivoGrupoEvento(grupoEventoParaModificar);
if (codigoArchivo.HasValue && codigoArchivo > 0)
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivo = new Archivos
{
Consecutivo = codigoArchivo.Value
};
archivoRepo.EliminarArchivo(archivo);
}
}
GruposEventos grupoEventoExistente = await grupoRepository.ModificarInformacionGrupoEvento(grupoEventoParaModificar);
if (grupoEventoParaModificar.CategoriasEventos != null && grupoEventoParaModificar.CategoriasEventos.Count > 0)
{
CategoriasRepository categoriaRepo = new CategoriasRepository(context);
CategoriasEventos categoriaEventos = new CategoriasEventos
{
CodigoEvento = grupoEventoParaModificar.Consecutivo
};
categoriaRepo.EliminarMultiplesCategoriasEventos(categoriaEventos);
categoriaRepo.CrearListaCategoriaEventos(grupoEventoParaModificar.CategoriasEventos);
}
WrapperSimpleTypesDTO wrapperModificarInformacionGrupoEvento = new WrapperSimpleTypesDTO();
wrapperModificarInformacionGrupoEvento.NumeroRegistrosAfectados = await context.SaveChangesAsync();
wrapperModificarInformacionGrupoEvento.Exitoso = true;
return(wrapperModificarInformacionGrupoEvento);
}
}
public async Task <IHttpActionResult> EliminarCategoriaEvento(CategoriasEventos categoriaEventoParaBorrar)
{
if (categoriaEventoParaBorrar == null || categoriaEventoParaBorrar.Consecutivo <= 0)
{
return(BadRequest("categoriaEventoParaBorrar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperEliminarCategoriaEvento = await _categoriasBusiness.EliminarCategoriaEvento(categoriaEventoParaBorrar);
return(Ok(wrapperEliminarCategoriaEvento));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> ListarCategoriasDeUnEventoPorIdioma(CategoriasEventos categoriaEventoParaListar)
{
if (categoriaEventoParaListar == null || categoriaEventoParaListar.CodigoEvento <= 0 || categoriaEventoParaListar.IdiomaBase == Idioma.SinIdioma)
{
return(BadRequest("categoriaEventoAListar vacio y/o invalido!."));
}
try
{
List <CategoriasEventosDTO> listaCategoriasEventos = await _categoriasBusiness.ListarCategoriasDeUnEventoPorIdioma(categoriaEventoParaListar);
return(Ok(listaCategoriasEventos));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> CrearCategoriaEventos(CategoriasEventos categoriaEventoParaCrear)
{
if (categoriaEventoParaCrear == null || categoriaEventoParaCrear.CodigoCategoria > 0 || categoriaEventoParaCrear.CodigoEvento > 0)
{
return(BadRequest("categoriaCandidatoParaCrear vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperCrearCategoriaEventos = await _categoriasBusiness.CrearCategoriaEventos(categoriaEventoParaCrear);
return(Ok(wrapperCrearCategoriaEventos));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <WrapperSimpleTypesDTO> EliminarCategoriaEvento(CategoriasEventos categoriaEventoParaBorrar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
categoriasRepo.EliminarCategoriaEvento(categoriaEventoParaBorrar);
WrapperSimpleTypesDTO wrapperEliminarCategoriaEvento = new WrapperSimpleTypesDTO();
wrapperEliminarCategoriaEvento.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarCategoriaEvento.NumeroRegistrosAfectados > 0)
{
wrapperEliminarCategoriaEvento.Exitoso = true;
}
return(wrapperEliminarCategoriaEvento);
}
}
public async Task <WrapperSimpleTypesDTO> CrearCategoriaEventos(CategoriasEventos categoriaEventoParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
categoriasRepo.CrearCategoriaEventos(categoriaEventoParaCrear);
WrapperSimpleTypesDTO wrapperCategoriaEventos = new WrapperSimpleTypesDTO();
wrapperCategoriaEventos.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCategoriaEventos.NumeroRegistrosAfectados > 0)
{
wrapperCategoriaEventos.Exitoso = true;
wrapperCategoriaEventos.ConsecutivoCreado = categoriaEventoParaCrear.Consecutivo;
}
return(wrapperCategoriaEventos);
}
}
public async Task <List <CategoriasEventosDTO> > ListarCategoriasDeUnEventoPorIdioma(CategoriasEventos categoriaEventoParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
List <CategoriasEventosDTO> listaCategoriaEvento = await categoriasRepo.ListarCategoriasDeUnEventoPorIdioma(categoriaEventoParaListar);
return(listaCategoriaEvento);
}
}
public async Task <CategoriasEventosDTO> BuscarCategoriaEventoPorConsecutivoAndIdioma(CategoriasEventos categoriaEventoParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
CategoriasEventosDTO categoriaEventoBuscada = await categoriasRepo.BuscarCategoriaEventoPorConsecutivoAndIdioma(categoriaEventoParaBuscar);
return(categoriaEventoBuscada);
}
}
public async Task <IHttpActionResult> BuscarCategoriaEventoPorConsecutivoAndIdioma(CategoriasEventos categoriaEventoParaBuscar)
{
if (categoriaEventoParaBuscar == null || categoriaEventoParaBuscar.Consecutivo <= 0 || categoriaEventoParaBuscar.IdiomaBase == Idioma.SinIdioma)
{
return(BadRequest("categoriaEventoParaBuscar vacio y/o invalido!."));
}
try
{
CategoriasEventosDTO categoriaEventoBuscada = await _categoriasBusiness.BuscarCategoriaEventoPorConsecutivoAndIdioma(categoriaEventoParaBuscar);
return(Ok(categoriaEventoBuscada));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public void EliminarMultiplesCategoriasEventos(CategoriasEventos categoriaEventoParaBorrar)
{
_context.CategoriasEventos.RemoveRange(_context.CategoriasEventos.Where(x => x.CodigoEvento == categoriaEventoParaBorrar.CodigoEvento));
}
public void EliminarCategoriaEvento(CategoriasEventos categoriaEventoParaBorrar)
{
_context.CategoriasEventos.Attach(categoriaEventoParaBorrar);
_context.CategoriasEventos.Remove(categoriaEventoParaBorrar);
}
public async Task <List <CategoriasEventosDTO> > ListarCategoriasDeUnEventoPorIdioma(CategoriasEventos categoriaEventoParaListar)
{
IQueryable <CategoriasEventos> queryEventos = _context.CategoriasEventos.Where(x => x.CodigoEvento == categoriaEventoParaListar.CodigoEvento).AsQueryable();
List <CategoriasEventosDTO> listaCategoriaEvento = await queryEventos
.Select(x => new CategoriasEventosDTO
{
Consecutivo = x.Consecutivo,
CodigoCategoria = x.CodigoCategoria,
CodigoEvento = x.CodigoEvento,
Categorias = new CategoriasDTO
{
Consecutivo = x.Categorias.Consecutivo,
CodigoArchivo = x.Categorias.CodigoArchivo,
DescripcionIdiomaBuscado = x.Categorias.CategoriasContenidos.Where(y => y.CodigoIdioma == categoriaEventoParaListar.CodigoIdiomaUsuarioBase).Select(y => y.Descripcion).FirstOrDefault(),
CategoriasContenidos = x.Categorias.CategoriasContenidos.Where(y => y.CodigoIdioma == categoriaEventoParaListar.CodigoIdiomaUsuarioBase)
.Select(z => new CategoriasContenidosDTO
{
Consecutivo = z.Consecutivo,
Descripcion = z.Descripcion,
CodigoIdioma = z.CodigoIdioma
}).ToList()
}
})
.AsNoTracking()
.ToListAsync();
return(listaCategoriaEvento);
}
public void CrearCategoriaEventos(CategoriasEventos categoriaEventoParaCrear)
{
_context.CategoriasEventos.Add(categoriaEventoParaCrear);
}
