Exemplo n.º 1
0
        public async Task <int> MetricasGrupos(MetricasDTO metricasParaBuscar)
        {
            IQueryable <Grupos> queryGrupos = _context.Grupos.AsQueryable();

            if (metricasParaBuscar.CategoriasParaBuscar != null && metricasParaBuscar.CategoriasParaBuscar.Count > 0)
            {
                queryGrupos = queryGrupos.Where(x => x.CategoriasGrupos.Any(y => metricasParaBuscar.CategoriasParaBuscar.Contains(y.CodigoCategoria)));
            }

            if (metricasParaBuscar.PaisesParaBuscar != null && metricasParaBuscar.PaisesParaBuscar.Count > 0)
            {
                queryGrupos = queryGrupos.Where(x => metricasParaBuscar.PaisesParaBuscar.Contains(x.Personas.CodigoPais));
            }

            if (metricasParaBuscar.IdiomasParaBuscar != null && metricasParaBuscar.IdiomasParaBuscar.Count > 0)
            {
                queryGrupos = queryGrupos.Where(x => metricasParaBuscar.IdiomasParaBuscar.Contains(x.Personas.CodigoIdioma));
            }

            if (metricasParaBuscar.PlanesParaBuscar != null && metricasParaBuscar.PlanesParaBuscar.Count > 0)
            {
                queryGrupos = queryGrupos.Where(x => metricasParaBuscar.PlanesParaBuscar.Contains(x.Personas.Usuarios.PlanesUsuarios.CodigoPlan));
            }

            return(await queryGrupos.CountAsync());
        }
Exemplo n.º 2
0
        public async Task <int> MetricasAnuncios(MetricasDTO metricasParaBuscar)
        {
            IQueryable <Anuncios> queryAnuncios = _context.Anuncios.AsQueryable();

            if (metricasParaBuscar.CodigoAnunciante > 0)
            {
                queryAnuncios = queryAnuncios.Where(x => x.CodigoAnunciante == metricasParaBuscar.CodigoAnunciante);
            }

            if (metricasParaBuscar.CategoriasParaBuscar != null && metricasParaBuscar.CategoriasParaBuscar.Count > 0)
            {
                queryAnuncios = queryAnuncios.Where(x => x.CategoriasAnuncios.Any(y => metricasParaBuscar.CategoriasParaBuscar.Contains(y.CodigoCategoria)));
            }

            if (metricasParaBuscar.PaisesParaBuscar != null && metricasParaBuscar.PaisesParaBuscar.Count > 0)
            {
                queryAnuncios = queryAnuncios.Where(x => x.AnunciosPaises.Any(y => metricasParaBuscar.PaisesParaBuscar.Contains(y.CodigoPais)));
            }

            if (metricasParaBuscar.IdiomasParaBuscar != null && metricasParaBuscar.IdiomasParaBuscar.Count > 0)
            {
                queryAnuncios = queryAnuncios.Where(x => x.AnunciosContenidos.Any(y => metricasParaBuscar.IdiomasParaBuscar.Contains(y.CodigoIdioma)));
            }

            return(await queryAnuncios.CountAsync());
        }
Exemplo n.º 3
0
        public async Task <MetricasDTO> MetricasUsuarios(MetricasDTO metricasParaBuscar)
        {
            IHttpClient client = ConfigurarHttpClient();

            MetricasDTO metricasUsuarios = await client.PostAsync("Metricas/MetricasUsuarios", metricasParaBuscar);

            return(metricasUsuarios);
        }
Exemplo n.º 4
0
        public async Task <WrapperSimpleTypesDTO> NumeroVecesVistosUltimoMes(MetricasDTO metricasParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                MetricasRepository    metricasRepo = new MetricasRepository(context);
                WrapperSimpleTypesDTO wrapperNumeroVecesVistosUltimoMes = await metricasRepo.NumeroVecesVistosUltimoMes(metricasParaBuscar);

                return(wrapperNumeroVecesVistosUltimoMes);
            }
        }
Exemplo n.º 5
0
        public async Task MetricasServices_ListarUsuariosMetricas_ShouldList()
        {
            MetricasServices metricasServices = new MetricasServices();

            MetricasDTO metricas = new MetricasDTO
            {
                SkipIndexBase = 0,
                TakeIndexBase = 5
            };

            List <PersonasDTO> listaUsuario = await metricasServices.ListarUsuariosMetricas(metricas);
        }
Exemplo n.º 6
0
        public async Task <WrapperSimpleTypesDTO> NumeroAnunciosRegistrados(MetricasDTO metricasParaBuscar = null)
        {
            IHttpClient client = ConfigurarHttpClient();

            if (metricasParaBuscar == null)
            {
                metricasParaBuscar = new MetricasDTO();
            }

            WrapperSimpleTypesDTO wrapperNumeroAnunciosRegistrados = await client.PostAsync <MetricasDTO, WrapperSimpleTypesDTO>("Metricas/NumeroAnunciosRegistrados", metricasParaBuscar);

            return(wrapperNumeroAnunciosRegistrados);
        }
Exemplo n.º 7
0
        public async Task <WrapperSimpleTypesDTO> NumeroVecesVistosUltimoMes(MetricasDTO metricasParaBuscar = null)
        {
            IHttpClient client = ConfigurarHttpClient();

            if (metricasParaBuscar == null)
            {
                metricasParaBuscar = new MetricasDTO();
            }

            WrapperSimpleTypesDTO wrapperNumeroVecesVistosUltimoMes = await client.PostAsync <MetricasDTO, WrapperSimpleTypesDTO>("Metricas/NumeroVecesVistosUltimoMes", metricasParaBuscar);

            return(wrapperNumeroVecesVistosUltimoMes);
        }
        public async Task <IHttpActionResult> MetricasUsuarios(MetricasDTO metricasParaBuscar)
        {
            try
            {
                MetricasDTO metricasUsuarios = await _metricasBusiness.MetricasUsuarios(metricasParaBuscar);

                return(Ok(metricasUsuarios));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
        public async Task <IHttpActionResult> NumeroVecesVistosUltimoMes(MetricasDTO metricasParaBuscar)
        {
            try
            {
                WrapperSimpleTypesDTO wrapperNumeroVecesVistosUltimoMes = await _metricasBusiness.NumeroVecesVistosUltimoMes(metricasParaBuscar);

                return(Ok(wrapperNumeroVecesVistosUltimoMes));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
        public async Task <IHttpActionResult> NumeroAnunciosRegistrados(MetricasDTO metricasParaBuscar)
        {
            try
            {
                WrapperSimpleTypesDTO wrapperNumeroAnunciosRegistrados = await _metricasBusiness.NumeroAnunciosRegistrados(metricasParaBuscar);

                return(Ok(wrapperNumeroAnunciosRegistrados));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
Exemplo n.º 11
0
        public async Task MetricasBusiness_NumeroVecesClickeadosUltimoMes_ShouldDoMetrics()
        {
            MetricasBusiness metricasBusiness = new MetricasBusiness();

            MetricasDTO metricas = new MetricasDTO
            {
                CodigoAnunciante = 1
            };

            WrapperSimpleTypesDTO wrapper = await metricasBusiness.NumeroVecesClickeadosUltimoMes(metricas);

            Assert.IsNotNull(wrapper);
        }
Exemplo n.º 12
0
        public async Task <MetricasDTO> MetricasEventos(MetricasDTO metricasParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                MetricasRepository metricasRepo = new MetricasRepository(context);

                MetricasDTO metricasBuscada = new MetricasDTO();

                metricasBuscada.NumeroEventos = await metricasRepo.MetricasEventos(metricasParaBuscar);

                return(metricasBuscada);
            }
        }
Exemplo n.º 13
0
        public async Task <WrapperSimpleTypesDTO> NumeroAnunciosRegistrados(MetricasDTO metricasParaBuscar)
        {
            WrapperSimpleTypesDTO wrapper = new WrapperSimpleTypesDTO();

            if (metricasParaBuscar != null && metricasParaBuscar.CodigoAnunciante > 0)
            {
                wrapper.NumeroRegistrosExistentes = await _context.Anuncios.Where(x => x.CodigoAnunciante == metricasParaBuscar.CodigoAnunciante).CountAsync();
            }
            else
            {
                wrapper.NumeroRegistrosExistentes = await _context.Anuncios.CountAsync();
            }

            return(wrapper);
        }
Exemplo n.º 14
0
        public async Task MetricasBusiness_MetricasUsuarios_ShouldDoMetrics()
        {
            MetricasBusiness metricasBusiness = new MetricasBusiness();

            MetricasDTO metricasParaBuscar = new MetricasDTO
            {
                PlanesParaBuscar = new List <int> {
                    18
                }
            };

            MetricasDTO metricasBuscada = await metricasBusiness.MetricasUsuarios(metricasParaBuscar);

            Assert.IsNotNull(metricasBuscada);
        }
Exemplo n.º 15
0
        public async Task MetricasBusiness_ListarUsuariosMetricas_ShouldList()
        {
            MetricasBusiness metricasBusiness = new MetricasBusiness();

            MetricasDTO metricasParaBuscar = new MetricasDTO
            {
                NombrePersonaParaBuscar = "Grupo",
                SkipIndexBase           = 0,
                TakeIndexBase           = 10,
                ZonaHorariaGMTBase      = -5
            };

            List <PersonasDTO> metricasBuscada = await metricasBusiness.ListarUsuariosMetricas(metricasParaBuscar);

            Assert.IsNotNull(metricasBuscada);
        }
Exemplo n.º 16
0
        public async Task <MetricasDTO> MetricasUsuarios(MetricasDTO metricasParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                MetricasRepository metricasRepo = new MetricasRepository(context);

                MetricasDTO metricasBuscada = new MetricasDTO();

                metricasBuscada.NumeroCandidatos = await metricasRepo.MetricasCandidatos(metricasParaBuscar);

                metricasBuscada.NumeroGrupos = await metricasRepo.MetricasGrupos(metricasParaBuscar);

                metricasBuscada.NumeroRepresentantes = await metricasRepo.MetricasRepresentantes(metricasParaBuscar);

                return(metricasBuscada);
            }
        }
        public async Task MetricasRepository_ListarUsuariosMetricas_ShouldList()
        {
            using (SportsGoEntities context = new SportsGoEntities())
            {
                MetricasRepository metricasRepo = new MetricasRepository(context);

                MetricasDTO metricas = new MetricasDTO
                {
                    SkipIndexBase = 0,
                    TakeIndexBase = 10
                };

                List <PersonasDTO> listaPersonas = await metricasRepo.ListarUsuariosMetricas(metricas);

                Assert.IsNotNull(listaPersonas);
            }
        }
Exemplo n.º 18
0
        public async Task <List <PersonasDTO> > ListarUsuariosMetricas(MetricasDTO metricasParaBuscar)
        {
            if (metricasParaBuscar == null)
            {
                throw new ArgumentNullException("No puedes listar los usuario si metricasParaBuscar es nulo!.");
            }
            if (metricasParaBuscar.TakeIndexBase <= 0 || metricasParaBuscar.SkipIndexBase < 0 || metricasParaBuscar.IdiomaBase == Idioma.SinIdioma)
            {
                throw new ArgumentException("metricasParaBuscar vacia y/o invalida!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            List <PersonasDTO> listaUsuarioMetricas = await client.PostAsync <MetricasDTO, List <PersonasDTO> >("Metricas/ListarUsuariosMetricas", metricasParaBuscar);

            return(listaUsuarioMetricas);
        }
        public async Task <IHttpActionResult> ListarUsuariosMetricas(MetricasDTO metricasParaBuscar)
        {
            if (metricasParaBuscar == null || metricasParaBuscar.TakeIndexBase <= 0 || metricasParaBuscar.SkipIndexBase < 0 || metricasParaBuscar.IdiomaBase == Idioma.SinIdioma)
            {
                return(BadRequest("metricasParaBuscar vacio y/o invalido!."));
            }

            try
            {
                List <PersonasDTO> listaUsuarioMetricas = await _metricasBusiness.ListarUsuariosMetricas(metricasParaBuscar);

                return(Ok(listaUsuarioMetricas));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
Exemplo n.º 20
0
        public async Task <WrapperSimpleTypesDTO> NumeroAnunciosRegistradosUltimoMes(MetricasDTO metricasParaBuscar)
        {
            WrapperSimpleTypesDTO wrapper = new WrapperSimpleTypesDTO();

            DateTime fechaInicio = DateTimeHelper.PrimerDiaDelMes(DateTime.Today.AddMonths(-1));
            DateTime fechaFinal  = DateTimeHelper.UltimoDiaDelMes(DateTime.Today.AddMonths(-1));

            if (metricasParaBuscar != null && metricasParaBuscar.CodigoAnunciante > 0)
            {
                wrapper.NumeroRegistrosExistentes = await _context.Anuncios.Where(x => x.CodigoAnunciante == metricasParaBuscar.CodigoAnunciante && x.Creacion >= fechaInicio && x.Creacion <= fechaFinal).CountAsync();
            }
            else
            {
                wrapper.NumeroRegistrosExistentes = await _context.Anuncios.Where(x => x.Creacion >= fechaInicio && x.Creacion <= fechaFinal).CountAsync();
            }

            return(wrapper);
        }
Exemplo n.º 21
0
        public async Task <List <PersonasDTO> > ListarUsuariosMetricas(MetricasDTO metricasParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                MetricasRepository metricasRepo         = new MetricasRepository(context);
                List <PersonasDTO> listaUsuarioMetricas = await metricasRepo.ListarUsuariosMetricas(metricasParaBuscar);

                if (listaUsuarioMetricas != null && listaUsuarioMetricas.Count > 0)
                {
                    DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
                    foreach (var persona in listaUsuarioMetricas)
                    {
                        persona.Usuarios.Creacion = helper.ConvertDateTimeFromAnotherTimeZone(metricasParaBuscar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, persona.Usuarios.Creacion);
                    }
                }

                return(listaUsuarioMetricas);
            }
        }
Exemplo n.º 22
0
        public async Task <WrapperSimpleTypesDTO> NumeroVecesVistos(MetricasDTO metricasParaBuscar)
        {
            WrapperSimpleTypesDTO wrapper = new WrapperSimpleTypesDTO();

            if (metricasParaBuscar != null && metricasParaBuscar.CodigoAnunciante > 0)
            {
                int?numeroVecesVistos = await _context.Anuncios.Where(x => x.CodigoAnunciante == metricasParaBuscar.CodigoAnunciante).Select(x => x.NumeroVecesVistos).SumAsync();

                wrapper.NumeroRegistrosExistentes = numeroVecesVistos.HasValue ? numeroVecesVistos.Value : 0;
            }
            else
            {
                int?numeroVecesVistos = await _context.Anuncios.Select(x => x.NumeroVecesVistos).SumAsync();

                wrapper.NumeroRegistrosExistentes = numeroVecesVistos.HasValue ? numeroVecesVistos.Value : 0;
            }

            return(wrapper);
        }
        async void ConsultarMetricasUsuarios()
        {
            MetricasDTO metricas = new MetricasDTO();

            try
            {
                if (IsNotConnected)
                {
                    return;
                }
                MetricasDTO metricasBuscadas = await _metricasServices.MetricasUsuarios(metricas);

                NumeroCandidatos     = metricasBuscadas.NumeroCandidatos + " " + SportsGoResources.Usuarios;
                NumeroGrupos         = metricasBuscadas.NumeroGrupos + " " + SportsGoResources.Usuarios;
                NumeroRepresentantes = metricasBuscadas.NumeroRepresentantes + " " + SportsGoResources.Usuarios;
            }
            catch (Exception)
            {
            }
        }
Exemplo n.º 24
0
        public async Task <JsonResult> GetDashboard(MetricasDTO metrica)
        {
            Result <MetricasDTO> result = new Result <MetricasDTO>();

            try
            {
                MetricasServices metricaService = new MetricasServices();
                metrica.CodigoAnunciante = UserLoggedIn().PersonaDelUsuario.AnuncianteDeLaPersona.Consecutivo;
                result.obj = await metricaService.MetricasAnuncios(metrica);

                if (result.obj == null)
                {
                    return(Json(Helper.returnErrorObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
                }

                return(Json(result, JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }
Exemplo n.º 25
0
        public async Task <List <PersonasDTO> > ListarUsuariosMetricas(MetricasDTO metricasParaBuscar)
        {
            IQueryable <Personas> listaUsuarioMetricas = (from persona in _context.Personas
                                                          select persona).AsQueryable();

            if (metricasParaBuscar.PaisesParaBuscar != null && metricasParaBuscar.PaisesParaBuscar.Count > 0)
            {
                listaUsuarioMetricas = listaUsuarioMetricas.Where(x => metricasParaBuscar.PaisesParaBuscar.Contains(x.CodigoPais));
            }

            if (metricasParaBuscar.IdiomasParaBuscar != null && metricasParaBuscar.IdiomasParaBuscar.Count > 0)
            {
                listaUsuarioMetricas = listaUsuarioMetricas.Where(x => metricasParaBuscar.IdiomasParaBuscar.Contains(x.CodigoIdioma));
            }

            if (metricasParaBuscar.PerfilesParaBuscar != null && metricasParaBuscar.PerfilesParaBuscar.Count > 0)
            {
                listaUsuarioMetricas = listaUsuarioMetricas.Where(x => metricasParaBuscar.PerfilesParaBuscar.Contains(x.CodigoTipoPerfil));
            }

            if (!string.IsNullOrWhiteSpace(metricasParaBuscar.UsuarioParaBuscar))
            {
                listaUsuarioMetricas = listaUsuarioMetricas.Where(x => x.Usuarios.Usuario.Trim().ToUpper().Contains(metricasParaBuscar.UsuarioParaBuscar.Trim().ToUpper()));
            }

            if (!string.IsNullOrWhiteSpace(metricasParaBuscar.NombrePersonaParaBuscar))
            {
                listaUsuarioMetricas = listaUsuarioMetricas.Where(x => x.Nombres.Trim().ToUpper().Contains(metricasParaBuscar.NombrePersonaParaBuscar.Trim().ToUpper()));
            }

            if (!string.IsNullOrWhiteSpace(metricasParaBuscar.EmailParaBuscar))
            {
                listaUsuarioMetricas = listaUsuarioMetricas.Where(x => x.Usuarios.Email.Trim().ToUpper().Contains(metricasParaBuscar.EmailParaBuscar.Trim().ToUpper()));
            }

            int numeroRegistrosExistentes = await listaUsuarioMetricas.CountAsync();

            return(await listaUsuarioMetricas.Select(x =>
                                                     new PersonasDTO
            {
                Consecutivo = x.Consecutivo,
                Nombres = x.Nombres,
                Apellidos = x.Apellidos,
                CodigoIdioma = x.CodigoIdioma,
                CodigoPais = x.CodigoPais,
                CodigoTipoPerfil = x.CodigoTipoPerfil,
                CodigoArchivoImagenPerfil = x.CodigoArchivoImagenPerfil,
                CiudadResidencia = x.CiudadResidencia,
                Telefono = x.Telefono,
                NumeroRegistrosExistentes = numeroRegistrosExistentes,
                CodigoUsuario = x.CodigoUsuario,
                Paises = new PaisesDTO
                {
                    Consecutivo = x.Paises.Consecutivo,
                    CodigoArchivo = x.Paises.CodigoArchivo,
                    DescripcionIdiomaBuscado = x.Paises.PaisesContenidos.Where(z => z.CodigoIdioma == metricasParaBuscar.CodigoIdiomaUsuarioBase).Select(z => z.Descripcion).FirstOrDefault()
                },
                Usuarios = new UsuariosDTO
                {
                    Consecutivo = x.Usuarios.Consecutivo,
                    Usuario = x.Usuarios.Usuario,
                    Email = x.Usuarios.Email,
                    CodigoTipoPerfil = x.Usuarios.CodigoTipoPerfil,
                    CodigoPlanUsuario = x.Usuarios.CodigoPlanUsuario,
                    Creacion = x.Usuarios.Creacion,
                    CuentaActiva = x.Usuarios.CuentaActiva,
                    PlanesUsuarios = new PlanesUsuariosDTO
                    {
                        Consecutivo = x.Usuarios.PlanesUsuarios.Consecutivo,
                        CodigoPlan = x.Usuarios.PlanesUsuarios.CodigoPlan,
                        NumeroCategoriasUsadas = x.Usuarios.PlanesUsuarios.NumeroCategoriasUsadas
                    }
                }
            })
                   .OrderByDescending(x => x.Usuarios.Creacion)
                   .Skip(() => metricasParaBuscar.SkipIndexBase)
                   .Take(() => metricasParaBuscar.TakeIndexBase)
                   .AsNoTracking()
                   .ToListAsync());
        }