public async Task <IHttpActionResult> EliminarGrupoEventoAsistente(GruposEventosAsistentes grupoEventoAsistenteParaEliminar)
{
if (grupoEventoAsistenteParaEliminar == null || grupoEventoAsistenteParaEliminar.CodigoPersona <= 0 || grupoEventoAsistenteParaEliminar.CodigoEvento <= 0)
{
return(BadRequest("grupoEventoAsistenteParaEliminar vacio y/o invalido!."));
}
try
{
Tuple <WrapperSimpleTypesDTO, TimeLineNotificaciones> tupleWrapper = await _grupoBusiness.EliminarGrupoEventoAsistente(grupoEventoAsistenteParaEliminar);
if (tupleWrapper.Item1.Exitoso && tupleWrapper.Item2 != null)
{
NoticiasBusiness noticiasBusiness = new NoticiasBusiness();
IHubContext hubContext = GlobalHost.ConnectionManager.GetHubContext <ChatHub>();
hubContext.Clients.Group(ChatHub._prefixChatGroupName + tupleWrapper.Item2.CodigoPersonaDestino.ToString()).receiveNotification(tupleWrapper.Item2);
}
return(Ok(tupleWrapper.Item1));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <GruposEventosAsistentes> EliminarGrupoEventoAsistente(GruposEventosAsistentes grupoEventoAsistenteParaEliminar)
{
GruposEventosAsistentes grupoEventoAsistente = await _context.GruposEventosAsistentes.Where(x => x.CodigoEvento == grupoEventoAsistenteParaEliminar.CodigoEvento && x.CodigoPersona == grupoEventoAsistenteParaEliminar.CodigoPersona).FirstOrDefaultAsync();
_context.GruposEventosAsistentes.Remove(grupoEventoAsistente);
return(grupoEventoAsistente);
}
public async Task <WrapperSimpleTypesDTO> BuscarSiPersonaAsisteAGrupoEvento(GruposEventosAsistentes grupoEventoAsistenteParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
GruposRepository grupoRepository = new GruposRepository(context);
WrapperSimpleTypesDTO wrapperBuscarSiPersonaAsisteAGrupoEvento = await grupoRepository.BuscarSiPersonaAsisteAGrupoEvento(grupoEventoAsistenteParaBuscar);
return(wrapperBuscarSiPersonaAsisteAGrupoEvento);
}
}
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> BuscarSiPersonaAsisteAGrupoEvento(GruposEventosAsistentes grupoEventoAsistenteParaBuscar)
{
WrapperSimpleTypesDTO grupoEventoBuscado = new WrapperSimpleTypesDTO();
grupoEventoBuscado.Existe = await(from grupoEventoAsistentes in _context.GruposEventosAsistentes
where grupoEventoAsistentes.CodigoEvento == grupoEventoAsistenteParaBuscar.CodigoEvento &&
grupoEventoAsistentes.CodigoPersona == grupoEventoAsistenteParaBuscar.CodigoPersona
select grupoEventoAsistentes).AnyAsync();
return(grupoEventoBuscado);
}
public async Task GruposBusiness_CrearGruposEventosAsistentes_ShouldCreate()
{
GruposBusiness gruposBusiness = new GruposBusiness();
GruposEventosAsistentes grupoEvento = new GruposEventosAsistentes
{
CodigoEvento = 13,
CodigoPersona = 7
};
Tuple <WrapperSimpleTypesDTO, TimeLineNotificaciones> wrapper = await gruposBusiness.CrearGruposEventosAsistentes(grupoEvento);
Assert.IsNotNull(wrapper);
Assert.IsTrue(wrapper.Item1.Exitoso);
}
public async Task <IHttpActionResult> BuscarSiPersonaAsisteAGrupoEvento(GruposEventosAsistentes grupoEventoAsistenteParaBuscar)
{
if (grupoEventoAsistenteParaBuscar == null || grupoEventoAsistenteParaBuscar.CodigoEvento <= 0 || grupoEventoAsistenteParaBuscar.CodigoPersona <= 0)
{
return(BadRequest("grupoEventoAsistenteParaBuscar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperBuscarSiPersonaAsisteAGrupoEvento = await _grupoBusiness.BuscarSiPersonaAsisteAGrupoEvento(grupoEventoAsistenteParaBuscar);
return(Ok(wrapperBuscarSiPersonaAsisteAGrupoEvento));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <Tuple <WrapperSimpleTypesDTO, TimeLineNotificaciones> > EliminarGrupoEventoAsistente(GruposEventosAsistentes grupoEventoAsistenteParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
GruposRepository grupoRepository = new GruposRepository(context);
GruposEventosAsistentes grupoEventoAsistenteBorrado = await grupoRepository.EliminarGrupoEventoAsistente(grupoEventoAsistenteParaEliminar);
int?codigoPersonaGrupo = await grupoRepository.BuscarCodigoPersonaDeUnGrupo(grupoEventoAsistenteParaEliminar.CodigoEvento);
if (!codigoPersonaGrupo.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el codigo persona del grupo dueño de este evento, BUUUUUUGGG!..");
}
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Notificaciones notificacion = new Notificaciones
{
CodigoEvento = grupoEventoAsistenteParaEliminar.CodigoEvento,
CodigoPersonaDestinoAccion = codigoPersonaGrupo.Value,
CodigoPersonaOrigenAccion = grupoEventoAsistenteParaEliminar.CodigoPersona,
CodigoTipoNotificacion = (int)TipoNotificacionEnum.DesuscripcionEventoUsuario,
Creacion = DateTime.Now
};
noticiasRepo.CrearNotificacion(notificacion);
WrapperSimpleTypesDTO wrapperEliminarGrupoEventoAsistente = new WrapperSimpleTypesDTO();
TimeLineNotificaciones timeLineNotificacion = null;
wrapperEliminarGrupoEventoAsistente.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarGrupoEventoAsistente.NumeroRegistrosAfectados > 0)
{
wrapperEliminarGrupoEventoAsistente.Exitoso = true;
if (notificacion.Consecutivo > 0)
{
timeLineNotificacion = new TimeLineNotificaciones(await noticiasRepo.BuscarNotificacion(notificacion));
}
}
return(Tuple.Create(wrapperEliminarGrupoEventoAsistente, timeLineNotificacion));
}
}
public async Task <IHttpActionResult> ListarEventosAsistentesDeUnEvento(GruposEventosAsistentes grupoEventoAsistenteParaListar)
{
if (grupoEventoAsistenteParaListar == null || grupoEventoAsistenteParaListar.CodigoEvento <= 0 || grupoEventoAsistenteParaListar.IdiomaBase == Idioma.SinIdioma ||
grupoEventoAsistenteParaListar.SkipIndexBase < 0 || grupoEventoAsistenteParaListar.TakeIndexBase <= 0)
{
return(BadRequest("grupoEventoAsistenteParaListar vacio y/o invalido!."));
}
try
{
List <GruposEventosAsistentesDTO> listaEventosAsistentesDeUnEvento = await _grupoBusiness.ListarEventosAsistentesDeUnEvento(grupoEventoAsistenteParaListar);
return(Ok(listaEventosAsistentesDeUnEvento));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <List <GruposEventosAsistentesDTO> > ListarEventosAsistentesDeUnEvento(GruposEventosAsistentes grupoEventoAsistenteParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
GruposRepository grupoRepository = new GruposRepository(context);
List <GruposEventosAsistentesDTO> listaEventosAsistentesDeUnEvento = await grupoRepository.ListarEventosAsistentesDeUnEvento(grupoEventoAsistenteParaListar);
return(listaEventosAsistentesDeUnEvento);
}
}
public void EliminarMultiplesGrupoEventoAsistente(GruposEventosAsistentes grupoEventoAsistenteParaEliminar)
{
_context.GruposEventosAsistentes.RemoveRange(_context.GruposEventosAsistentes.Where(x => x.CodigoEvento == grupoEventoAsistenteParaEliminar.CodigoEvento));
}
public async Task <List <GruposEventosAsistentesDTO> > ListarEventosAsistentesDeUnEvento(GruposEventosAsistentes grupoEventoAsistenteParaListar)
{
IQueryable <GruposEventosAsistentes> queryEventosAsistentesDeUnGrupo = _context.GruposEventosAsistentes.Where(x => x.CodigoEvento == grupoEventoAsistenteParaListar.CodigoEvento).AsQueryable();
if (!string.IsNullOrWhiteSpace(grupoEventoAsistenteParaListar.IdentificadorParaBuscar))
{
grupoEventoAsistenteParaListar.IdentificadorParaBuscar = grupoEventoAsistenteParaListar.IdentificadorParaBuscar.Trim();
string[] arrayIdentificador = grupoEventoAsistenteParaListar.IdentificadorParaBuscar.Split(new char[] { ' ' }, 2);
string nombre = arrayIdentificador.ElementAtOrDefault(0);
string apellido = arrayIdentificador.ElementAtOrDefault(1);
if (!string.IsNullOrWhiteSpace(nombre) && !string.IsNullOrWhiteSpace(apellido))
{
queryEventosAsistentesDeUnGrupo = queryEventosAsistentesDeUnGrupo.Where(x => x.Personas.Nombres.Trim().ToUpper().Contains(nombre.Trim().ToUpper()) || x.Personas.Apellidos.Trim().ToUpper().Contains(apellido.Trim().ToUpper()));
}
else
{
queryEventosAsistentesDeUnGrupo = queryEventosAsistentesDeUnGrupo.Where(x => x.Personas.Nombres.Trim().ToUpper().Contains(nombre.Trim().ToUpper()));
}
}
int queryContador = await queryEventosAsistentesDeUnGrupo.CountAsync();
List <GruposEventosAsistentesDTO> listaEventosAsistentesDeUnEvento = await queryEventosAsistentesDeUnGrupo
.Select(x => new GruposEventosAsistentesDTO
{
Consecutivo = x.Consecutivo,
CodigoEvento = x.CodigoEvento,
CodigoPersona = x.CodigoPersona,
NumeroRegistrosExistentes = queryContador,
Personas = new PersonasDTO
{
Consecutivo = x.Personas.Consecutivo,
Nombres = x.Personas.Nombres,
Apellidos = x.Personas.Apellidos,
CodigoIdioma = x.Personas.CodigoIdioma,
CodigoPais = x.Personas.CodigoPais,
CodigoArchivoImagenPerfil = x.Personas.CodigoArchivoImagenPerfil,
Paises = new PaisesDTO
{
Consecutivo = x.Personas.Paises.Consecutivo,
CodigoArchivo = x.Personas.Paises.CodigoArchivo,
DescripcionIdiomaBuscado = x.Personas.Paises.PaisesContenidos.Where(z => z.CodigoIdioma == grupoEventoAsistenteParaListar.CodigoIdiomaUsuarioBase).Select(y => y.Descripcion).FirstOrDefault()
}
}
})
.OrderBy(x => x.Personas.Nombres)
.Skip(() => grupoEventoAsistenteParaListar.SkipIndexBase)
.Take(() => grupoEventoAsistenteParaListar.TakeIndexBase)
.AsNoTracking()
.ToListAsync();
return(listaEventosAsistentesDeUnEvento);
}
public async Task <WrapperSimpleTypesDTO> BuscarNumeroAsistentesGruposEventos(GruposEventosAsistentes grupoEventoAsistenteParaBuscar)
{
WrapperSimpleTypesDTO grupoEventoBuscado = new WrapperSimpleTypesDTO();
grupoEventoBuscado.NumeroRegistrosExistentes = await(from grupoEventoAsistentes in _context.GruposEventosAsistentes
where grupoEventoAsistentes.CodigoEvento == grupoEventoAsistenteParaBuscar.CodigoEvento
select grupoEventoAsistentes).CountAsync();
return(grupoEventoBuscado);
}
public void CrearGruposEventosAsistentes(GruposEventosAsistentes grupoEventoAsistentesParaCrear)
{
_context.GruposEventosAsistentes.Add(grupoEventoAsistentesParaCrear);
}