Пример #1
0
        /// <summary>
        /// Busca os comentarios, posts, logradouros e bairros no banco de dados e relaciona-os
        /// </summary>
        /// <param name="cidade">Cidade a ser procurada</param>
        /// <returns>Lista de entidades encontradados no comentario ou post</returns>
        public static List <EntidadeRelacionada> ReconhecerEntididadesRelacionadas(string cidade)
        {
            Bairros     = BairroDAO.BuscarTodosBairros(cidade);
            Logradouros = LogradouroDAO.BuscarTodosLogradouros(cidade);
            PaginasFb   = PaginaFacebookDAO.ObterPaginasCidade(cidade);
            PostsFb     = new List <PostFacebookDAO>();
            foreach (var pagina in PaginasFb)
            {
                PostsFb.AddRange(PostFacebookDAO.BuscarPostsPagina(pagina.Id));
            }
            ComentariosFb = ComentarioFacebookDAO.BuscarTodosComentarios();

            var entidades_rel = new List <EntidadeRelacionada>();

            var sw = new Stopwatch();

            sw.Start();
            foreach (var comentario in ComentariosFb)
            {
                var comm_f    = Formatacao.FormatarTexto(comentario.message);
                var tokens    = Token.Tokenize(comentario.message);
                var entidades = ReconhecerEntidades(comm_f.Formatado);
                foreach (var ent in entidades)
                {
                    var ent_rel = ReconhecerEntidadeRelacionada(ent, comm_f.Original);
                    if (ent_rel != null)
                    {
                        entidades_rel.Add(ent_rel);
                    }
                }
            }

            foreach (var post in PostsFb)
            {
                var tokens    = Token.Tokenize(post.message);
                var comm_f    = Formatacao.FormatarTexto(post.message);
                var entidades = ReconhecerEntidades(comm_f.Formatado);
            }


            sw.Stop();


            return(null);
        }
Пример #2
0
        public object Get(string nome)
        {
            var cidade      = CidadeDAO.BuscarCidade(nome);
            var pags        = PaginaFacebookDAO.ObterPaginasCidade(cidade.Nome);
            var comentarios = ComentarioFacebookDAO.BuscarTodosComentariosDaCidade(cidade);
            var posts       = 0;
            var logradouros = LogradouroDAO.BuscarTodosLogradouros(nome);

            foreach (var item in pags)
            {
                posts += PostFacebookDAO.BuscarPostsPagina(item.Id).Count;
            }
            var c = new
            {
                cidade      = FirstCharToUpper(cidade.Nome),
                bairros     = cidade.BairrosDAO.Count,
                paginas     = pags.Count,
                comentarios = comentarios.Count,
                posts       = posts,
                logradouros = logradouros.Count
            };

            return(c);
        }
Пример #3
0
        public static async Task AdicionarComentarios()
        {
            WriteLine("Cidade referente as paginas: ");
            var cidade  = ReadLine();
            var paginas = PaginaFacebookDAO.ObterPaginasCidade(cidade);

            WriteLine($"{paginas.Count} paginas encontradas. \nObtendo posts...");
            var posts = new List <PostFacebookDAO>();

            foreach (var p in paginas)
            {
                posts.AddRange(PostFacebookDAO.BuscarPostsPagina(p.Id));
                SetCursorPosition(0, CursorTop - 1);
                WriteLine($"{posts.Count} encontrados. Aguarde...");
            }
            SetCursorPosition(0, CursorTop - 1);
            WriteLine($"Fim da busca. {posts.Count} encontrados.");

            WriteLine($"Obtendo comentarios do facebook. Aguarde...");
            double total            = 0;
            int    comentariosCount = 0;

            SetCursorPosition(0, CursorTop - 1);
            WriteLine("0 Comentários encontrados. Aguarde...");
            foreach (var post in posts)
            {
                double totalPorc = (total / posts.Count) * 100;

                var comentarios = await FacebookRestAPI.ObterComentariosPostAsync(post.id);

                comentariosCount += comentarios.Count;

                SetCursorPosition(0, CursorTop - 1);
                WriteLine($"{comentarios.Count} Comentários encontrados. {totalPorc:0.0}% concluido");

                double parcial = 0;
                int    add     = 0;
                int    addR    = 0;
                foreach (var comment in comentarios)
                {
                    long ok = ComentarioFacebookDAO.AdicionarComentario(comment, post.Id, post.IdPagina, post.IdCidade);
                    try
                    {
                        if (ok != -1)
                        {
                            add++;
                        }
                        if (comment.comments != null)
                        {
                            foreach (var com_r in comment?.comments?.data)
                            {
                                ok = ComentarioFacebookDAO.AdicionarComentario(com_r, post.Id, post.IdPagina, post.IdCidade, ok);
                                if (ok != -1)
                                {
                                    addR++;
                                }
                            }
                        }
                        parcial++;
                        double parcialPorc = (parcial / comentarios.Count) * 100;
                        //SetCursorPosition(0, CursorTop  -1);
                        //WriteLine($" | {add} comentarios e {addR} respostas foram adicionadas ao bd. {parcialPorc:0.0}% concluido");
                    }
                    catch (Exception e)
                    {
                    }
                }
                total++;
            }
            SetCursorPosition(0, CursorTop - 1);
            WriteLine($"Fim da busca. {comentariosCount} Comentários encontrados.");

            Read();
        }
Пример #4
0
        public async Task InitAsync()
        {
            while (true)
            {
                int dias = 30;
                MessageLoop = "Buscando cidades no MySQL...";
                var cidades = await CidadeDAO.BuscarCidadesAsync();

                MessageLoop = $"{cidades.Count} cidades encontradas";
                foreach (var cidade in cidades)
                {
                    var paginas = await PaginaFacebookDAO.ObterPaginasCidadeAsync(cidade.Nome);

                    MessageLoop = $"{paginas.Count} páginas encontradas de {cidade.Nome}";
                    var dataRecente = $"{DateTime.Now.AddDays(-dias):dd/MM/yyyy}";
                    foreach (var pagina in paginas)
                    {
                        MessageLoop = "Procurando posts na API do Facebook";
                        var posts = await FacebookRestAPI.ObterPostsPaginaAsync(pagina.id, dataRecente);

                        MessageLoop = $"{posts.data.Count} encontrados nos ultimos {dias} dias";
                        int postsatt = 0;
                        foreach (var post in posts.data)
                        {
                            // Adiciona os novos posts ao mysql
                            var idPost = await PostFacebookDAO.AdicionarPostIdAsync(post, cidade.Id, pagina.Id);

                            if (idPost != -1)
                            {
                                postsatt++;
                            }
                        }
                        MessageLoop = $"{postsatt} novos posts adicionados ao MySQL\nObtendo posts do MySQL";
                        // Busca todos os posts do mysql
                        var postsBd = PostFacebookDAO.BuscarPostsPagina(pagina.Id, dias);
                        MessageLoop = $"{postsBd.Count} posts encontrados\nAtualizando comentarios...\n";
                        int comentatt = 0;
                        foreach (var post in postsBd)
                        {
                            Progresso(postsBd.Count, postsBd.IndexOf(post) + 1, "Posts verificados.");
                            var idPost      = post.Id;
                            var comentarios = await FacebookRestAPI.ObterComentariosPostAsync(post.id, dataRecente);

                            foreach (var comentario in comentarios)
                            {
                                var idComentario = await ComentarioFacebookDAO.AdicionarComentarioAsync(comentario, idPost, pagina.Id, cidade.Id);

                                if (idComentario != -1)
                                {
                                    comentatt++;
                                }
                                if (comentario.comments != null && comentario.comments.data.Count > 0)
                                {
                                    foreach (var comentRespondido in comentario.comments?.data)
                                    {
                                        idComentario = await ComentarioFacebookDAO.AdicionarComentarioAsync(comentRespondido, idPost, pagina.Id, cidade.Id, idComentario);

                                        if (idComentario != -1)
                                        {
                                            comentatt++;
                                        }
                                    }
                                }
                            }
                        }
                        MessageLoop = $"{comentatt} novos comentarios adicionados ao MySQL";
                        var comentariosCidade = ComentarioFacebookDAO.BuscarTodosComentariosDaCidade(cidade, dias);
                        int catt = 0, catual = 0;
                        foreach (var comentario in comentariosCidade)
                        {
                            catual++;
                            if (MongoConector.AcessoDados.SalvarUmComentarioSeNaoExistir(comentario, "comentarios"))
                            {
                                catt++;
                            }
                            Progresso(comentariosCidade.Count, catual, "Comentarios analisados no mongo");
                        }
                        MessageLoop = $"{catt} novos comentarios adicionados ao MongoDB";
                        ReadKey();
                    }
                }
                MessageLoop = "Dormindo por 1 hora...";
                await Task.Delay(1000 * 60 * 60);
            }
        }
Пример #5
0
        public async void InitAsync()
        {
            int dias = 30;

            MessageLoop = "Buscando cidades no MySQL...";
            var cidades = await CidadeDAO.BuscarCidadesAsync();

            MessageLoop = $"{cidades.Count} cidades encontradas";
            foreach (var cidade in cidades)
            {
                var paginas = await PaginaFacebookDAO.ObterPaginasCidadeAsync(cidade.Nome);

                MessageLoop = $"{paginas.Count} páginas encontradas de {cidade.Nome}";
                var dataRecente = $"{DateTime.Now.AddDays(-dias):dd/MM/yyyy}";
                foreach (var pagina in paginas)
                {
                    var posts = await FacebookRestAPI.ObterPostsPaginaAsync(pagina.id, dataRecente);

                    MessageLoop = $"{posts.data.Count} encontrados nos ultimos {dias} dias";
                    int postsatt = 0;
                    foreach (var post in posts.data)
                    {
                        // Adiciona os novos posts ao mysql
                        var idPost = await PostFacebookDAO.AdicionarPostIdAsync(post, cidade.Id, pagina.Id);

                        if (idPost != -1)
                        {
                            postsatt++;
                        }
                    }
                    MessageLoop = $"{postsatt} novos posts adicionados ao MySQL";
                    // Busca todos os posts do mysql
                    var postsBd   = PostFacebookDAO.BuscarPostsPagina(pagina.Id);
                    int comentatt = 0;
                    foreach (var post in postsBd)
                    {
                        var idPost      = post.Id;
                        var comentarios = await FacebookRestAPI.ObterComentariosPostAsync(post.id, dataRecente);

                        foreach (var comentario in comentarios)
                        {
                            var idComentario = await ComentarioFacebookDAO.AdicionarComentarioAsync(comentario, idPost, pagina.Id, cidade.Id);

                            if (idComentario != -1)
                            {
                                comentatt++;
                            }
                            if (comentario.comments != null && comentario.comments.data.Count > 0)
                            {
                                foreach (var comentRespondido in comentario.comments?.data)
                                {
                                    idComentario = await ComentarioFacebookDAO.AdicionarComentarioAsync(comentRespondido, idPost, pagina.Id, cidade.Id, idComentario);

                                    if (idComentario != -1)
                                    {
                                        comentatt++;
                                    }
                                }
                            }
                        }
                    }
                    MessageLoop = $"{comentatt} novos comentarios adicionados ao MySQL";
                }
            }
        }