Beispiel #1
0
        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);
        }
Beispiel #6
0
        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);
        }
Beispiel #7
0
        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));
            }
        }
Beispiel #9
0
        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);
 }