public async Task <WrapperSimpleTypesDTO> EliminarPlan(Planes planParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
int?codigoTipoPerfilPlan = await planRepository.BuscarCodigoTipoPerfilDeUnPlan(planParaEliminar);
if (!codigoTipoPerfilPlan.HasValue)
{
throw new InvalidOperationException("El plan no tiene un tipo de perfil especificado!. BUUUUUGGGGGG!.");
}
TipoPerfil tipoPerfil = codigoTipoPerfilPlan.Value.ToEnum <TipoPerfil>();
int numeroDePlanesDefault = await planRepository.NumeroPlanesDefault(tipoPerfil);
if (numeroDePlanesDefault <= 1)
{
bool esPlanDefault = await planRepository.BuscarSiPlanEsDefault(planParaEliminar);
if (esPlanDefault)
{
throw new InvalidOperationException("No puedes quedarte sin planes default para el perfil de " + tipoPerfil.ToString() + "!.");
}
}
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Notificaciones notificacion = new Notificaciones
{
CodigoPlanNuevo = planParaEliminar.Consecutivo
};
noticiasRepo.EliminarNotificacionesDeUnPlan(notificacion);
PlanesContenidos planContenido = new PlanesContenidos
{
CodigoPlan = planParaEliminar.Consecutivo
};
planRepository.EliminarMultiplesPlanesContenidos(planContenido);
planRepository.EliminarPlan(planParaEliminar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivo = new Archivos
{
Consecutivo = planParaEliminar.CodigoArchivo
};
archivoRepo.EliminarArchivo(archivo);
WrapperSimpleTypesDTO wrapperEliminarPlan = new WrapperSimpleTypesDTO();
wrapperEliminarPlan.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarPlan.NumeroRegistrosAfectados > 0)
{
wrapperEliminarPlan.Exitoso = true;
}
return(wrapperEliminarPlan);
}
}
public async Task <PlanesContenidos> ModificarPlanContenido(PlanesContenidos planContenidoParaModificar)
{
PlanesContenidos planContenidoExistente = await _context.PlanesContenidos.Where(x => x.Consecutivo == planContenidoParaModificar.Consecutivo).FirstOrDefaultAsync();
planContenidoExistente.Descripcion = planContenidoParaModificar.Descripcion.Trim();
return(planContenidoExistente);
}
public async Task <List <PlanesContenidos> > ListarContenidoDeUnPlan(PlanesContenidos planContenidoParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planesRepo = new PlanesRepository(context);
List <PlanesContenidos> listaPlanes = await planesRepo.ListarContenidoDeUnPlan(planContenidoParaListar);
return(listaPlanes);
}
}
public async Task <PlanesContenidos> BuscarPlanContenido(PlanesContenidos planContenidoParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planesRepo = new PlanesRepository(context);
PlanesContenidos planContenidoBuscado = await planesRepo.BuscarPlanContenido(planContenidoParaBuscar);
return(planContenidoBuscado);
}
}
public async Task <List <PlanesContenidos> > ListarContenidoDeUnPlan(PlanesContenidos planContenidoParaListar)
{
List <PlanesContenidos> listaPlanesContenidos = await(from planContenido in _context.PlanesContenidos
where planContenido.CodigoPlan == planContenidoParaListar.CodigoPlan
select planContenido).Include(x => x.Idiomas)
.AsNoTracking()
.ToListAsync();
return(listaPlanesContenidos);
}
public async Task <PlanesContenidos> BuscarPlanContenido(PlanesContenidos planParaBuscar)
{
PlanesContenidos planContenidoBuscado = await(from planContenido in _context.PlanesContenidos
where planContenido.Consecutivo == planParaBuscar.Consecutivo
select planContenido).Include(x => x.Idiomas)
.Include(x => x.Planes)
.AsNoTracking()
.FirstOrDefaultAsync();
return(planContenidoBuscado);
}
public async Task <IHttpActionResult> EliminarPlanContenido(PlanesContenidos planContenidoParaEliminar)
{
if (planContenidoParaEliminar == null || planContenidoParaEliminar.Consecutivo <= 0)
{
return(BadRequest("planContenidoParaEliminar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperEliminarPlanContenido = await _planesBusiness.EliminarPlanContenido(planContenidoParaEliminar);
return(Ok(wrapperEliminarPlanContenido));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> ModificarPlanContenido(PlanesContenidos planContenidoParaModificar)
{
if (planContenidoParaModificar == null || planContenidoParaModificar.Consecutivo <= 0 || string.IsNullOrWhiteSpace(planContenidoParaModificar.Descripcion))
{
return(BadRequest("planContenidoParaModificar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperModificarPlanContenido = await _planesBusiness.ModificarPlanContenido(planContenidoParaModificar);
return(Ok(wrapperModificarPlanContenido));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> ListarContenidoDeUnPlan(PlanesContenidos planContenidoParaListar)
{
if (planContenidoParaListar == null || planContenidoParaListar.CodigoPlan <= 0)
{
return(BadRequest("planContenidoParaListar vacio y/o invalido!."));
}
try
{
List <PlanesContenidos> listaPlanesContenidos = await _planesBusiness.ListarContenidoDeUnPlan(planContenidoParaListar);
return(Ok(listaPlanesContenidos));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> BuscarPlanContenido(PlanesContenidos planContenidoParaBuscar)
{
if (planContenidoParaBuscar == null || planContenidoParaBuscar.Consecutivo <= 0)
{
return(BadRequest("planContenidoParaBuscar vacio y/o invalido!."));
}
try
{
PlanesContenidos planContenidoBuscado = await _planesBusiness.BuscarPlanContenido(planContenidoParaBuscar);
return(Ok(planContenidoBuscado));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <WrapperSimpleTypesDTO> EliminarPlanContenido(PlanesContenidos planContenidoParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planesRepo = new PlanesRepository(context);
planesRepo.EliminarPlanContenido(planContenidoParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarPlanContenido = new WrapperSimpleTypesDTO();
wrapperEliminarPlanContenido.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarPlanContenido.NumeroRegistrosAfectados > 0)
{
wrapperEliminarPlanContenido.Exitoso = true;
}
return(wrapperEliminarPlanContenido);
}
}
public void EliminarMultiplesPlanesContenidos(PlanesContenidos planContenidoParaEliminar)
{
_context.PlanesContenidos.RemoveRange(_context.PlanesContenidos.Where(x => x.CodigoPlan == planContenidoParaEliminar.CodigoPlan));
}
public void EliminarPlanContenido(PlanesContenidos planContenidoParaEliminar)
{
_context.PlanesContenidos.Attach(planContenidoParaEliminar);
_context.PlanesContenidos.Remove(planContenidoParaEliminar);
}
public void CrearPlanContenido(PlanesContenidos planesContenidosParaCrear)
{
planesContenidosParaCrear.Descripcion.Trim();
_context.PlanesContenidos.Add(planesContenidosParaCrear);
}