concurso_hub 0.1.0

data/src/application/ports/concurso_repository.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Application
+  module Ports
+    class ConcursoRepository
+      def fetch_abertos
+        raise NotImplementedError, "#{self.class}#fetch_abertos deve ser implementado"
+      end
+
+      def fetch_encerrados(busca)
+        raise NotImplementedError, "#{self.class}#fetch_encerrados deve ser implementado"
+      end
+
+      def fetch_edital(url)
+        raise NotImplementedError, "#{self.class}#fetch_edital deve ser implementado"
+      end
+
+      def fetch_provas_listing(provas_url)
+        raise NotImplementedError, "#{self.class}#fetch_provas_listing deve ser implementado"
+      end
+
+      def fetch_prova_pdfs(download_url)
+        raise NotImplementedError, "#{self.class}#fetch_prova_pdfs deve ser implementado"
+      end
+    end
+  end
+end

data/src/application/ports/file_downloader.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Application
+  module Ports
+    class FileDownloader
+      def download(url, dest_path)
+        raise NotImplementedError, "#{self.class}#download deve ser implementado"
+      end
+    end
+  end
+end

data/src/application/ports/presenter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Application
+  module Ports
+    class Presenter
+      def show_loading
+        raise NotImplementedError, "#{self.class}#show_loading deve ser implementado"
+      end
+
+      def show(concursos, metadata: {})
+        raise NotImplementedError, "#{self.class}#show deve ser implementado"
+      end
+
+      def error(message)
+        raise NotImplementedError, "#{self.class}#error deve ser implementado"
+      end
+
+      def show_edital(edital)
+        raise NotImplementedError, "#{self.class}#show_edital deve ser implementado"
+      end
+
+      def show_download_start(titulo, index, total)
+        raise NotImplementedError, "#{self.class}#show_download_start deve ser implementado"
+      end
+
+      def show_download_done(paths)
+        raise NotImplementedError, "#{self.class}#show_download_done deve ser implementado"
+      end
+
+      def show_provas(provas)
+        raise NotImplementedError, "#{self.class}#show_provas deve ser implementado"
+      end
+    end
+  end
+end

data/src/application/use_cases/baixar_edital.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'uri'
+require_relative '../baixar_edital_request'
+require_relative '../ports/concurso_repository'
+require_relative '../ports/file_downloader'
+require_relative '../ports/presenter'
+
+module Application
+  module UseCases
+    class BaixarEdital
+      def initialize(repository:, downloader:, presenter:)
+        @repository = repository
+        @downloader = downloader
+        @presenter  = presenter
+      end
+
+      def execute(request)
+        edital = @repository.fetch_edital(request.url)
+
+        if edital.pdfs.empty?
+          @presenter.error("Nenhum PDF encontrado para este edital.")
+          return
+        end
+
+        dest_dir = request.dest_dir || File.join(Dir.pwd, 'editais')
+        Dir.mkdir(dest_dir) unless Dir.exist?(dest_dir)
+
+        downloaded = []
+        edital.pdfs.each_with_index do |pdf, index|
+          filename  = File.basename(URI.parse(pdf[:url]).path)
+          dest_path = File.join(dest_dir, filename)
+
+          @presenter.show_download_start(pdf[:titulo], index + 1, edital.pdfs.size)
+          @downloader.download(pdf[:url], dest_path)
+          downloaded << dest_path
+        end
+
+        @presenter.show_download_done(downloaded)
+      end
+    end
+  end
+end

data/src/application/use_cases/baixar_provas.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'uri'
+require_relative '../baixar_provas_request'
+require_relative '../ports/concurso_repository'
+require_relative '../ports/file_downloader'
+require_relative '../ports/presenter'
+
+module Application
+  module UseCases
+    class BaixarProvas
+      def initialize(repository:, downloader:, presenter:)
+        @repository = repository
+        @downloader = downloader
+        @presenter  = presenter
+      end
+
+      def execute(request)
+        provas = @repository.fetch_provas_listing(request.url)
+
+        if provas.empty?
+          @presenter.error("Nenhuma prova encontrada em: #{request.url}")
+          return
+        end
+
+        todos_pdfs = []
+        provas.each_with_index do |prova, i|
+          @presenter.show_download_start(
+            "Buscando provas de: #{prova[:cargo]}", i + 1, provas.size
+          )
+          pdfs = @repository.fetch_prova_pdfs(prova[:download_url])
+          pdfs.each { |pdf| todos_pdfs << { cargo: prova[:cargo], **pdf } }
+        end
+
+        if todos_pdfs.empty?
+          @presenter.error("Nenhum PDF de prova encontrado.")
+          return
+        end
+
+        dest_dir = request.dest_dir || File.join(Dir.pwd, 'editais')
+        Dir.mkdir(dest_dir) unless Dir.exist?(dest_dir)
+
+        downloaded = []
+        todos_pdfs.each_with_index do |pdf, i|
+          filename  = File.basename(URI.parse(pdf[:url]).path)
+          dest_path = File.join(dest_dir, filename)
+
+          @presenter.show_download_start(
+            "#{pdf[:cargo]} — #{pdf[:titulo]}", i + 1, todos_pdfs.size
+          )
+          @downloader.download(pdf[:url], dest_path)
+          downloaded << dest_path
+        end
+
+        @presenter.show_download_done(downloaded)
+      end
+    end
+  end
+end

data/src/application/use_cases/listar_concursos.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative '../filtros_concurso'
+require_relative '../ports/concurso_repository'
+require_relative '../ports/presenter'
+
+module Application
+  module UseCases
+    class ListarConcursos
+      def initialize(repository:, presenter:)
+        @repository = repository
+        @presenter  = presenter
+      end
+
+      def execute(filtros = FiltrosConcurso.new)
+        if filtros.encerrados?
+          executar_encerrados(filtros)
+        else
+          executar_abertos(filtros)
+        end
+      end
+
+      private
+
+      def executar_abertos(filtros)
+        concursos, metadata = @repository.fetch_abertos
+        metadata[:total_scraped] = concursos.size
+        metadata[:modo]          = :abertos
+
+        concursos = aplicar_filtros(concursos, filtros, incluir_busca: true)
+        concursos = concursos.first(filtros.limite) if filtros.limite
+        @presenter.show(concursos, metadata: metadata)
+      end
+
+      def executar_encerrados(filtros)
+        unless filtros.busca
+          @presenter.error("--encerrados requer --busca TEXTO (ex: ruby main.rb --encerrados --busca policia)")
+          return
+        end
+
+        concursos, metadata = @repository.fetch_encerrados(filtros.busca)
+        metadata[:total_scraped] = concursos.size
+        metadata[:modo]          = :encerrados
+        metadata[:busca]         = filtros.busca
+
+        concursos = aplicar_filtros(concursos, filtros, incluir_busca: false)
+        concursos = concursos.first(filtros.limite) if filtros.limite
+        @presenter.show(concursos, metadata: metadata)
+      end
+
+      def aplicar_filtros(concursos, filtros, incluir_busca: true)
+        concursos = filtrar_por_estado(concursos, filtros.estado)
+        concursos = filtrar_por_nivel(concursos, filtros.nivel)
+        concursos = filtrar_por_busca(concursos, filtros.busca) if incluir_busca
+        concursos = filtrar_por_ano(concursos, filtros.ano)
+        concursos
+      end
+
+      def filtrar_por_estado(concursos, estado)
+        return concursos unless estado
+
+        concursos.select { |c| c.estado == estado }
+      end
+
+      def filtrar_por_nivel(concursos, nivel)
+        return concursos unless nivel
+
+        term = nivel.downcase
+        concursos.select { |c| c.nivel.downcase.include?(term) }
+      end
+
+      def filtrar_por_busca(concursos, busca)
+        return concursos unless busca
+
+        term = busca.downcase
+        concursos.select do |c|
+          c.instituicao.downcase.include?(term) ||
+            c.cargos.downcase.include?(term)
+        end
+      end
+
+      def filtrar_por_ano(concursos, ano)
+        return concursos unless ano
+
+        concursos.select { |c| c.prazo.include?(ano.to_s) }
+      end
+    end
+  end
+end

data/src/application/use_cases/listar_provas.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../ver_edital_request'
+require_relative '../ports/concurso_repository'
+require_relative '../ports/presenter'
+
+module Application
+  module UseCases
+    class ListarProvas
+      def initialize(repository:, presenter:)
+        @repository = repository
+        @presenter  = presenter
+      end
+
+      def execute(request)
+        listing = @repository.fetch_provas_listing(request.url)
+
+        if listing.empty?
+          @presenter.error("Nenhuma prova encontrada em: #{request.url}")
+          return
+        end
+
+        resultado = listing.map do |prova|
+          pdfs = @repository.fetch_prova_pdfs(prova[:download_url])
+          { cargo: prova[:cargo], pdfs: pdfs }
+        end
+
+        @presenter.show_provas(resultado)
+      end
+    end
+  end
+end

data/src/application/use_cases/ver_edital.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../ver_edital_request'
+require_relative '../ports/concurso_repository'
+require_relative '../ports/presenter'
+
+module Application
+  module UseCases
+    class VerEdital
+      def initialize(repository:, presenter:)
+        @repository = repository
+        @presenter  = presenter
+      end
+
+      def execute(request)
+        edital = @repository.fetch_edital(request.url)
+        @presenter.show_edital(edital)
+      end
+    end
+  end
+end

data/src/application/ver_edital_request.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Application
+  VerEditalRequest = Struct.new(:url, keyword_init: true)
+end

data/src/domain/entities/concurso.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Domain
+  module Entities
+    class Concurso
+      attr_reader :instituicao, :estado, :vagas, :salario,
+                  :cargos, :nivel, :prazo, :url
+
+      def initialize(instituicao:, estado:, vagas:, salario:,
+                     cargos:, nivel:, prazo:, url:)
+        @instituicao = instituicao
+        @estado      = estado
+        @vagas       = vagas
+        @salario     = salario
+        @cargos      = cargos
+        @nivel       = nivel
+        @prazo       = prazo
+        @url         = url
+
+        freeze
+      end
+    end
+  end
+end

data/src/domain/entities/edital.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Domain
+  module Entities
+    class Edital
+      attr_reader :titulo, :descricao, :data_publicacao, :blocos, :pdfs, :provas_url, :url
+
+      def initialize(titulo:, descricao:, data_publicacao:, blocos:, pdfs: [], provas_url: nil, url:)
+        @titulo          = titulo
+        @descricao       = descricao
+        @data_publicacao = data_publicacao
+        @blocos          = blocos.freeze
+        @pdfs            = pdfs.freeze
+        @provas_url      = provas_url
+        @url             = url
+
+        freeze
+      end
+    end
+  end
+end

data/src/infrastructure/http/http_client.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+module Infrastructure
+  module Http
+    class HttpClient
+      USER_AGENT = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 ' \
+                   '(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36'
+
+      def get(url, redirect_limit: 5)
+        raise 'Muitos redirecionamentos' if redirect_limit.zero?
+
+        uri      = URI.parse(url)
+        http     = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl      = (uri.scheme == 'https')
+        http.open_timeout = 15
+        http.read_timeout = 30
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request['User-Agent']      = USER_AGENT
+        request['Accept']          = 'text/html,application/xhtml+xml'
+        request['Accept-Language'] = 'pt-BR,pt;q=0.9'
+
+        response = http.request(request)
+
+        case response
+        when Net::HTTPSuccess
+          body = response.body
+          body.force_encoding('UTF-8')
+          body
+        when Net::HTTPRedirection
+          get(response['location'], redirect_limit: redirect_limit - 1)
+        else
+          raise "Erro HTTP: #{response.code} #{response.message}"
+        end
+      end
+    end
+  end
+end

data/src/infrastructure/http/http_file_downloader.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require_relative '../../application/ports/file_downloader'
+
+module Infrastructure
+  module Http
+    class HttpFileDownloader < Application::Ports::FileDownloader
+      USER_AGENT = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 ' \
+                   '(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36'
+
+      def download(url, dest_path, redirect_limit: 5)
+        raise 'Muitos redirecionamentos' if redirect_limit.zero?
+
+        uri  = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl      = (uri.scheme == 'https')
+        http.open_timeout = 15
+        http.read_timeout = 120
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request['User-Agent'] = USER_AGENT
+
+        http.start do |h|
+          h.request(request) do |response|
+            case response
+            when Net::HTTPSuccess
+              File.open(dest_path, 'wb') do |file|
+                response.read_body { |chunk| file.write(chunk) }
+              end
+            when Net::HTTPRedirection
+              new_url = response['location']
+              new_url = URI.join(url, new_url).to_s unless new_url.start_with?('http')
+              download(new_url, dest_path, redirect_limit: redirect_limit - 1)
+            else
+              raise "Erro HTTP: #{response.code} #{response.message}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/src/infrastructure/parsers/pci_html_parser.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require_relative '../../domain/entities/concurso'
+require_relative '../../domain/entities/edital'
+
+module Infrastructure
+  module Parsers
+    class PciHtmlParser
+      def parse_abertos(html)
+        doc = Nokogiri::HTML(html, nil, 'UTF-8')
+        [extract_abertos(doc), { total_vagas: extract_total_vagas(doc) }]
+      end
+
+      def parse_encerrados(html)
+        doc = Nokogiri::HTML(html, nil, 'UTF-8')
+        concursos = doc.css('div.ea').filter_map { |el| build_concurso_encerrado(el) }
+        [concursos, { total_vagas: '' }]
+      end
+
+      def parse_edital(html, url)
+        doc     = Nokogiri::HTML(html, nil, 'UTF-8')
+        article = doc.css('article#noticia').first
+
+        raise "Edital não encontrado na página: #{url}" unless article
+
+        titulo    = article.css('h1[itemprop="headline"]').first&.text&.strip || ''
+        descricao = article.css('div.description').first&.text&.strip          || ''
+        data_raw  = article.css('abbr.published').first&.[]('title')           || ''
+        data_pub  = format_date(data_raw)
+
+        body_node = article.css('div[itemprop="articleBody"]').first
+        blocos    = body_node ? extract_body_blocks(body_node) : []
+
+        Domain::Entities::Edital.new(
+          titulo:          titulo,
+          descricao:       descricao,
+          data_publicacao: data_pub,
+          blocos:          blocos,
+          pdfs:            extract_pdfs(doc),
+          provas_url:      extract_provas_url(doc),
+          url:             url
+        )
+      end
+
+      def parse_provas_listing(html)
+        doc = Nokogiri::HTML(html, nil, 'UTF-8')
+        doc.css('a.prova_download').map do |a|
+          cargo = a.children.select(&:text?).map(&:text).join.strip
+          { cargo: cargo, download_url: a['href'] }
+        end
+      end
+
+      def parse_prova_download_page(html)
+        doc = Nokogiri::HTML(html, nil, 'UTF-8')
+        doc.css('div#download a.item-link[href$=".pdf"]')
+           .select { |a| a.text.strip.start_with?('Baixar') }
+           .map    { |a| { titulo: a.text.sub(/\ABaixar\s+/i, '').strip, url: a['href'] } }
+      end
+
+      private
+
+      def extract_total_vagas(doc)
+        doc.css('h1').first&.text&.match(/[\d.]+\s*Vagas?/i)&.[](0) || ''
+      end
+
+      def extract_abertos(doc)
+        nacional = doc.css('#NACIONAL').first
+        return [] unless nacional
+
+        concursos     = []
+        current_state = 'NACIONAL'
+
+        nacional.parent.children.each do |child|
+          next unless child.element?
+
+          case child['class']&.strip
+          when 'ua'
+            current_state = child['id'] || 'NACIONAL'
+          when 'da', 'na'
+            entry = build_concurso(child, current_state)
+            concursos << entry if entry
+          end
+        end
+
+        concursos
+      end
+
+      def build_concurso_encerrado(el)
+        link = el.css('div.ca > a').first
+        return nil unless link
+
+        state = el.css('div.cc').first&.text&.strip || ''
+        vagas, salario = parse_vagas_salario(el)
+        cargos, nivel  = parse_cargo_nivel(el)
+
+        Domain::Entities::Concurso.new(
+          instituicao: link.text.strip,
+          estado:      state,
+          vagas:       vagas,
+          salario:     salario,
+          cargos:      cargos,
+          nivel:       nivel,
+          prazo:       parse_prazo(el),
+          url:         link['href']
+        )
+      end
+      def build_concurso(el, state)
+        link = el.css('div.ca > a').first
+        return nil unless link
+
+        vagas, salario = parse_vagas_salario(el)
+        cargos, nivel  = parse_cargo_nivel(el)
+
+        Domain::Entities::Concurso.new(
+          instituicao: link.text.strip,
+          estado:      state,
+          vagas:       vagas,
+          salario:     salario,
+          cargos:      cargos,
+          nivel:       nivel,
+          prazo:       parse_prazo(el),
+          url:         link['href']
+        )
+      end
+
+      def parse_vagas_salario(el)
+        cd = el.css('div.cd').first
+        return ['', ''] unless cd
+
+        text = cd.xpath('text()[1]').text.strip
+        if text =~ /^(.+?)\s+(até R\$.+)$/
+          [$1.strip, $2.strip]
+        else
+          [text, '']
+        end
+      end
+
+      def parse_cargo_nivel(el)
+        cd = el.css('div.cd').first
+        return ['', ''] unless cd
+
+        outer = cd.children.find { |c| c.element? && c.name == 'span' }
+        return ['', ''] unless outer
+
+        cargos = outer.xpath('text()[1]').text.strip
+        nivel  = outer.children
+                      .find { |c| c.element? && c.name == 'span' }
+                      &.text&.strip || ''
+        [cargos, nivel]
+      end
+
+      def parse_prazo(el)
+        span = el.css('div.ce span').first
+        return '' unless span
+
+        span.children.map { |c|
+          c.element? && c.name == 'br' ? ' ' : c.text
+        }.join.gsub(/\s+/, ' ').strip
+      end
+
+      def extract_pdfs(doc)
+        doc.css('aside#links li.pdf a').map do |a|
+          { titulo: a.text.strip, url: a['href'] }
+        end
+      end
+
+      def extract_provas_url(doc)
+        doc.css('aside#links li.li_provas a').first&.[]('href')
+      end
+
+      def format_date(iso_str)
+        return '' if iso_str.nil? || iso_str.empty?
+
+        parts = iso_str[0..9].split('-')
+        return iso_str unless parts.length == 3
+
+        parts.reverse.join('/')
+      end
+
+      # Converte nós filhos de um articleBody em blocos estruturados.
+      # Cada bloco: { tipo: :secao | :paragrafo | :item, texto: String }
+      def extract_body_blocks(node)
+        blocos = []
+        node.children.each do |child|
+          next unless child.element?
+
+          case child.name
+          when 'p'
+            text = child.text.strip.gsub(/\s+/, ' ')
+            blocos << { tipo: :paragrafo, texto: text } unless text.empty?
+          when 'h2', 'h3', 'h4'
+            text = child.text.strip
+            blocos << { tipo: :secao, texto: text } unless text.empty?
+          when 'ul', 'ol'
+            child.css('li').each do |li|
+              text = li.text.strip.gsub(/\s+/, ' ')
+              blocos << { tipo: :item, texto: text } unless text.empty?
+            end
+          when 'div'
+            blocos.concat(extract_body_blocks(child))
+          end
+        end
+        blocos
+      end
+    end
+  end
+end