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);
}
}
public async Task <WrapperSimpleTypesDTO> AsignarTerminosCondicionesLista(List <TerminosCondiciones> terminosCondicionesParaAsignar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
foreach (TerminosCondiciones terminos in terminosCondicionesParaAsignar)
{
bool existe = await adminRepo.BuscarSiExisteTerminosYCondiciones(terminos);
if (existe)
{
TerminosCondiciones terminosCondicionesExistentes = await adminRepo.ModificarTerminosCondiciones(terminos);
}
else
{
adminRepo.CrearTerminosCondiciones(terminos);
}
}
WrapperSimpleTypesDTO wrapperAsignarTerminosCondicionesLista = new WrapperSimpleTypesDTO();
wrapperAsignarTerminosCondicionesLista.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperAsignarTerminosCondicionesLista.NumeroRegistrosAfectados > 0)
{
wrapperAsignarTerminosCondicionesLista.Exitoso = true;
}
return(wrapperAsignarTerminosCondicionesLista);
}
}
public async Task <Tuple <WrapperSimpleTypesDTO, TimeLineNotificaciones> > ModificarUsuario(Usuarios usuarioParamodificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
Usuarios usuarioExistente = await adminRepo.ModificarUsuario(usuarioParamodificar);
Notificaciones notificacion = null;
if (usuarioExistente.PlanesUsuarios.CodigoPlan != usuarioParamodificar.PlanesUsuarios.CodigoPlanDeseado)
{
PlanesBusiness planBusiness = new PlanesBusiness();
// Cambio el plan para esa persona
await planBusiness.CambiarDePlanUsuario(usuarioParamodificar.PlanesUsuarios);
// Armamos una notificacion para el nuevo plan
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
notificacion = new Notificaciones
{
CodigoTipoNotificacion = (int)TipoNotificacionEnum.PlanAprobado,
CodigoPlanNuevo = usuarioParamodificar.PlanesUsuarios.CodigoPlanDeseado,
CodigoPersonaDestinoAccion = usuarioExistente.Personas.First().Consecutivo,
Creacion = DateTime.Now
};
noticiasRepo.CrearNotificacion(notificacion);
}
WrapperSimpleTypesDTO wrapperModificarUsuario = new WrapperSimpleTypesDTO();
TimeLineNotificaciones timeLineNotificacion = null;
wrapperModificarUsuario.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarUsuario.NumeroRegistrosAfectados > 0)
{
wrapperModificarUsuario.Exitoso = true;
if (notificacion != null && notificacion.Consecutivo > 0)
{
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
if (notificacion.CodigoPersonaDestinoAccion.HasValue && notificacion.CodigoPersonaDestinoAccion > 0)
{
PersonasRepository personaRepo = new PersonasRepository(context);
int codigoIdioma = await personaRepo.BuscarCodigoIdiomaDeLaPersona(notificacion.CodigoPersonaDestinoAccion.Value);
notificacion.CodigoIdiomaUsuarioBase = codigoIdioma;
}
timeLineNotificacion = new TimeLineNotificaciones(await noticiasRepo.BuscarNotificacion(notificacion));
}
}
return(Tuple.Create(wrapperModificarUsuario, timeLineNotificacion));
}
}
public async Task <WrapperSimpleTypesDTO> AsignarImagenPerfilAdministrador(int codigoUsuario, Stream streamSource)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
ArchivosBusiness archivoBuss = new ArchivosBusiness();
ImagenesPerfilAdministradores imagenPerfilExistente = await adminRepo.BuscarImagenPerfilAdministrador(codigoUsuario);
int?codigoArchivoExistente = null;
WrapperSimpleTypesDTO wrapper = await archivoBuss.CrearArchivoStream((int)TipoArchivo.Imagen, streamSource);
if (imagenPerfilExistente == null)
{
ImagenesPerfilAdministradores imagenParaCrear = new ImagenesPerfilAdministradores
{
CodigoUsuario = codigoUsuario,
CodigoArchivo = Convert.ToInt32(wrapper.ConsecutivoArchivoCreado)
};
adminRepo.CrearImagenPerfilAdministrador(imagenParaCrear);
}
else
{
// Guardo el viejo codigo de archivo para borrarlo luego
codigoArchivoExistente = imagenPerfilExistente.CodigoArchivo;
imagenPerfilExistente = await adminRepo.AsignarImagenPerfil(codigoUsuario, Convert.ToInt32(wrapper.ConsecutivoArchivoCreado));
}
// Borro el archivo viejo
if (codigoArchivoExistente.HasValue)
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivoParaBorrar = new Archivos
{
Consecutivo = codigoArchivoExistente.Value
};
archivoRepo.EliminarArchivo(archivoParaBorrar);
}
WrapperSimpleTypesDTO wrapperAsignarImagenPerfilAdministrador = new WrapperSimpleTypesDTO();
wrapperAsignarImagenPerfilAdministrador.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperAsignarImagenPerfilAdministrador.NumeroRegistrosAfectados > 0)
{
wrapperAsignarImagenPerfilAdministrador.Exitoso = true;
wrapperAsignarImagenPerfilAdministrador.ConsecutivoCreado = imagenPerfilExistente.Consecutivo;
wrapperAsignarImagenPerfilAdministrador.ConsecutivoArchivoCreado = wrapper.ConsecutivoArchivoCreado;
}
return(wrapperAsignarImagenPerfilAdministrador);
}
}
public async Task <List <PaisesDTO> > ListarPaisesPorIdioma(Paises paisParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
List <PaisesDTO> listaPaises = await adminRepo.ListarPaisesPorIdioma(paisParaListar);
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);
}
}
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 <List <TerminosCondiciones> > ListarTerminosCondiciones()
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
List <TerminosCondiciones> listaTerminosCondicionesBuscados = await adminRepo.ListarTerminosCondiciones();
return(listaTerminosCondicionesBuscados);
}
}
public async Task <TerminosCondiciones> BuscarTerminosCondiciones(TerminosCondiciones terminosCondicionesParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
TerminosCondiciones terminosCondicionesBuscados = await adminRepo.BuscarTerminosCondiciones(terminosCondicionesParaBuscar);
return(terminosCondicionesBuscados);
}
}
async Task EliminarRepresentante(AdministracionRepository adminRepo, int?codigoPersona)
{
int?codigoRepresentante = await adminRepo.BuscarCodigoRepresentanteDeUnaPersona(codigoPersona.Value);
if (codigoRepresentante.HasValue)
{
adminRepo.EliminarCategoriaRepresentantesDeUnRepresentante(codigoRepresentante.Value);
adminRepo.EliminarRepresentante(codigoRepresentante.Value);
}
else
{
throw new InvalidOperationException("No existe un Representante para esta persona que se quiere borrar, BUUUGGG BUAAGHHH!.");
}
}
async Task EliminarCandidato(AdministracionRepository adminRepo, int?codigoPersona)
{
int?codigoCandidato = await adminRepo.BuscarCodigoCandidatoDeUnaPersona(codigoPersona.Value);
if (codigoCandidato.HasValue)
{
List <int> listaCodigoCategorias = await adminRepo.ListarCodigoCategoriasDeUnCandidato(codigoCandidato.Value);
if (listaCodigoCategorias != null && listaCodigoCategorias.Count > 0)
{
foreach (var codigoCategoria in listaCodigoCategorias)
{
adminRepo.EliminarHabilidadesDeUnaCategoriaCandidato(codigoCategoria);
}
}
adminRepo.EliminarCategoriasCandidatoDeUnCandidato(codigoCandidato.Value);
adminRepo.EliminarCandidatosVideoDeUnCandidato(codigoCandidato.Value);
int?codigoResponsable = await adminRepo.BuscarCodigoResponsableDeUnCandidato(codigoCandidato.Value);
List <int> listaCodigoArchivoVideosCandidatos = await adminRepo.ListarCodigoArchivosDeTodosLosCandidatoVideosDeUnaCandidato(codigoCandidato.Value);
adminRepo.EliminarCandidato(codigoCandidato.Value);
if (codigoResponsable.HasValue)
{
adminRepo.EliminarCandidatosResponsables(codigoResponsable.Value);
}
if (listaCodigoArchivoVideosCandidatos != null && listaCodigoArchivoVideosCandidatos.Count > 0)
{
foreach (var codigoArchivo in listaCodigoArchivoVideosCandidatos)
{
adminRepo.EliminarArchivo(codigoArchivo);
}
}
}
else
{
throw new InvalidOperationException("No existe un Candidato para esta persona que se quiere borrar, BUUUGGG BUAAGHHH!.");
}
}
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);
}
}
public async Task <UsuariosDTO> VerificarUsuario(Usuarios usuarioParaVerificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
UsuariosDTO usuarioVerificado = await authenticateRepo.VerificarUsuario(usuarioParaVerificar);
if (usuarioVerificado != null)
{
Usuarios usuarioExistente = await authenticateRepo.ActualizarFechaUltimoAcceso(usuarioVerificado.Consecutivo);
// Se vencio el plan
if (usuarioVerificado.PlanesUsuarios.Vencimiento < DateTime.Now && usuarioVerificado.TipoPerfil != TipoPerfil.Administrador)
{
PlanesBusiness planBusiness = new PlanesBusiness();
WrapperSimpleTypesDTO wrapperCambiarPlan = await planBusiness.CambiarPlanUsuarioADefaultPerfilPorVencimiento(usuarioVerificado.PlanesUsuarios);
usuarioVerificado = await authenticateRepo.VerificarUsuario(usuarioParaVerificar);
}
await context.SaveChangesAsync();
if (usuarioVerificado.TipoPerfil == TipoPerfil.Administrador)
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
ImagenesPerfilAdministradores imagenPerfilBuscada = await adminRepo.BuscarImagenPerfilAdministrador(usuarioVerificado.Consecutivo);
if (imagenPerfilBuscada != null)
{
usuarioVerificado.CodigoImagenPerfilAdmin = imagenPerfilBuscada.CodigoArchivo;
}
}
}
return(usuarioVerificado);
}
}
public async Task <WrapperSimpleTypesDTO> CrearPais(Paises paisParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
paisParaCrear.Archivos.CodigoTipoArchivo = (int)TipoArchivo.Imagen;
adminRepo.CrearPais(paisParaCrear);
WrapperSimpleTypesDTO wrapperCrearPais = new WrapperSimpleTypesDTO();
wrapperCrearPais.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearPais.NumeroRegistrosAfectados > 0)
{
wrapperCrearPais.Exitoso = true;
wrapperCrearPais.ConsecutivoCreado = paisParaCrear.Consecutivo;
wrapperCrearPais.ConsecutivoArchivoCreado = paisParaCrear.CodigoArchivo;
}
return(wrapperCrearPais);
}
}
async Task EliminarAnunciante(AdministracionRepository adminRepo, int?codigoPersona)
{
int?codigoAnunciante = await adminRepo.BuscarCodigoAnuncianteDeUnaPersona(codigoPersona.Value);
if (codigoAnunciante.HasValue)
{
List <int> listaCodigoAnuncios = await adminRepo.ListarCodigoAnunciosDeUnAnunciante(codigoAnunciante.Value);
if (listaCodigoAnuncios != null && listaCodigoAnuncios.Count > 0)
{
foreach (var codigoAnuncio in listaCodigoAnuncios)
{
adminRepo.EliminarAnunciosContenidosDeUnAnuncio(codigoAnuncio);
adminRepo.EliminarAnunciosPaisesDeUnAnuncio(codigoAnuncio);
adminRepo.EliminarCategoriasAnunciosDeUnAnuncio(codigoAnuncio);
}
}
adminRepo.EliminarAnunciosDeUnAnunciante(codigoAnunciante.Value);
List <int> listaCodigoArchivoAnuncios = await adminRepo.ListarCodigoArchivosDeTodosLosAnunciosDeUnAnunciante(codigoAnunciante.Value);
adminRepo.EliminarAnunciante(codigoAnunciante.Value);
if (listaCodigoArchivoAnuncios != null && listaCodigoArchivoAnuncios.Count > 0)
{
foreach (var codigoArchivo in listaCodigoArchivoAnuncios)
{
adminRepo.EliminarArchivo(codigoArchivo);
}
}
}
else
{
throw new InvalidOperationException("No existe un Anunciante para esta persona que se quiere borrar, BUUUGGG BUAAGHHH!.");
}
}
async Task EliminarGrupo(AdministracionRepository adminRepo, int?codigoPersona)
{
int?codigoGrupo = await adminRepo.BuscarCodigoGrupoDeUnaPersona(codigoPersona.Value);
if (codigoGrupo.HasValue)
{
List <int> listaCodigoEventos = await adminRepo.ListarCodigoEventosDeUnGrupo(codigoGrupo.Value);
if (listaCodigoEventos != null && listaCodigoEventos.Count > 0)
{
foreach (var codigoEvento in listaCodigoEventos)
{
adminRepo.EliminarGruposAsistentesDeUnEvento(codigoEvento);
adminRepo.EliminarCategoriasEventosDeUnEvento(codigoEvento);
}
}
adminRepo.EliminarEventosDeUnGrupo(codigoGrupo.Value);
adminRepo.EliminarCategoriasGruposDeUnGrupo(codigoGrupo.Value);
List <int> listaCodigoArchivoGrupo = await adminRepo.ListarCodigoArchivosDeTodosLosGrupoEventosDeUnGrupo(codigoGrupo.Value);
adminRepo.EliminarGrupo(codigoGrupo.Value);
if (listaCodigoArchivoGrupo != null && listaCodigoArchivoGrupo.Count > 0)
{
foreach (var codigoArchivo in listaCodigoArchivoGrupo)
{
adminRepo.EliminarArchivo(codigoArchivo);
}
}
}
else
{
throw new InvalidOperationException("No existe un Grupo para esta persona que se quiere borrar, BUUUGGG BUAAGHHH!.");
}
}
public async Task <WrapperSimpleTypesDTO> ModificarPais(Paises paisParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
Paises paisExistente = await adminRepo.ModificarPais(paisParaModificar);
foreach (var item in paisParaModificar.PaisesContenidos)
{
await adminRepo.ModificarPaisContenido(item);
}
WrapperSimpleTypesDTO wrapperModificarPais = new WrapperSimpleTypesDTO();
wrapperModificarPais.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarPais.NumeroRegistrosAfectados > 0)
{
wrapperModificarPais.Exitoso = true;
}
return(wrapperModificarPais);
}
}
public async Task <List <TimeLineNotificaciones> > ListaTimeLineNotificaciones(BuscadorDTO buscador)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
NoticiasRepository noticiaRepo = new NoticiasRepository(context);
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
if (buscador.FechaFiltroBase != DateTime.MinValue)
{
buscador.FechaFiltroBase = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, buscador.FechaFiltroBase);
}
List <NoticiasDTO> listaNoticias = await noticiaRepo.ListarNoticiasNotificaciones(buscador);
List <NotificacionesDTO> listarNotificaciones = await noticiaRepo.ListarNotificaciones(buscador);
List <TimeLineNotificaciones> listaTimeLineNotificacion = TimeLineNotificaciones.CrearListaTimeLineNotificaciones(listaNoticias, listarNotificaciones);
// Si no es minValue significa que estoy refrescando y no busco feed
if (buscador.FechaFiltroBase == DateTime.MinValue)
{
RssFeeds rssBuscado = await noticiaRepo.BuscarRssFeedPorCodigoIdioma(buscador.CodigoIdiomaUsuarioBase);
if (rssBuscado != null && !string.IsNullOrWhiteSpace(rssBuscado.UrlFeed))
{
FeedReader reader = new FeedReader();
IEnumerable <FeedItem> items = reader.RetrieveFeed(rssBuscado.UrlFeed);
if (items != null && items.Count() > 0)
{
IEnumerable <FeedItem> itemsFiltrados = items.Skip(buscador.SkipIndexBase).Take(buscador.TakeIndexBase);
if (itemsFiltrados != null && itemsFiltrados.Count() > 0)
{
foreach (FeedItem item in itemsFiltrados)
{
string url = item.Uri != null ? item.Uri.AbsoluteUri : string.Empty;
TimeLineNotificaciones timeLineRss = new TimeLineNotificaciones(item.Title, item.Summary, url, string.Empty, TipoNotificacionEnum.RssFeed);
listaTimeLineNotificacion.Insert(0, timeLineRss);
}
}
}
}
}
// Cuando Skip este en 0 significa que es la primera consulta, asi no repito su cosa de validar el plan
// si "FechaFiltroBase" tiene un valor significa que es pull to refresh y no debo agregar las validaciones del plan
if (buscador.SkipIndexBase == 0 && buscador.FechaFiltroBase == DateTime.MinValue)
{
PlanesRepository planRepo = new PlanesRepository(context);
AdministracionRepository adminRepo = new AdministracionRepository(context);
PlanesUsuarios planUsuario = new PlanesUsuarios
{
Consecutivo = buscador.CodigoPlanUsuario,
IdiomaBase = buscador.IdiomaBase
};
PlanesUsuariosDTO planDelUsuarioValidado = await planRepo.BuscarPlanUsuario(planUsuario);
ImagenesPerfilAdministradores imagenperfil = await adminRepo.BuscarPrimeraImagenPerfilAdministrador();
long mesesFaltantesParaQueSeVenza = DateTimeHelper.DiferenciaEntreDosFechas(planDelUsuarioValidado.Vencimiento, DateTime.Now);
if (mesesFaltantesParaQueSeVenza == 1 && planDelUsuarioValidado.Planes.PlanDefault != 1)
{
TimeLineNotificaciones timeLineCasiVence = new TimeLineNotificaciones
{
CodigoArchivo = imagenperfil.CodigoArchivo,
UrlArchivo = imagenperfil.UrlImagenPerfil,
DescripcionPlan = planDelUsuarioValidado.Planes.DescripcionIdiomaBuscado,
FechaVencimientoPlan = planDelUsuarioValidado.Vencimiento,
TipoDeLaNotificacion = TipoNotificacionEnum.EstaPorVencersePlan,
CreacionNotificacion = DateTime.Now
};
listaTimeLineNotificacion.Insert(0, timeLineCasiVence);
}
else if (mesesFaltantesParaQueSeVenza < 0 && planDelUsuarioValidado.Planes.PlanDefault != 1)
{
TimeLineNotificaciones timeLineVencio = new TimeLineNotificaciones
{
CodigoArchivo = imagenperfil.CodigoArchivo,
UrlArchivo = imagenperfil.UrlImagenPerfil,
DescripcionPlan = planDelUsuarioValidado.Planes.DescripcionIdiomaBuscado,
FechaVencimientoPlan = planDelUsuarioValidado.Vencimiento,
TipoDeLaNotificacion = TipoNotificacionEnum.SeVencioPlan,
CreacionNotificacion = DateTime.Now
};
listaTimeLineNotificacion.Insert(0, timeLineVencio);
}
}
if (listaTimeLineNotificacion != null && listaTimeLineNotificacion.Count > 0)
{
foreach (var notificacion in listaTimeLineNotificacion)
{
notificacion.CreacionNotificacion = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, notificacion.CreacionNotificacion);
notificacion.FechaInicioEvento = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, notificacion.FechaInicioEvento);
notificacion.FechaTerminacionEvento = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, notificacion.FechaTerminacionEvento);
notificacion.FechaVencimientoPlan = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, notificacion.FechaVencimientoPlan);
}
}
return(listaTimeLineNotificacion);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarUsuario(Usuarios usuarioParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
int?codigoPersona = await adminRepo.BuscarCodigoPersonaDeUnUsuario(usuarioParaEliminar.Consecutivo);
if (!codigoPersona.HasValue)
{
throw new InvalidOperationException("La persona que se intenta borrar no existe, BUUUGGG BUAAGHHH!.");
}
int?codigoTipoPerfil = await adminRepo.BuscarTipoPerfilDeUnaPersona(codigoPersona.Value);
if (!codigoTipoPerfil.HasValue)
{
throw new InvalidOperationException("La persona que se intenta borrar no tiene un tipo de perfil valido, BUUUGGG BUAAGHHH!.");
}
TipoPerfil tipoPerfilDeEstaPersona = codigoTipoPerfil.Value.ToEnum <TipoPerfil>();
int?codigoPlanUsuario = await adminRepo.BuscarCodigoPlanUsuarioDeUnUsuario(usuarioParaEliminar.Consecutivo);
if (!codigoPlanUsuario.HasValue)
{
throw new InvalidOperationException("El usuario que se intenta borrar no tiene un plan de usuario valido, BUUUGGG BUAAGHHH!.");
}
adminRepo.EliminarNotificacionesDeUnaPersona(codigoPersona.Value);
List <int> listaCodigoArchivoHistorialPago = await adminRepo.ListarCodigoArchivosDeTodosLosHistorialPagoDeUnaPersona(codigoPersona.Value);
adminRepo.EliminarHistorialPagoDeUnaPersona(codigoPersona.Value);
if (listaCodigoArchivoHistorialPago != null && listaCodigoArchivoHistorialPago.Count > 0)
{
foreach (var codigoArchivo in listaCodigoArchivoHistorialPago)
{
adminRepo.EliminarArchivo(codigoArchivo);
}
}
List <int> listaCodigoChats = await adminRepo.ListarCodigoChatDeUnaPersona(codigoPersona.Value);
if (listaCodigoChats != null && listaCodigoChats.Count > 0)
{
foreach (var codigoChat in listaCodigoChats)
{
adminRepo.EliminarChatMensajesDeUnChat(codigoChat);
}
}
adminRepo.EliminarChatsDeUnaPersona(codigoPersona.Value);
adminRepo.EliminarContactosDeUnaPersona(codigoPersona.Value);
adminRepo.EliminarGrupoEventosAsistentesDeUnaPersona(codigoPersona.Value);
switch (tipoPerfilDeEstaPersona)
{
case TipoPerfil.Candidato:
await EliminarCandidato(adminRepo, codigoPersona);
break;
case TipoPerfil.Grupo:
await EliminarGrupo(adminRepo, codigoPersona);
break;
case TipoPerfil.Representante:
await EliminarRepresentante(adminRepo, codigoPersona);
break;
case TipoPerfil.Anunciante:
await EliminarAnunciante(adminRepo, codigoPersona);
break;
}
adminRepo.EliminarPersona(codigoPersona.Value);
int?codigoArchivoImagenPerfil = await adminRepo.BuscarCodigoArchivoDeImagenPerfilDeUnaPersona(codigoPersona.Value);
int?codigoArchivoImagenBanner = await adminRepo.BuscarCodigoArchivoDeImagenBannerDeUnaPersona(codigoPersona.Value);
if (codigoArchivoImagenPerfil.HasValue)
{
adminRepo.EliminarArchivo(codigoArchivoImagenPerfil.Value);
}
if (codigoArchivoImagenBanner.HasValue)
{
adminRepo.EliminarArchivo(codigoArchivoImagenBanner.Value);
}
adminRepo.EliminarPlanUsuario(codigoPlanUsuario.Value);
adminRepo.EliminarUsuario(usuarioParaEliminar.Consecutivo);
WrapperSimpleTypesDTO wrapperEliminarUsuario = new WrapperSimpleTypesDTO();
wrapperEliminarUsuario.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarUsuario.NumeroRegistrosAfectados > 0)
{
wrapperEliminarUsuario.Exitoso = true;
}
return(wrapperEliminarUsuario);
}
}
