feat: Sistema de Ranking de Consultores CAPES - versão inicial

Backend (FastAPI + DDD):
- Arquitetura DDD com camadas Domain, Application, Infrastructure, Interface
- Integração com Elasticsearch (ATUACAPES) para dados de consultores
- Integração com Oracle (SUCUPIRA_PAINEL) para coordenações PPG
- Cálculo dos 4 componentes de pontuação (A, B, C, D)
- Cache em memória para otimização de performance
- API REST com endpoints /ranking, /ranking/detalhado, /consultor/{id}

Frontend (React + Vite):
- Interface responsiva com cards expansíveis
- Visualização detalhada de pontuação por componente
- Filtro por quantidade de consultores (Top 10, 50, 100, etc)

Docker:
- docker-compose com shared_network externa
- Backend com Oracle Instant Client
- Frontend com Vite dev server

backend/src/application/dtos/consultor_dto.py

@@ -0,0 +1,98 @@
+from dataclasses import dataclass, asdict
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+
+
+@dataclass
+class PeriodoDTO:
+    inicio: str
+    fim: Optional[str]
+    ativo: bool
+    anos_decorridos: float
+
+
+@dataclass
+class CoordenacaoCapesDTO:
+    tipo: str
+    area_avaliacao: str
+    periodo: PeriodoDTO
+    areas_adicionais: List[str]
+    ja_coordenou_antes: bool
+
+
+@dataclass
+class CoordenacaoProgramaDTO:
+    id_programa: int
+    nome_programa: str
+    codigo_programa: str
+    nota_ppg: str
+    modalidade: str
+    area_avaliacao: str
+    periodo: PeriodoDTO
+
+
+@dataclass
+class ConsultoriaDTO:
+    total_eventos: int
+    eventos_recentes: int
+    primeiro_evento: str
+    ultimo_evento: str
+    vezes_responsavel: int
+    areas: List[str]
+
+
+@dataclass
+class PremiacaoDTO:
+    tipo: str
+    nome_premio: str
+    ano: int
+    pontos: int
+
+
+@dataclass
+class ComponentePontuacaoDTO:
+    base: int
+    tempo: int
+    extras: int
+    bonus: int
+    retorno: int
+    total: int
+
+
+@dataclass
+class PontuacaoCompletaDTO:
+    componente_a: ComponentePontuacaoDTO
+    componente_b: ComponentePontuacaoDTO
+    componente_c: ComponentePontuacaoDTO
+    componente_d: ComponentePontuacaoDTO
+    pontuacao_total: int
+
+
+@dataclass
+class ConsultorResumoDTO:
+    id_pessoa: int
+    nome: str
+    anos_atuacao: float
+    ativo: bool
+    veterano: bool
+    pontuacao_total: int
+    rank: Optional[int] = None
+
+
+@dataclass
+class ConsultorDetalhadoDTO:
+    id_pessoa: int
+    nome: str
+    cpf: Optional[str]
+    anos_atuacao: float
+    ativo: bool
+    veterano: bool
+    coordenacoes_capes: List[CoordenacaoCapesDTO]
+    coordenacoes_programas: List[CoordenacaoProgramaDTO]
+    consultoria: Optional[ConsultoriaDTO]
+    premiacoes: List[PremiacaoDTO]
+    pontuacao: PontuacaoCompletaDTO
+    rank: Optional[int] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)

backend/src/application/use_cases/obter_consultor.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+from ...domain.repositories.consultor_repository import ConsultorRepository
+from ..dtos.consultor_dto import ConsultorDetalhadoDTO
+from .obter_ranking import ObterRankingUseCase
+
+
+class ObterConsultorUseCase:
+    def __init__(self, repository: ConsultorRepository):
+        self.repository = repository
+        self.ranking_use_case = ObterRankingUseCase(repository)
+
+    async def executar(self, id_pessoa: int) -> Optional[ConsultorDetalhadoDTO]:
+        consultor = await self.repository.buscar_por_id(id_pessoa)
+        if not consultor:
+            return None
+
+        ranking_completo = await self.repository.buscar_ranking(limite=1000)
+        rank = next(
+            (idx + 1 for idx, c in enumerate(ranking_completo) if c.id_pessoa == id_pessoa), None
+        )
+
+        return self.ranking_use_case._converter_para_dto_detalhado(consultor, rank or 0)

backend/src/application/use_cases/obter_ranking.py

@@ -0,0 +1,145 @@
+from typing import List, Optional
+from datetime import datetime
+
+from ...domain.repositories.consultor_repository import ConsultorRepository
+from ...domain.entities.consultor import Consultor
+from ..dtos.consultor_dto import (
+    ConsultorResumoDTO,
+    ConsultorDetalhadoDTO,
+    PeriodoDTO,
+    CoordenacaoCapesDTO,
+    CoordenacaoProgramaDTO,
+    ConsultoriaDTO,
+    PremiacaoDTO,
+    ComponentePontuacaoDTO,
+    PontuacaoCompletaDTO,
+)
+
+
+class ObterRankingUseCase:
+    def __init__(self, repository: ConsultorRepository):
+        self.repository = repository
+
+    async def executar(
+        self, limite: int = 100, componente: Optional[str] = None
+    ) -> List[ConsultorResumoDTO]:
+        consultores = await self.repository.buscar_ranking(limite=limite, componente=componente)
+
+        return [
+            ConsultorResumoDTO(
+                id_pessoa=c.id_pessoa,
+                nome=c.nome,
+                anos_atuacao=c.anos_atuacao,
+                ativo=c.ativo,
+                veterano=c.veterano,
+                pontuacao_total=c.pontuacao_total,
+                rank=idx + 1,
+            )
+            for idx, c in enumerate(consultores)
+        ]
+
+    async def executar_detalhado(
+        self, limite: int = 100, componente: Optional[str] = None
+    ) -> List[ConsultorDetalhadoDTO]:
+        consultores = await self.repository.buscar_ranking(limite=limite, componente=componente)
+
+        return [self._converter_para_dto_detalhado(c, idx + 1) for idx, c in enumerate(consultores)]
+
+    def _converter_para_dto_detalhado(
+        self, consultor: Consultor, rank: int
+    ) -> ConsultorDetalhadoDTO:
+        return ConsultorDetalhadoDTO(
+            id_pessoa=consultor.id_pessoa,
+            nome=consultor.nome,
+            cpf=consultor.cpf,
+            anos_atuacao=consultor.anos_atuacao,
+            ativo=consultor.ativo,
+            veterano=consultor.veterano,
+            coordenacoes_capes=[
+                CoordenacaoCapesDTO(
+                    tipo=cc.tipo,
+                    area_avaliacao=cc.area_avaliacao,
+                    periodo=PeriodoDTO(
+                        inicio=cc.periodo.inicio.isoformat(),
+                        fim=cc.periodo.fim.isoformat() if cc.periodo.fim else None,
+                        ativo=cc.periodo.ativo,
+                        anos_decorridos=cc.periodo.anos_decorridos,
+                    ),
+                    areas_adicionais=cc.areas_adicionais,
+                    ja_coordenou_antes=cc.ja_coordenou_antes,
+                )
+                for cc in consultor.coordenacoes_capes
+            ],
+            coordenacoes_programas=[
+                CoordenacaoProgramaDTO(
+                    id_programa=cp.id_programa,
+                    nome_programa=cp.nome_programa,
+                    codigo_programa=cp.codigo_programa,
+                    nota_ppg=cp.nota_ppg,
+                    modalidade=cp.modalidade,
+                    area_avaliacao=cp.area_avaliacao,
+                    periodo=PeriodoDTO(
+                        inicio=cp.periodo.inicio.isoformat(),
+                        fim=cp.periodo.fim.isoformat() if cp.periodo.fim else None,
+                        ativo=cp.periodo.ativo,
+                        anos_decorridos=cp.periodo.anos_decorridos,
+                    ),
+                )
+                for cp in consultor.coordenacoes_programas
+            ],
+            consultoria=ConsultoriaDTO(
+                total_eventos=consultor.consultoria.total_eventos,
+                eventos_recentes=consultor.consultoria.eventos_recentes,
+                primeiro_evento=consultor.consultoria.primeiro_evento.isoformat(),
+                ultimo_evento=consultor.consultoria.ultimo_evento.isoformat(),
+                vezes_responsavel=consultor.consultoria.vezes_responsavel,
+                areas=consultor.consultoria.areas,
+            )
+            if consultor.consultoria
+            else None,
+            premiacoes=[
+                PremiacaoDTO(
+                    tipo=p.tipo,
+                    nome_premio=p.nome_premio,
+                    ano=p.ano,
+                    pontos=p.pontos,
+                )
+                for p in consultor.premiacoes
+            ],
+            pontuacao=PontuacaoCompletaDTO(
+                componente_a=ComponentePontuacaoDTO(
+                    base=consultor.pontuacao.componente_a.base,
+                    tempo=consultor.pontuacao.componente_a.tempo,
+                    extras=consultor.pontuacao.componente_a.extras,
+                    bonus=consultor.pontuacao.componente_a.bonus,
+                    retorno=consultor.pontuacao.componente_a.retorno,
+                    total=consultor.pontuacao.componente_a.total,
+                ),
+                componente_b=ComponentePontuacaoDTO(
+                    base=consultor.pontuacao.componente_b.base,
+                    tempo=consultor.pontuacao.componente_b.tempo,
+                    extras=consultor.pontuacao.componente_b.extras,
+                    bonus=consultor.pontuacao.componente_b.bonus,
+                    retorno=0,
+                    total=consultor.pontuacao.componente_b.total,
+                ),
+                componente_c=ComponentePontuacaoDTO(
+                    base=consultor.pontuacao.componente_c.base,
+                    tempo=consultor.pontuacao.componente_c.tempo,
+                    extras=consultor.pontuacao.componente_c.extras,
+                    bonus=consultor.pontuacao.componente_c.bonus,
+                    retorno=0,
+                    total=consultor.pontuacao.componente_c.total,
+                ),
+                componente_d=ComponentePontuacaoDTO(
+                    base=consultor.pontuacao.componente_d.base,
+                    tempo=consultor.pontuacao.componente_d.tempo,
+                    extras=consultor.pontuacao.componente_d.extras,
+                    bonus=consultor.pontuacao.componente_d.bonus,
+                    retorno=0,
+                    total=consultor.pontuacao.componente_d.total,
+                ),
+                pontuacao_total=consultor.pontuacao.total,
+            ),
+            rank=rank,
+        )

backend/src/domain/entities/consultor.py

@@ -0,0 +1,77 @@
+from dataclasses import dataclass, field
+from typing import List, Optional
+from datetime import datetime
+
+from ..value_objects.periodo import Periodo
+from ..value_objects.pontuacao import PontuacaoCompleta
+
+
+@dataclass
+class CoordenacaoCapes:
+    tipo: str
+    area_avaliacao: str
+    periodo: Periodo
+    areas_adicionais: List[str] = field(default_factory=list)
+    ja_coordenou_antes: bool = False
+
+
+@dataclass
+class CoordenacaoPrograma:
+    id_programa: int
+    nome_programa: str
+    codigo_programa: str
+    nota_ppg: str
+    modalidade: str
+    area_avaliacao: str
+    periodo: Periodo
+
+
+@dataclass
+class Consultoria:
+    total_eventos: int
+    eventos_recentes: int
+    primeiro_evento: datetime
+    ultimo_evento: datetime
+    vezes_responsavel: int
+    areas: List[str] = field(default_factory=list)
+
+
+@dataclass
+class Premiacao:
+    tipo: str
+    nome_premio: str
+    ano: int
+    pontos: int
+
+
+@dataclass
+class Consultor:
+    id_pessoa: int
+    nome: str
+    cpf: Optional[str] = None
+    coordenacoes_capes: List[CoordenacaoCapes] = field(default_factory=list)
+    coordenacoes_programas: List[CoordenacaoPrograma] = field(default_factory=list)
+    consultoria: Optional[Consultoria] = None
+    premiacoes: List[Premiacao] = field(default_factory=list)
+    pontuacao: Optional[PontuacaoCompleta] = None
+
+    @property
+    def anos_atuacao(self) -> float:
+        if not self.consultoria:
+            return 0.0
+        dias = (datetime.now() - self.consultoria.primeiro_evento).days
+        return round(dias / 365.25, 1)
+
+    @property
+    def ativo(self) -> bool:
+        if not self.consultoria:
+            return False
+        return self.consultoria.eventos_recentes > 0
+
+    @property
+    def veterano(self) -> bool:
+        return self.anos_atuacao >= 10.0
+
+    @property
+    def pontuacao_total(self) -> int:
+        return self.pontuacao.total if self.pontuacao else 0

backend/src/domain/repositories/consultor_repository.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional
+
+from ..entities.consultor import Consultor
+
+
+class ConsultorRepository(ABC):
+    @abstractmethod
+    async def buscar_por_id(self, id_pessoa: int) -> Optional[Consultor]:
+        pass
+
+    @abstractmethod
+    async def buscar_todos(
+        self, limite: int = 100, offset: int = 0, filtro_ativo: Optional[bool] = None
+    ) -> List[Consultor]:
+        pass
+
+    @abstractmethod
+    async def buscar_ranking(
+        self, limite: int = 100, componente: Optional[str] = None
+    ) -> List[Consultor]:
+        pass
+
+    @abstractmethod
+    async def contar_total(self, filtro_ativo: Optional[bool] = None) -> int:
+        pass

backend/src/domain/services/calculador_pontuacao.py

@@ -0,0 +1,93 @@
+from datetime import datetime, timedelta
+from typing import List
+
+from ..entities.consultor import (
+    Consultor,
+    CoordenacaoCapes,
+    CoordenacaoPrograma,
+    Consultoria,
+    Premiacao,
+)
+from ..value_objects.pontuacao import ComponentePontuacao, PontuacaoCompleta
+
+
+class CalculadorPontuacao:
+    @staticmethod
+    def calcular_componente_a(coordenacoes: List[CoordenacaoCapes]) -> ComponentePontuacao:
+        if not coordenacoes:
+            return ComponentePontuacao(base=0, tempo=0, extras=0, bonus=0, retorno=0)
+
+        coord_atual = next((c for c in coordenacoes if c.periodo.ativo), None)
+        if not coord_atual:
+            return ComponentePontuacao(base=0, tempo=0, extras=0, bonus=0, retorno=0)
+
+        base_map = {"CA": 200, "CAJ": 150, "CAJ-MP": 120, "CAM": 100}
+        tempo_max_map = {"CA": 100, "CAJ": 80, "CAJ-MP": 60, "CAM": 50}
+        bonus_atual_map = {"CA": 30, "CAJ": 20, "CAJ-MP": 15, "CAM": 10}
+
+        base = base_map.get(coord_atual.tipo, 0)
+        anos = coord_atual.periodo.anos_decorridos
+        tempo = min(int(anos * 10), tempo_max_map.get(coord_atual.tipo, 0))
+
+        extras = min(len(coord_atual.areas_adicionais) * 20, 100)
+        bonus = bonus_atual_map.get(coord_atual.tipo, 0) if coord_atual.periodo.ativo else 0
+        retorno = 20 if coord_atual.ja_coordenou_antes else 0
+
+        return ComponentePontuacao(base=base, tempo=tempo, extras=extras, bonus=bonus, retorno=retorno)
+
+    @staticmethod
+    def calcular_componente_b(coordenacoes: List[CoordenacaoPrograma]) -> ComponentePontuacao:
+        if not coordenacoes:
+            return ComponentePontuacao(base=0, tempo=0, extras=0, bonus=0)
+
+        base = 70
+        anos_totais = sum(c.periodo.anos_decorridos for c in coordenacoes)
+        tempo = min(int(anos_totais * 5), 50)
+
+        programas_distintos = len({c.id_programa for c in coordenacoes})
+        extras = min((programas_distintos - 1) * 20, 40)
+
+        coord_ativa = any(c.periodo.ativo for c in coordenacoes)
+        bonus = 20 if coord_ativa else 0
+
+        return ComponentePontuacao(base=base, tempo=tempo, extras=extras, bonus=bonus)
+
+    @staticmethod
+    def calcular_componente_c(consultoria: Consultoria) -> ComponentePontuacao:
+        if not consultoria:
+            return ComponentePontuacao(base=0, tempo=0, extras=0, bonus=0)
+
+        base = 150 if consultoria.eventos_recentes > 0 else 100
+
+        anos = (datetime.now() - consultoria.primeiro_evento).days / 365.25
+        tempo = min(int(anos * 5), 50)
+
+        extras_eventos = min(consultoria.total_eventos * 2, 20)
+        extras_responsavel = min(consultoria.vezes_responsavel * 5, 25)
+        extras_areas = min((len(consultoria.areas) - 1) * 10, 30) if len(consultoria.areas) > 1 else 0
+        extras = extras_eventos + extras_responsavel + extras_areas
+
+        bonus = 0
+
+        return ComponentePontuacao(base=base, tempo=tempo, extras=extras, bonus=bonus)
+
+    @staticmethod
+    def calcular_componente_d(premiacoes: List[Premiacao]) -> ComponentePontuacao:
+        if not premiacoes:
+            return ComponentePontuacao(base=0, tempo=0, extras=0, bonus=0)
+
+        total_pontos = sum(p.pontos for p in premiacoes)
+        total_pontos = min(total_pontos, 180)
+
+        return ComponentePontuacao(base=total_pontos, tempo=0, extras=0, bonus=0)
+
+    @classmethod
+    def calcular_pontuacao_completa(cls, consultor: Consultor) -> PontuacaoCompleta:
+        comp_a = cls.calcular_componente_a(consultor.coordenacoes_capes)
+        comp_b = cls.calcular_componente_b(consultor.coordenacoes_programas)
+        comp_c = cls.calcular_componente_c(consultor.consultoria)
+        comp_d = cls.calcular_componente_d(consultor.premiacoes)
+
+        return PontuacaoCompleta(
+            componente_a=comp_a, componente_b=comp_b, componente_c=comp_c, componente_d=comp_d
+        )

backend/src/domain/value_objects/periodo.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class Periodo:
+    inicio: datetime
+    fim: Optional[datetime] = None
+
+    @property
+    def ativo(self) -> bool:
+        return self.fim is None
+
+    @property
+    def anos_decorridos(self) -> float:
+        fim = self.fim if self.fim else datetime.now()
+        dias = (fim - self.inicio).days
+        return round(dias / 365.25, 1)
+
+    def __post_init__(self) -> None:
+        if self.fim and self.fim < self.inicio:
+            raise ValueError("Data de fim não pode ser anterior à data de início")

backend/src/domain/value_objects/pontuacao.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass
+from typing import Dict
+
+
+@dataclass(frozen=True)
+class ComponentePontuacao:
+    base: int
+    tempo: int
+    extras: int
+    bonus: int
+    retorno: int = 0
+
+    @property
+    def total(self) -> int:
+        return self.base + self.tempo + self.extras + self.bonus + self.retorno
+
+
+@dataclass(frozen=True)
+class PontuacaoCompleta:
+    componente_a: ComponentePontuacao
+    componente_b: ComponentePontuacao
+    componente_c: ComponentePontuacao
+    componente_d: ComponentePontuacao
+
+    @property
+    def total(self) -> int:
+        return (
+            self.componente_a.total
+            + self.componente_b.total
+            + self.componente_c.total
+            + self.componente_d.total
+        )
+
+    @property
+    def detalhamento(self) -> Dict[str, Dict[str, int]]:
+        return {
+            "componente_a": {
+                "base": self.componente_a.base,
+                "tempo": self.componente_a.tempo,
+                "extras": self.componente_a.extras,
+                "bonus": self.componente_a.bonus,
+                "retorno": self.componente_a.retorno,
+                "total": self.componente_a.total,
+            },
+            "componente_b": {
+                "base": self.componente_b.base,
+                "tempo": self.componente_b.tempo,
+                "extras": self.componente_b.extras,
+                "bonus": self.componente_b.bonus,
+                "total": self.componente_b.total,
+            },
+            "componente_c": {
+                "base": self.componente_c.base,
+                "tempo": self.componente_c.tempo,
+                "extras": self.componente_c.extras,
+                "bonus": self.componente_c.bonus,
+                "total": self.componente_c.total,
+            },
+            "componente_d": {
+                "base": self.componente_d.base,
+                "tempo": self.componente_d.tempo,
+                "extras": self.componente_d.extras,
+                "bonus": self.componente_d.bonus,
+                "total": self.componente_d.total,
+            },
+            "pontuacao_total": self.total,
+        }

backend/src/infrastructure/elasticsearch/client.py

@@ -0,0 +1,104 @@
+import httpx
+from typing import Optional, Dict, Any
+
+
+class ElasticsearchClient:
+    def __init__(self, url: str, index: str, user: str = "", password: str = ""):
+        self.url = url.rstrip("/")
+        self.index = index
+        self.user = user
+        self.password = password
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def connect(self) -> None:
+        auth = None
+        if self.user and self.password:
+            auth = httpx.BasicAuth(self.user, self.password)
+
+        self._client = httpx.AsyncClient(
+            auth=auth,
+            headers={
+                "Content-Type": "application/json",
+                "Accept": "application/json"
+            },
+            verify=False,
+            timeout=120.0
+        )
+
+    async def close(self) -> None:
+        if self._client:
+            await self._client.aclose()
+
+    @property
+    def client(self) -> httpx.AsyncClient:
+        if not self._client:
+            raise RuntimeError("Cliente Elasticsearch não conectado. Execute connect() primeiro.")
+        return self._client
+
+    async def buscar_por_id(self, id_pessoa: int) -> Optional[dict]:
+        try:
+            query = {
+                "query": {"term": {"id": id_pessoa}},
+                "_source": ["id", "dadosPessoais", "atuacoes"],
+                "size": 1,
+            }
+
+            response = await self.client.post(
+                f"{self.url}/{self.index}/_search",
+                json=query
+            )
+            response.raise_for_status()
+
+            data = response.json()
+            hits = data.get("hits", {}).get("hits", [])
+            return hits[0]["_source"] if hits else None
+        except Exception as e:
+            raise RuntimeError(f"Erro ao buscar consultor {id_pessoa}: {e}")
+
+    async def buscar_com_atuacoes(self, size: int = 1000, from_: int = 0) -> list:
+        try:
+            query = {
+                "query": {
+                    "nested": {
+                        "path": "atuacoes",
+                        "query": {"exists": {"field": "atuacoes.tipo"}}
+                    }
+                },
+                "_source": ["id", "dadosPessoais", "atuacoes"],
+                "size": size,
+                "from": from_,
+                "sort": [{"id": "asc"}],
+            }
+
+            response = await self.client.post(
+                f"{self.url}/{self.index}/_search",
+                json=query
+            )
+            response.raise_for_status()
+
+            data = response.json()
+            return [hit["_source"] for hit in data.get("hits", {}).get("hits", [])]
+        except Exception as e:
+            raise RuntimeError(f"Erro ao buscar consultores: {e}")
+
+    async def contar_com_atuacoes(self) -> int:
+        try:
+            query = {
+                "query": {
+                    "nested": {
+                        "path": "atuacoes",
+                        "query": {"exists": {"field": "atuacoes.tipo"}}
+                    }
+                }
+            }
+
+            response = await self.client.post(
+                f"{self.url}/{self.index}/_count",
+                json=query
+            )
+            response.raise_for_status()
+
+            data = response.json()
+            return data.get("count", 0)
+        except Exception as e:
+            raise RuntimeError(f"Erro ao contar consultores: {e}")

backend/src/infrastructure/oracle/client.py

@@ -0,0 +1,112 @@
+import cx_Oracle
+from typing import List, Dict, Any, Optional
+from contextlib import contextmanager
+
+
+class OracleClient:
+    def __init__(self, user: str, password: str, dsn: str):
+        self.user = user
+        self.password = password
+        self.dsn = dsn
+        self._pool: Optional[cx_Oracle.SessionPool] = None
+        self._connected = False
+
+    def connect(self) -> None:
+        try:
+            self._pool = cx_Oracle.SessionPool(
+                user=self.user,
+                password=self.password,
+                dsn=self.dsn,
+                min=2,
+                max=10,
+                increment=1,
+                encoding="UTF-8",
+            )
+            self._connected = True
+        except Exception as e:
+            print(f"AVISO Oracle: {e}")
+            self._connected = False
+
+    def close(self) -> None:
+        if self._pool:
+            try:
+                self._pool.close()
+            except:
+                pass
+
+    @property
+    def is_connected(self) -> bool:
+        return self._connected and self._pool is not None
+
+    @contextmanager
+    def get_connection(self):
+        if not self._pool:
+            raise RuntimeError("Pool Oracle não conectado. Execute connect() primeiro.")
+        conn = self._pool.acquire()
+        try:
+            yield conn
+        finally:
+            self._pool.release(conn)
+
+    def executar_query(self, query: str, params: Optional[dict] = None) -> List[Dict[str, Any]]:
+        if not self.is_connected:
+            return []
+        try:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+                cursor.execute(query, params or {})
+                columns = [col[0] for col in cursor.description]
+                rows = cursor.fetchall()
+                cursor.close()
+                return [dict(zip(columns, row)) for row in rows]
+        except Exception as e:
+            print(f"AVISO Oracle: falha ao executar query: {e}")
+            self._connected = False
+            return []
+
+    def buscar_coordenacoes_programa(self, id_pessoa: int) -> List[Dict[str, Any]]:
+        query = """
+            SELECT
+                c.ID_PESSOA,
+                c.ID_PROGRAMA_SNPG,
+                p.NM_PROGRAMA,
+                p.CD_PROGRAMA_PPG,
+                p.DS_CONCEITO AS NOTA_PPG,
+                p.NM_PROGRAMA_MODALIDADE,
+                aa.NM_AREA_AVALIACAO,
+                c.DT_INICIO_VIGENCIA,
+                c.DT_FIM_VIGENCIA
+            FROM SUCUPIRA_PAINEL.VM_COORDENADOR c
+            INNER JOIN SUCUPIRA_PAINEL.VM_PROGRAMA_SUCUPIRA p
+                ON c.ID_PROGRAMA_SNPG = p.ID_PROGRAMA
+            LEFT JOIN SUCUPIRA_PAINEL.VM_AREA_CONHECIMENTO ac
+                ON p.ID_AREA_CONHECIMENTO_ATUAL = ac.ID_AREA_CONHECIMENTO
+            LEFT JOIN SUCUPIRA_PAINEL.VM_AREA_AVALIACAO aa
+                ON ac.ID_AREA_AVALIACAO = aa.ID_AREA_AVALIACAO
+            WHERE c.ID_PESSOA = :id_pessoa
+            ORDER BY c.DT_INICIO_VIGENCIA DESC
+        """
+        return self.executar_query(query, {"id_pessoa": id_pessoa})
+
+    def buscar_todas_coordenacoes_programa(self) -> List[Dict[str, Any]]:
+        query = """
+            SELECT
+                c.ID_PESSOA,
+                c.ID_PROGRAMA_SNPG,
+                p.NM_PROGRAMA,
+                p.CD_PROGRAMA_PPG,
+                p.DS_CONCEITO AS NOTA_PPG,
+                p.NM_PROGRAMA_MODALIDADE,
+                aa.NM_AREA_AVALIACAO,
+                c.DT_INICIO_VIGENCIA,
+                c.DT_FIM_VIGENCIA
+            FROM SUCUPIRA_PAINEL.VM_COORDENADOR c
+            INNER JOIN SUCUPIRA_PAINEL.VM_PROGRAMA_SUCUPIRA p
+                ON c.ID_PROGRAMA_SNPG = p.ID_PROGRAMA
+            LEFT JOIN SUCUPIRA_PAINEL.VM_AREA_CONHECIMENTO ac
+                ON p.ID_AREA_CONHECIMENTO_ATUAL = ac.ID_AREA_CONHECIMENTO
+            LEFT JOIN SUCUPIRA_PAINEL.VM_AREA_AVALIACAO aa
+                ON ac.ID_AREA_AVALIACAO = aa.ID_AREA_AVALIACAO
+            ORDER BY c.ID_PESSOA, c.DT_INICIO_VIGENCIA DESC
+        """
+        return self.executar_query(query)

backend/src/infrastructure/repositories/consultor_repository_impl.py

@@ -0,0 +1,287 @@
+from typing import List, Optional, Dict, Any
+from datetime import datetime, timedelta
+from dateutil import parser as date_parser
+import asyncio
+
+from ...domain.entities.consultor import (
+    Consultor,
+    CoordenacaoCapes,
+    CoordenacaoPrograma,
+    Consultoria,
+    Premiacao,
+)
+from ...domain.repositories.consultor_repository import ConsultorRepository
+from ...domain.services.calculador_pontuacao import CalculadorPontuacao
+from ...domain.value_objects.periodo import Periodo
+from ..elasticsearch.client import ElasticsearchClient
+from ..oracle.client import OracleClient
+
+
+class RankingCache:
+    def __init__(self, ttl_seconds: int = 300):
+        self.ttl = ttl_seconds
+        self._cache: List[Consultor] = []
+        self._last_update: Optional[datetime] = None
+        self._loading = False
+        self._lock = asyncio.Lock()
+
+    def is_valid(self) -> bool:
+        if not self._cache or not self._last_update:
+            return False
+        return (datetime.now() - self._last_update).total_seconds() < self.ttl
+
+    def get(self) -> List[Consultor]:
+        return self._cache
+
+    def set(self, consultores: List[Consultor]) -> None:
+        self._cache = consultores
+        self._last_update = datetime.now()
+
+
+_ranking_cache = RankingCache(ttl_seconds=300)
+
+
+class ConsultorRepositoryImpl(ConsultorRepository):
+    def __init__(self, es_client: ElasticsearchClient, oracle_client: OracleClient):
+        self.es_client = es_client
+        self.oracle_client = oracle_client
+        self.calculador = CalculadorPontuacao()
+        self.es_disponivel = True
+
+    def _parse_date(self, date_str: Optional[str]) -> Optional[datetime]:
+        if not date_str:
+            return None
+        try:
+            return date_parser.parse(date_str, dayfirst=True)
+        except:
+            return None
+
+    def _extrair_consultoria(self, atuacoes: List[Dict[str, Any]]) -> Optional[Consultoria]:
+        consultorias = [
+            a for a in atuacoes if a.get("tipo") in ["Consultor", "Histórico de Consultoria"]
+        ]
+        if not consultorias:
+            return None
+
+        datas_inicio = [
+            self._parse_date(c.get("inicio"))
+            for c in consultorias
+        ]
+        datas_inicio = [d for d in datas_inicio if d]
+
+        datas_fim = [
+            self._parse_date(c.get("fim"))
+            for c in consultorias
+        ]
+        datas_fim = [d for d in datas_fim if d]
+
+        if not datas_inicio:
+            return None
+
+        limite_recente = datetime.now() - timedelta(days=730)
+        eventos_recentes = sum(1 for d in datas_fim if d >= limite_recente)
+
+        areas = list({c.get("areaAvaliacao", "N/A") for c in consultorias if c.get("areaAvaliacao")})
+
+        vezes_responsavel = sum(1 for c in consultorias if c.get("responsavel", False))
+
+        return Consultoria(
+            total_eventos=len(consultorias),
+            eventos_recentes=eventos_recentes,
+            primeiro_evento=min(datas_inicio),
+            ultimo_evento=max(datas_fim) if datas_fim else datetime.now(),
+            vezes_responsavel=vezes_responsavel,
+            areas=areas,
+        )
+
+    def _extrair_coordenacoes_capes(
+        self, atuacoes: List[Dict[str, Any]]
+    ) -> List[CoordenacaoCapes]:
+        coordenacoes = [
+            a
+            for a in atuacoes
+            if a.get("tipo")
+            in [
+                "Coordenação de Área de Avaliação",
+                "Histórico de Coordenação de Área de Avaliação",
+            ]
+        ]
+
+        resultado = []
+        for coord in coordenacoes:
+            inicio = self._parse_date(coord.get("inicio"))
+            if not inicio:
+                continue
+
+            tipo = self._inferir_tipo_coordenacao(coord)
+            fim = self._parse_date(coord.get("fim"))
+
+            resultado.append(
+                CoordenacaoCapes(
+                    tipo=tipo,
+                    area_avaliacao=coord.get("areaAvaliacao", "N/A"),
+                    periodo=Periodo(inicio=inicio, fim=fim),
+                    areas_adicionais=[],
+                    ja_coordenou_antes=False,
+                )
+            )
+
+        return resultado
+
+    def _inferir_tipo_coordenacao(self, coord: Dict[str, Any]) -> str:
+        nome = coord.get("nome", "").lower()
+        if "câmara" in nome or "camara" in nome:
+            return "CAM"
+        elif "mestrado profissional" in nome:
+            return "CAJ-MP"
+        elif "adjunta" in nome:
+            return "CAJ"
+        else:
+            return "CA"
+
+    def _extrair_premiacoes(self, atuacoes: List[Dict[str, Any]]) -> List[Premiacao]:
+        premiacoes_data = [
+            a
+            for a in atuacoes
+            if a.get("tipo")
+            in [
+                "Premiação Prêmio",
+                "Avaliação Prêmio",
+                "Inscrição Prêmio",
+            ]
+        ]
+
+        premiacoes = []
+        for prem in premiacoes_data:
+            pontos = self._calcular_pontos_premiacao(prem.get("tipo", ""))
+            inicio = self._parse_date(prem.get("inicio"))
+            ano = inicio.year if inicio else datetime.now().year
+
+            premiacoes.append(
+                Premiacao(
+                    tipo=prem.get("tipo", "N/A"),
+                    nome_premio=prem.get("descricao", "N/A"),
+                    ano=ano,
+                    pontos=pontos,
+                )
+            )
+
+        return premiacoes
+
+    def _calcular_pontos_premiacao(self, tipo: str) -> int:
+        mapa = {
+            "Premiação Prêmio": 60,
+            "Avaliação Prêmio": 40,
+            "Inscrição Prêmio": 20,
+        }
+        return mapa.get(tipo, 0)
+
+    async def _construir_consultor(self, doc: Dict[str, Any]) -> Consultor:
+        id_pessoa = doc["id"]
+        dados_pessoais = doc.get("dadosPessoais", {})
+        atuacoes = doc.get("atuacoes", [])
+
+        consultoria = self._extrair_consultoria(atuacoes)
+        coordenacoes_capes = self._extrair_coordenacoes_capes(atuacoes)
+        premiacoes = self._extrair_premiacoes(atuacoes)
+
+        coordenacoes_programas_raw = []
+        if self.oracle_client.is_connected:
+            try:
+                coordenacoes_programas_raw = self.oracle_client.buscar_coordenacoes_programa(id_pessoa)
+            except Exception as e:
+                print(f"AVISO Oracle: erro ao buscar coordenacoes do programa para {id_pessoa}: {e}")
+        coordenacoes_programas = [
+            CoordenacaoPrograma(
+                id_programa=c["ID_PROGRAMA_SNPG"],
+                nome_programa=c["NM_PROGRAMA"],
+                codigo_programa=c["CD_PROGRAMA_PPG"],
+                nota_ppg=c["NOTA_PPG"] or "N/A",
+                modalidade=c["NM_PROGRAMA_MODALIDADE"] or "N/A",
+                area_avaliacao=c["NM_AREA_AVALIACAO"] or "N/A",
+                periodo=Periodo(
+                    inicio=c["DT_INICIO_VIGENCIA"],
+                    fim=c["DT_FIM_VIGENCIA"],
+                ),
+            )
+            for c in coordenacoes_programas_raw
+        ]
+
+        consultor = Consultor(
+            id_pessoa=id_pessoa,
+            nome=dados_pessoais.get("nome", "N/A"),
+            cpf=dados_pessoais.get("cpf"),
+            coordenacoes_capes=coordenacoes_capes,
+            coordenacoes_programas=coordenacoes_programas,
+            consultoria=consultoria,
+            premiacoes=premiacoes,
+        )
+
+        consultor.pontuacao = self.calculador.calcular_pontuacao_completa(consultor)
+
+        return consultor
+
+    async def buscar_por_id(self, id_pessoa: int) -> Optional[Consultor]:
+        try:
+            doc = await self.es_client.buscar_por_id(id_pessoa)
+        except Exception as e:
+            print(f"AVISO Elasticsearch: falha ao buscar consultor {id_pessoa}: {e}")
+            return None
+        if not doc:
+            return None
+        return await self._construir_consultor(doc)
+
+    async def buscar_todos(
+        self, limite: int = 100, offset: int = 0, filtro_ativo: Optional[bool] = None
+    ) -> List[Consultor]:
+        if not self.es_client._client or getattr(self.es_client._client, "is_closed", False):
+            self.es_disponivel = False
+            return []
+        try:
+            docs = await self.es_client.buscar_com_atuacoes(size=limite, from_=offset)
+            self.es_disponivel = True
+        except Exception as e:
+            print(f"AVISO Elasticsearch: falha ao buscar consultores: {e}")
+            self.es_disponivel = False
+            return []
+        consultores = [await self._construir_consultor(doc) for doc in docs]
+
+        if filtro_ativo is not None:
+            consultores = [c for c in consultores if c.ativo == filtro_ativo]
+
+        return consultores
+
+    async def buscar_ranking(
+        self, limite: int = 100, componente: Optional[str] = None
+    ) -> List[Consultor]:
+        global _ranking_cache
+
+        if _ranking_cache.is_valid():
+            consultores_ordenados = _ranking_cache.get()
+            return consultores_ordenados[:limite]
+
+        async with _ranking_cache._lock:
+            if _ranking_cache.is_valid():
+                return _ranking_cache.get()[:limite]
+
+            tamanho_busca = 1000
+            consultores = await self.buscar_todos(limite=tamanho_busca)
+            consultores_ordenados = sorted(
+                consultores, key=lambda c: c.pontuacao_total, reverse=True
+            )
+            _ranking_cache.set(consultores_ordenados)
+
+        return consultores_ordenados[:limite]
+
+    async def contar_total(self, filtro_ativo: Optional[bool] = None) -> int:
+        if not self.es_disponivel:
+            return 0
+        if not self.es_client._client or getattr(self.es_client._client, "is_closed", False):
+            self.es_disponivel = False
+            return 0
+        try:
+            return await self.es_client.contar_com_atuacoes()
+        except Exception as e:
+            print(f"AVISO Elasticsearch: falha ao contar consultores: {e}")
+            self.es_disponivel = False
+            return 0

backend/src/interface/api/app.py

@@ -0,0 +1,50 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+
+from .routes import router
+from .config import settings
+from .dependencies import es_client, oracle_client
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await es_client.connect()
+    try:
+        oracle_client.connect()
+    except Exception as e:
+        print(f"AVISO: Oracle não conectou: {e}. Sistema rodando sem Coordenação PPG.")
+    yield
+    await es_client.close()
+    try:
+        oracle_client.close()
+    except:
+        pass
+
+
+app = FastAPI(
+    title="Ranking de Consultores CAPES",
+    description="Sistema de Ranking de Consultores CAPES baseado na Minuta Técnica",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins_list,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(router)
+
+
+@app.get("/")
+async def root():
+    return {
+        "message": "API Ranking CAPES",
+        "version": "1.0.0",
+        "docs": "/docs",
+        "health": "/api/v1/health",
+    }

backend/src/interface/api/config.py

@@ -0,0 +1,30 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing import List
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")
+
+    ES_URL: str = "http://localhost:9200"
+    ES_INDEX: str = "atuacapes__1763197236"
+    ES_USER: str = ""
+    ES_PASSWORD: str = ""
+
+    ORACLE_USER: str
+    ORACLE_PASSWORD: str
+    ORACLE_DSN: str
+
+    API_HOST: str = "0.0.0.0"
+    API_PORT: int = 8000
+    API_RELOAD: bool = True
+
+    CORS_ORIGINS: str = "http://localhost:3000,http://localhost:5173"
+
+    LOG_LEVEL: str = "INFO"
+
+    @property
+    def cors_origins_list(self) -> List[str]:
+        return [origin.strip() for origin in self.CORS_ORIGINS.split(",")]
+
+
+settings = Settings()

backend/src/interface/api/dependencies.py

@@ -0,0 +1,25 @@
+from ...infrastructure.elasticsearch.client import ElasticsearchClient
+from ...infrastructure.oracle.client import OracleClient
+from ...infrastructure.repositories.consultor_repository_impl import ConsultorRepositoryImpl
+from .config import settings
+
+
+es_client = ElasticsearchClient(
+    url=settings.ES_URL,
+    index=settings.ES_INDEX,
+    user=settings.ES_USER,
+    password=settings.ES_PASSWORD
+)
+
+oracle_client = OracleClient(
+    user=settings.ORACLE_USER, password=settings.ORACLE_PASSWORD, dsn=settings.ORACLE_DSN
+)
+
+_repository: ConsultorRepositoryImpl = None
+
+
+def get_repository() -> ConsultorRepositoryImpl:
+    global _repository
+    if _repository is None:
+        _repository = ConsultorRepositoryImpl(es_client=es_client, oracle_client=oracle_client)
+    return _repository

backend/src/interface/api/routes.py

@@ -0,0 +1,77 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from typing import Optional
+
+from ...application.use_cases.obter_ranking import ObterRankingUseCase
+from ...application.use_cases.obter_consultor import ObterConsultorUseCase
+from ...infrastructure.repositories.consultor_repository_impl import ConsultorRepositoryImpl
+from ..schemas.consultor_schema import (
+    RankingResponseSchema,
+    RankingDetalhadoResponseSchema,
+    ConsultorDetalhadoSchema,
+    ConsultorResumoSchema,
+)
+from .dependencies import get_repository
+
+router = APIRouter(prefix="/api/v1", tags=["ranking"])
+
+
+@router.get("/ranking", response_model=RankingResponseSchema)
+async def obter_ranking(
+    limite: int = Query(default=100, ge=1, le=1000, description="Limite de consultores"),
+    offset: int = Query(default=0, ge=0, description="Offset para paginação"),
+    componente: Optional[str] = Query(
+        default=None, description="Filtrar por componente (a, b, c, d)"
+    ),
+    repository: ConsultorRepositoryImpl = Depends(get_repository),
+):
+    use_case = ObterRankingUseCase(repository=repository)
+    consultores_dto = await use_case.executar(limite=limite, componente=componente)
+
+    total = await repository.contar_total()
+
+    consultores_schema = [
+        ConsultorResumoSchema(**vars(dto)) for dto in consultores_dto
+    ]
+
+    return RankingResponseSchema(
+        total=total, limite=limite, offset=offset, consultores=consultores_schema
+    )
+
+
+@router.get("/ranking/detalhado", response_model=RankingDetalhadoResponseSchema)
+async def obter_ranking_detalhado(
+    limite: int = Query(default=100, ge=1, le=1000, description="Limite de consultores"),
+    componente: Optional[str] = Query(
+        default=None, description="Filtrar por componente (a, b, c, d)"
+    ),
+    repository: ConsultorRepositoryImpl = Depends(get_repository),
+):
+    use_case = ObterRankingUseCase(repository=repository)
+    consultores_dto = await use_case.executar_detalhado(limite=limite, componente=componente)
+
+    total = await repository.contar_total()
+
+    consultores_schema = [
+        ConsultorDetalhadoSchema(**dto.to_dict()) for dto in consultores_dto
+    ]
+
+    return RankingDetalhadoResponseSchema(total=total, limite=limite, consultores=consultores_schema)
+
+
+@router.get("/consultor/{id_pessoa}", response_model=ConsultorDetalhadoSchema)
+async def obter_consultor(
+    id_pessoa: int,
+    repository: ConsultorRepositoryImpl = Depends(get_repository),
+):
+    use_case = ObterConsultorUseCase(repository=repository)
+    consultor = await use_case.executar(id_pessoa=id_pessoa)
+
+    if not consultor:
+        raise HTTPException(status_code=404, detail=f"Consultor {id_pessoa} não encontrado")
+
+    return consultor
+
+
+@router.get("/health")
+async def health_check():
+    return {"status": "ok", "message": "API Ranking CAPES funcionando"}

backend/src/interface/schemas/consultor_schema.py

@@ -0,0 +1,98 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+
+class PeriodoSchema(BaseModel):
+    inicio: str
+    fim: Optional[str] = None
+    ativo: bool
+    anos_decorridos: float
+
+
+class CoordenacaoCapesSchema(BaseModel):
+    tipo: str
+    area_avaliacao: str
+    periodo: PeriodoSchema
+    areas_adicionais: List[str]
+    ja_coordenou_antes: bool
+
+
+class CoordenacaoProgramaSchema(BaseModel):
+    id_programa: int
+    nome_programa: str
+    codigo_programa: str
+    nota_ppg: str
+    modalidade: str
+    area_avaliacao: str
+    periodo: PeriodoSchema
+
+
+class ConsultoriaSchema(BaseModel):
+    total_eventos: int
+    eventos_recentes: int
+    primeiro_evento: str
+    ultimo_evento: str
+    vezes_responsavel: int
+    areas: List[str]
+
+
+class PremiacaoSchema(BaseModel):
+    tipo: str
+    nome_premio: str
+    ano: int
+    pontos: int
+
+
+class ComponentePontuacaoSchema(BaseModel):
+    base: int
+    tempo: int
+    extras: int
+    bonus: int
+    retorno: int
+    total: int
+
+
+class PontuacaoCompletaSchema(BaseModel):
+    componente_a: ComponentePontuacaoSchema
+    componente_b: ComponentePontuacaoSchema
+    componente_c: ComponentePontuacaoSchema
+    componente_d: ComponentePontuacaoSchema
+    pontuacao_total: int
+
+
+class ConsultorResumoSchema(BaseModel):
+    id_pessoa: int
+    nome: str
+    anos_atuacao: float
+    ativo: bool
+    veterano: bool
+    pontuacao_total: int
+    rank: Optional[int] = None
+
+
+class ConsultorDetalhadoSchema(BaseModel):
+    id_pessoa: int
+    nome: str
+    cpf: Optional[str] = None
+    anos_atuacao: float
+    ativo: bool
+    veterano: bool
+    coordenacoes_capes: List[CoordenacaoCapesSchema]
+    coordenacoes_programas: List[CoordenacaoProgramaSchema]
+    consultoria: Optional[ConsultoriaSchema] = None
+    premiacoes: List[PremiacaoSchema]
+    pontuacao: PontuacaoCompletaSchema
+    rank: Optional[int] = None
+
+
+class RankingResponseSchema(BaseModel):
+    total: int
+    limite: int
+    offset: int
+    consultores: List[ConsultorResumoSchema]
+
+
+class RankingDetalhadoResponseSchema(BaseModel):
+    total: int
+    limite: int
+    consultores: List[ConsultorDetalhadoSchema]

backend/src/main.py

@@ -0,0 +1,12 @@
+import uvicorn
+from interface.api.app import app
+from interface.api.config import settings
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "interface.api.app:app",
+        host=settings.API_HOST,
+        port=settings.API_PORT,
+        reload=settings.API_RELOAD,
+        log_level=settings.LOG_LEVEL.lower(),
+    )