Esempio n. 1
0
        public async Task <ImagenesPerfilAdministradores> AsignarImagenPerfil(int codigoUsuario, int codigoArchivo)
        {
            ImagenesPerfilAdministradores imagenPerfilExistente = await _context.ImagenesPerfilAdministradores.Where(x => x.CodigoUsuario == codigoUsuario).FirstOrDefaultAsync();

            imagenPerfilExistente.CodigoArchivo = codigoArchivo;

            return(imagenPerfilExistente);
        }
        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 <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);
            }
        }
Esempio n. 4
0
        public async Task <ImagenesPerfilAdministradores> BuscarPrimeraImagenPerfilAdministrador()
        {
            ImagenesPerfilAdministradores imagenPerfilExistente = await _context.ImagenesPerfilAdministradores.FirstOrDefaultAsync();

            return(imagenPerfilExistente);
        }
Esempio n. 5
0
        public async Task <ImagenesPerfilAdministradores> BuscarImagenPerfilAdministrador(int codigoUsuario)
        {
            ImagenesPerfilAdministradores imagenPerfilExistente = await _context.ImagenesPerfilAdministradores.Where(x => x.CodigoUsuario == codigoUsuario).FirstOrDefaultAsync();

            return(imagenPerfilExistente);
        }
Esempio n. 6
0
 public void CrearImagenPerfilAdministrador(ImagenesPerfilAdministradores imagenParaCrear)
 {
     _context.ImagenesPerfilAdministradores.Add(imagenParaCrear);
 }
Esempio n. 7
0
        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);
            }
        }