Upload 33 files

.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+.venv
+.vscode

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim-buster
+
+
+# Atualiza o sistema e instala dependências essenciais (exemplo: gcc para compilações nativas)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+ && rm -rf /var/lib/apt/lists/*
+
+# Define o diretório de trabalho
+WORKDIR /app
+
+# Copia o arquivo de requisitos e instala as dependências Python
+COPY requirements.txt .
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# Copia o restante do código da aplicação para a imagem
+COPY . .
+
+# Exponha a porta desejada (neste exemplo, 80)
+EXPOSE 80
+
+# Comando para iniciar a aplicação usando uvicorn
+CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "80"]

Dockerrun.aws.json

@@ -0,0 +1,14 @@
+{
+  "AWSEBDockerrunVersion": "1",
+  "Image": {
+    "Name": "python:3.11-slim-buster",
+    "Update": "true"
+  },
+  "Ports": [
+    {
+      "ContainerPort": 5000,
+      "HostPort": 80
+    }
+  ],
+  "Logging": "/var/log"
+}

README.md

@@ -1,10 +1,43 @@
----
-title: Jurisbot
-emoji: 🌍
-colorFrom: indigo
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Monitoramento de processos dos Tribunais de Justiça do Brasil. :robot:
+
+## Introdução
+Monitoramento de processos dos Tribunais de Justiça do Brasil - BETA
+
+
+## Respostas da API
+
+| HTTP CODE | `code` | Descrição |
+| --------- | ---------- | --------- |
+| `200` | 0 | Sucesso |
+| `422` | 7 | Não foi possível processar |
+| `502` | 5 | Bad Gateway |
+| `512` | 4 | Erro ao executar parse da pagina |
+
+
+
+### Para executar o bot manualmente, siga os passos abaixo:
+
+1. Baixe o repositorio:
+```
+git clone https://github.com/reissbruno/monitoramento-processual
+```
+2. Mude de diretorio:
+```
+cd monitoramento-processual
+```
+3. Instale as bibliotecas requeridas:
+```
+pip install -r requirements.txt
+```
+4. Execute o bot:
+```
+uvicorn server:app --host 0.0.0.0 
+```
+5. Abra o navegador a acesse a URL: http://localhost:8000/
+
+
+| ENV VAR | Descrição |
+| ------- | ---------- |
+| `BOT_NAME` | Nome do bot. Util caso houver mais de um container do mesmo bot rodando. (*default: transparencia-receita-fortaleza*) |
+| `LOG_LEVEL` | Nivel de log. Valores aceitos: (DEBUG, INFO, WARNING, ERROR - *default: INFO*) |
+| `TIMEOUT` | Total de **segundos** que o bot espera antes de encerrar a conexao com o site. (*default: 180*) |

data_delete/deletar_advogado.py

@@ -0,0 +1,57 @@
+# Manipulação do bando de dados de adição de nomes de advogados, deletar do banco de dados
+
+import sqlite3
+
+DATABASE_FILE = "monitoramento.db"
+
+def initialize_db():
+    conn = sqlite3.connect(DATABASE_FILE)
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS monitor_advogados (
+            nome_advogado TEXT PRIMARY KEY,
+            credencial TEXT NOT NULL,
+            uf TEXT NOT NULL
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+initialize_db()
+
+async def delete_advogado(nome_advogado: str, uf: str, credencial: str):
+    """
+    Deleta um nome de advogado do banco de dados de monitoramento após verificar a credencial.
+    
+    Args:
+        nome_advogado (str): Nome do advogado a ser removido.
+        uf (str): Unidade federativa relacionada.
+        credencial (str): Credencial do responsável pela requisição.
+    
+    Returns:
+        dict: Mensagem com o status da operação.
+    """
+    try:
+        conn = sqlite3.connect(DATABASE_FILE)
+        cursor = conn.cursor()
+        # Buscar registro pelo nome do advogado e uf
+        cursor.execute('''
+            SELECT credencial FROM monitor_advogados WHERE nome_advogado = ? AND uf = ?
+        ''', (nome_advogado, uf))
+        row = cursor.fetchone()
+        if not row:
+            conn.close()
+            return {"code": 404, "message": "Advogado não encontrado."}
+        stored_credencial = row[0]
+        if stored_credencial != credencial:
+            conn.close()
+            return {"code": 403, "message": "Credencial inválida. Não autorizado para deletar este advogado."}
+        # Credencial verificada; realiza a deleção
+        cursor.execute('''
+            DELETE FROM monitor_advogados WHERE nome_advogado = ? AND uf = ?
+        ''', (nome_advogado, uf))
+        conn.commit()
+        conn.close()
+        return {"code": 200, "message": "Advogado deletado com sucesso."}
+    except Exception as e:
+        return {"code": 500, "message": f"Erro ao deletar advogado: {str(e)}"}

data_delete/deletar_processo.py

@@ -0,0 +1,57 @@
+# Manipulação do bando de dados de adição de processos, deletar do banco de dados
+
+import sqlite3
+
+DATABASE_FILE = "monitoramento.db"
+
+def initialize_db():
+    conn = sqlite3.connect(DATABASE_FILE)
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS monitor_processos (
+            numero_processo TEXT PRIMARY KEY,
+            credencial TEXT NOT NULL,
+            uf TEXT NOT NULL
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+initialize_db()
+
+async def delete_processo(numero_processo: str, uf: str, credencial: str):
+    """
+    Deleta um número de processo do banco de dados de monitoramento após verificar a credencial.
+    
+    Args:
+        numero_processo (str): Número do processo a ser removido.
+        uf (str): Unidade federativa relacionada.
+        credencial (str): Credencial do responsável pela requisição.
+    
+    Returns:
+        dict: Mensagem com o status da operação.
+    """
+    try:
+        conn = sqlite3.connect(DATABASE_FILE)
+        cursor = conn.cursor()
+        # Buscar registro pelo número do processo e uf
+        cursor.execute('''
+            SELECT credencial FROM monitor_processos WHERE numero_processo = ? AND uf = ?
+        ''', (numero_processo, uf))
+        row = cursor.fetchone()
+        if not row:
+            conn.close()
+            return {"code": 404, "message": "Processo não encontrado."}
+        stored_credencial = row[0]
+        if stored_credencial != credencial:
+            conn.close()
+            return {"code": 403, "message": "Credencial inválida. Não autorizado para deletar este processo."}
+        # Credencial verificada; realiza a deleção
+        cursor.execute('''
+            DELETE FROM monitor_processos WHERE numero_processo = ? AND uf = ?
+        ''', (numero_processo, uf))
+        conn.commit()
+        conn.close()
+        return {"code": 200, "message": "Processo deletado com sucesso."}
+    except Exception as e:
+        return {"code": 500, "message": f"Erro ao deletar processo: {str(e)}"}

data_insert/inserir_advogado.py

@@ -0,0 +1,45 @@
+# Manipulacao de dados para o sistema de advogados, adicionar advogados
+
+import sqlite3
+
+DATABASE_FILE = "monitoramento.db"
+
+def initialize_db():
+    conn = sqlite3.connect(DATABASE_FILE)
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS monitor_advogados (
+            nome_advogado TEXT PRIMARY KEY,
+            credencial TEXT NOT NULL,
+            uf TEXT NOT NULL
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+initialize_db()
+
+async def insert_advogado(nome_advogado: str, uf: str, credencial: str):
+    """
+    Insere ou atualiza um nome de advogado no banco de dados de monitoramento.
+    
+    Args:
+        nome_advogado (str): Nome do advogado a ser monitorado.
+        uf (str): Unidade federativa relacionada.
+        credencial (str): Credencial do responsável pela requisição.
+    
+    Returns:
+        dict: Mensagem com o status da operação.
+    """
+    try:
+        conn = sqlite3.connect(DATABASE_FILE)
+        cursor = conn.cursor()
+        cursor.execute('''
+            INSERT OR REPLACE INTO monitor_advogados (nome_advogado, credencial, uf)
+            VALUES (?, ?, ?)
+        ''', (nome_advogado, credencial, uf))
+        conn.commit()
+        conn.close()
+        return {"code": 200, "message": "Advogado inserido com sucesso."}
+    except Exception as e:
+        return {"code": 500, "message": f"Erro ao inserir advogado: {str(e)}"}

data_insert/inserir_processo.py

@@ -0,0 +1,45 @@
+# Manipulação do banco de dados de adição de processos, adicionar do banco de dados
+
+import sqlite3
+
+DATABASE_FILE = "monitoramento.db"
+
+def initialize_db():
+    conn = sqlite3.connect(DATABASE_FILE)
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS monitor_processos (
+            numero_processo TEXT PRIMARY KEY,
+            credencial TEXT NOT NULL,
+            uf TEXT NOT NULL
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+initialize_db()
+
+async def insert_processo(numero_processo: str, uf: str, credencial: str):
+    """
+    Insere ou atualiza um número de processo no banco de dados de monitoramento.
+    
+    Args:
+        numero_processo (str): Número do processo a ser monitorado.
+        uf (str): Unidade federativa relacionada.
+        credencial (str): Credencial do responsável pela requisição.
+    
+    Returns:
+        dict: Mensagem com o status da operação.
+    """
+    try:
+        conn = sqlite3.connect(DATABASE_FILE)
+        cursor = conn.cursor()
+        cursor.execute('''
+            INSERT OR REPLACE INTO monitor_processos (numero_processo, credencial, uf)
+            VALUES (?, ?, ?)
+        ''', (numero_processo, credencial, uf))
+        conn.commit()
+        conn.close()
+        return {"code": 200, "message": "Processo inserido com sucesso."}
+    except Exception as e:
+        return {"code": 500, "message": f"Erro ao inserir processo: {str(e)}"}

requirements.txt

@@ -0,0 +1,68 @@
+aiohttp==3.9.5
+aiosignal==1.3.2
+annotated-types==0.6.0
+anyio==4.8.0
+attrs==23.2.0
+bcrypt==3.2.0
+beautifulsoup4==4.13.3
+boto3==1.37.17
+botocore==1.37.17
+capmonstercloudclient==1.6.0
+certifi==2025.1.31
+cffi==1.17.1
+charset-normalizer==3.4.1
+click==8.1.8
+colorama==0.4.6
+coloredlogs==15.0.1
+ddddocr==1.5.6
+dnspython==2.7.0
+ecdsa==0.19.1
+email_validator==2.2.0
+fastapi==0.110.1
+filelock==3.17.0
+flatbuffers==25.2.10
+frozenlist==1.5.0
+fsspec==2025.2.0
+gradio_client==1.7.1
+greenlet==3.1.1
+gunicorn==23.0.0
+h11==0.14.0
+httpcore==1.0.7
+httpx==0.28.1
+huggingface-hub==0.29.1
+humanfriendly==10.0
+idna==3.10
+jmespath==1.0.1
+mpmath==1.3.0
+multidict==6.0.5
+onnxruntime==1.20.1
+opencv-python-headless==4.11.0.86
+packaging==24.2
+passlib==1.7.4
+pillow==11.1.0
+propcache==0.3.0
+protobuf==5.29.3
+psycopg2==2.9.10
+pyasn1==0.4.8
+pycparser==2.22
+pydantic==2.1.1
+pydantic_core==2.4.0
+pyreadline3==3.5.4
+python-dateutil==2.9.0.post0
+python-jose==3.4.0
+PyYAML==6.0.2
+requests==2.32.3
+rsa==4.9
+s3transfer==0.11.4
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.6
+SQLAlchemy==2.0.39
+starlette==0.37.2
+sympy==1.13.3
+tqdm==4.67.1
+typing_extensions==4.12.2
+urllib3==2.3.0
+uvicorn==0.29.0
+websockets==14.2
+yarl==1.18.3

server.py

@@ -0,0 +1,310 @@
+import logging
+from os import environ as env
+from fastapi.logger import logger as fastapi_logger
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from fastapi import FastAPI, Query, Depends, HTTPException, status, Request
+from fastapi.middleware.cors import CORSMiddleware
+
+# Local imports
+from src import models, consulta
+from src.monitoramento_processual.task_dispatcher import process_dispatcher
+from data_delete.deletar_advogado import delete_advogado
+from data_delete.deletar_processo import delete_processo
+from data_insert.inserir_processo import insert_processo
+from data_insert.inserir_advogado import insert_advogado
+from user_autentication.user_hash import verificar_senha, criar_token, gerar_hash, verificar_token
+from src.tj_research import tj_researcher
+from src.models import UserUpdateUsername, UserUpdatePassword
+from user_configuration.user_config import trocar_username, trocar_senha
+
+
+import sqlite3
+from pydantic import BaseModel
+
+# Logger setup
+msg_frt = "[%(asctime)s] %(levelname)s [%(name)s] - %(message)s"
+time_frt = "%Y-%m-%d %H:%M:%S"
+formatter = logging.Formatter(msg_frt, time_frt)
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
+LOG_LEVEL = env.get('LOG_LEVEL', default='INFO')
+fastapi_logger.addHandler(handler)
+fastapi_logger.setLevel(LOG_LEVEL)
+
+logger_name = env.get('BOT_NAME', default='Monitoramento Processual')
+fastapi_logger.name = logger_name
+
+# Dependencia para verificar token
+def get_current_user(request: Request):
+    auth_header = request.headers.get('Authorization')
+    fastapi_logger.info(f"Authorization Header: {auth_header}")
+
+    if auth_header is None or not auth_header.startswith("Bearer "):
+        fastapi_logger.error("Authorization header ausente ou mal formado!")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Token ausente"
+        )
+
+    token = auth_header.split(" ")[1]
+    fastapi_logger.info(f"Token extraído: {token}")
+
+    try:
+        username = verificar_token(token)
+        fastapi_logger.info(f"Usuário autenticado: {username}")
+        return username
+    except Exception as e:
+        fastapi_logger.error(f"Erro ao verificar token: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Token inválido ou expirado"
+        )
+
+# API description e metadata
+desc = '<a href="https://esaj.tjsp.jus.br/cpopg/search.do?conversationId=&cbPesquisa=NMADVOGADO&dadosConsulta.valorConsulta=&cdForo=-1" target="_blank">FONTE</a>'
+
+tags_metadata = [
+    {
+        'name': 'monitoramento-processual',
+        'description': 'Consulta processual nos Tribunais de Justiça no Brasil',
+    }
+]
+
+responses = {
+    407: {'model': models.ResponseError, 'description': 'Proxy Authentication Required'},
+    422: {'model': models.ResponseError, 'description': 'Unprocessable Entity'},
+    500: {'model': models.ResponseError, 'description': 'Erro interno no servidor'},
+    502: {'model': models.ResponseError, 'description': 'Bad Gateway'},
+    504: {'model': models.ResponseError, 'description': 'Conexao com o site excedeu tempo limite'},
+    509: {'model': models.ResponseError, 'description': 'Nao foi possivel resolver o captcha'},
+    512: {'model': models.ResponseError, 'description': 'Erro ao executar parse da pagina'},
+    513: {'model': models.ResponseError, 'description': 'Argumentos invalidos'}
+}
+
+app = FastAPI(
+    title='REST API - Monitoramento processual nos Tribunais de Justiça do Brasil', 
+    description=desc, 
+    debug=False, 
+    openapi_tags=tags_metadata,
+    docs_url='/docs'
+)
+
+app.add_middleware(
+    CORSMiddleware, 
+    allow_origins=['*'],
+    allow_credentials=True,
+    allow_methods=['*'],
+    allow_headers=['*'])
+
+uf = Query(
+    description='UF referente ao advogado ou processo a ser consultado',
+    example='SP',
+    enum=['AC', 'AL', 'AP', 'AM', 'BA', 'CE', 'DF', 'ES', 'GO', 'MA', 'MT', 'MS', 'MG',
+          'PA', 'PB', 'PR', 'PE', 'PI', 'RJ', 'RN', 'RS', 'RO', 'RR', 'SC', 'SP',
+          'SE', 'TO'],
+    default=None,
+)
+
+parametro_dummy = Query(
+    ..., 
+    description='parametro dummy',
+)
+
+nome_advogado = Query(
+    ...,
+    description='Nome do advogado a ser inserido',
+    example='Nome do Advogado'
+)
+
+numero_processo = Query(
+    ...,
+    description='Número do processo a ser monitorado o andamento',
+    example='0000000-00.0000.0.00.0000'
+)
+
+
+# Informacoes do usuario
+@app.get("/api/monitoramento-processual/usuario-info", tags=["monitoramento-processual"])
+def get_user_info(username: str):
+    conn = sqlite3.connect("monitoramento.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT nome, sobrenome FROM usuarios WHERE username = ?", (username,))
+    row = cursor.fetchone()
+    conn.close()
+
+    if row:
+        return {"nome": row[0], "sobrenome": row[1]}
+    raise HTTPException(status_code=404, detail="Usuário não encontrado")
+
+# Criação do banco de dados e tabelas
+@app.get("/api/monitoramento-processual/consulta/listar-advogados", tags=["monitoramento-processual"])
+def listar_advogados(current_user: str = Depends(get_current_user)):
+    conn = sqlite3.connect("monitoramento.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT nome_advogado, uf FROM monitor_advogados WHERE credencial = ?", (current_user,))
+    rows = cursor.fetchall()
+    conn.close()
+    return [{"nome_advogado": row[0], "uf": row[1]} for row in rows]
+
+@app.get("/api/monitoramento-processual/consulta/listar-processos", tags=["monitoramento-processual"])
+def listar_processos(current_user: str = Depends(get_current_user)):
+    conn = sqlite3.connect("monitoramento.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT numero_processo, uf FROM monitor_processos WHERE credencial = ?", (current_user,))
+    rows = cursor.fetchall()
+    conn.close()
+    return [{"numero_processo": row[0], "uf": row[1]} for row in rows]
+
+@app.get("/api/monitoramento-processual/consulta/listar-tarefas", tags=["monitoramento-processual"])
+def listar_tarefas(current_user: str = Depends(get_current_user)):
+    conn = sqlite3.connect("monitoramento.db")
+    cursor = conn.cursor()
+    cursor.execute("""
+        SELECT tipo, nome, uf, monitoramento, intervalo, unidade
+        FROM tarefas
+        WHERE username = ?
+    """, (current_user,))
+    rows = cursor.fetchall()
+    conn.close()
+    return [{
+        "tipo": row[0],
+        "nome": row[1],
+        "uf": row[2],
+        "monitoramento": row[3],
+        "intervalo": row[4],
+        "unidade": row[5]
+    } for row in rows]
+
+# Retorna o HTML para o frontend
+@app.get("/", tags=["monitoramento-processual"])
+def serve_index():
+    return FileResponse("static/index.html")
+
+@app.get("/dashboard", tags=["monitoramento-processual"])
+def serve_dashboard():
+    return FileResponse("static/dashboard.html")
+
+@app.get("/tasks", tags=["monitoramento-processual"])
+def serve_tasks():
+    return FileResponse("static/tasks.html")
+
+@app.get("/consulta", tags=["monitoramento-processual"])
+def serve_consulta():
+    return FileResponse("static/consulta.html")
+
+@app.get("/user_config", tags=["monitoramento-processual"])
+def serve_user_config():
+    return FileResponse("static/user_config.html")
+
+
+# Endpoints para consulta de processos e advogados
+
+@app.delete("/api/monitoramento-processual/consulta/deletar-processo", tags=["monitoramento-processual"], responses=responses)
+async def delete_processos(numero_processo: str = numero_processo, uf: str = uf, current_user: str = Depends(get_current_user)):
+    return await delete_processo(numero_processo, uf, current_user)
+
+@app.delete("/api/monitoramento-processual/consulta/deletar-advogado", tags=["monitoramento-processual"], responses=responses)
+async def delete_advogado_endpoint(nome_advogado: str = nome_advogado, uf: str = uf, current_user: str = Depends(get_current_user)):
+    return await delete_advogado(nome_advogado, uf, current_user)
+
+@app.post("/api/monitoramento-processual/consulta/inserir-processo", tags=["monitoramento-processual"], responses=responses)
+async def insert_processos_endpoint(numero_processo: str = numero_processo, uf: str = uf, current_user: str = Depends(get_current_user)):
+    return await insert_processo(numero_processo, uf, current_user)
+
+@app.post("/api/monitoramento-processual/consulta/inserir-advogado", tags=["monitoramento-processual"], responses=responses)
+async def insert_advogado_endpoint(nome_advogado: str = nome_advogado, uf: str = uf, current_user: str = Depends(get_current_user)):
+    return await insert_advogado(nome_advogado, uf, current_user)
+
+@app.post("/api/monitoramento-processual/consulta/inserir-tarefa", tags=["monitoramento-processual"], responses=responses)
+async def insert_tarefa(
+    tipo: str = Query(..., description="Tipo (advogado ou processo)"),
+    nome: str = Query(..., description="Nome do advogado ou número do processo"),
+    uf: str = Query(..., description="UF"),
+    monitoramento: str = Query(..., description="Deseja monitoramento? (sim ou nao)"),
+    intervalo: int = Query(..., description="Intervalo do monitoramento"),
+    unidade: str = Query(..., description="Unidade do intervalo (minutos, horas ou dias)"),
+    current_user: str = Depends(get_current_user)
+):
+    conn = sqlite3.connect("monitoramento.db")
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS tarefas (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT NOT NULL,
+            tipo TEXT NOT NULL,
+            nome TEXT NOT NULL,
+            uf TEXT NOT NULL,
+            monitoramento TEXT NOT NULL,
+            intervalo INTEGER NOT NULL,
+            unidade TEXT NOT NULL
+        )
+    ''')
+    cursor.execute('''
+        INSERT INTO tarefas (username, tipo, nome, uf, monitoramento, intervalo, unidade)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+    ''', (current_user, tipo, nome, uf, monitoramento, intervalo, unidade))
+    conn.commit()
+    conn.close()
+    return {"message": "Tarefa cadastrada com sucesso"}
+
+
+@app.get("/api/monitoramento-processual/consulta/tjs", tags=["monitoramento-processual"], responses=responses)
+async def get_consulta_tj(
+    uf: str = Query(..., description="Unidade Federativa"),
+    process_number: str = Query(..., description="Número do processo"),
+    current_user: str = Depends(get_current_user)
+):
+    result = await tj_researcher.research_process(uf=uf, process_number=process_number)
+    return result
+
+@app.get("/api/monitoramento-processual/monitoramento/uf", tags=["monitoramento-processual"], responses=responses)
+async def get_consulta_tjsc(uf: str = uf, current_user: str = Depends(get_current_user)):
+    return await process_dispatcher(current_user, uf)
+
+app.mount("/static", StaticFiles(directory="static", html=True), name="static")
+
+class LoginData(BaseModel):
+    username: str
+    senha: str
+
+@app.post("/api/monitoramento-processual/login", tags=["monitoramento-processual"])
+def login(data: LoginData):
+    conn = sqlite3.connect("monitoramento.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT senha_hash FROM usuarios WHERE username = ?", (data.username,))
+    row = cursor.fetchone()
+    conn.close()
+    if not row or not verificar_senha(data.senha, row[0]):
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Usuário ou senha inválidos")
+    token = criar_token({"sub": data.username})
+    return {"access_token": token, "token_type": "bearer"}
+
+@app.post("/api/monitoramento-processual/cadastrar-usuario", tags=["monitoramento-processual"])
+def cadastrar_usuario(data: models.UserCreate):
+    conn = sqlite3.connect("monitoramento.db")
+    cursor = conn.cursor()
+    senha_hash = gerar_hash(data.senha)
+    try:
+        cursor.execute(
+            "INSERT INTO usuarios (username, senha_hash, nome, sobrenome, email) VALUES (?, ?, ?, ?, ?)",
+            (data.username, senha_hash, data.nome, data.sobrenome, data.email)
+        )
+        conn.commit()
+        return {"message": "Usuário cadastrado com sucesso."}
+    except sqlite3.IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Usuário já existe."
+        )
+    finally:
+        conn.close()
+
+
+@app.put("/api/monitoramento-processual/config/usuario/username", tags=["monitoramento-processual"])
+async def atualizar_username(data: UserUpdateUsername, current_user: str = Depends(get_current_user)):
+    return await trocar_username(current_user, data.new_username)
+
+@app.put("/api/monitoramento-processual/config/usuario/password", tags=["monitoramento-processual"])
+async def atualizar_senha(data: UserUpdatePassword, current_user: str = Depends(get_current_user)):
+    return await trocar_senha(current_user, data.current_password, data.new_password)

src/consulta.py

@@ -0,0 +1,203 @@
+import sqlite3
+from os import environ as env
+from datetime import datetime, timedelta
+import aiohttp
+from bs4 import BeautifulSoup
+from fastapi.logger import logger
+from fastapi.responses import JSONResponse
+from fastapi import status
+
+# Local imports
+from src.models import *
+from src.processamento_tjdf import tjdf_request
+from src.enviador_de_email import enviar_email
+from utils.util import get_headers
+
+# Captura variáveis de ambiente e cria constantes
+TIMEOUT = env.get('TIMEOUT', default=180)
+
+def get_advogados_by_credencial(credencial: str, uf: str) -> list:
+    """
+    Consulta o banco de dados monitoramento.db para obter os nomes dos advogados
+    cadastrados para a credencial e UF informadas.
+    
+    Returns:
+        list: Lista de nomes de advogados (no formato armazenado, por exemplo, com '+' para espaços, se necessário)
+    """
+    try:
+        conn = sqlite3.connect("monitoramento.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT nome_advogado FROM monitor_advogados WHERE credencial = ? AND uf = ?", (credencial, uf))
+        rows = cursor.fetchall()
+        conn.close()
+        return [row[0] for row in rows]
+    except Exception as e:
+        logger.error(f"Erro ao buscar advogados no banco: {str(e)}")
+        return []
+
+async def processamento_lista_soup(soup, nome_advogado, grau):
+    """ Extrai processos do HTML do TJSP usando BeautifulSoup """
+    try:
+        processos = []
+        # Itera sobre todos os processos listados
+        for processo in soup.select("li div.row.unj-ai-c"):
+            # Número do processo
+            link_element = processo.select_one("a.linkProcesso")
+            numero_processo = link_element.text.strip() if link_element else ''
+            link_processo = f"https://esaj.tjsp.jus.br{link_element['href']}" if link_element else ''
+
+            # Nome do Advogado
+            nome_advogado_element = processo.select_one(".unj-base-alt")
+            nome_advogado = nome_advogado_element.text.strip() if nome_advogado_element else nome_advogado.replace("+", " ")
+
+            # Tipo de Processo (classe do processo)
+            tipo_processo_element = processo.select_one(".classeProcesso")
+            tipo_processo = tipo_processo_element.text.strip() if tipo_processo_element else ''
+
+            # Assunto do Processo
+            assunto_processo_element = processo.select_one(".assuntoPrincipalProcesso, .assuntoProcesso")
+            assunto_processo = assunto_processo_element.text.strip() if assunto_processo_element else ''
+
+            # Data de recebimento
+            data_recebimento_element = processo.select_one(".dataLocalDistribuicaoProcesso, .dataLocalDistribuicao")
+            data_recebimento = data_recebimento_element.text.strip() if data_recebimento_element else ''
+
+            # Foro do Processo
+            foro_element = processo.find_previous("h2", class_="unj-subtitle")
+            foro_processo = foro_element.text.strip() if foro_element else ''
+
+            processos.append({
+                "nome_advogado": nome_advogado,
+                "numero_processo": numero_processo,
+                "tipo_processo": tipo_processo,
+                "assunto_processo": assunto_processo,
+                "data_recebimento": data_recebimento,
+                "link_processo": link_processo,
+                "foro_processo": foro_processo,
+                "grau_processo": grau
+            })
+
+        return processos
+
+    except Exception as e:
+        logger.error(f"Erro ao processar HTML: {str(e)}")
+        return []
+
+#-----------------------------------------------------------------------------------------------------
+async def fetch(parametro_dummy: str, credencial_usuario: str, uf: str):
+    """
+    Executa uma consulta genérica (dummy) de monitoramento processual.
+    
+    Ao invés de usar uma lista fixa de nomes, obtém a lista de advogados cadastrados no banco
+    para o usuário identificado pela credencial e UF informados.
+    
+    Args:
+        parametro_dummy (str): Parâmetro dummy que ativa a consulta.
+        credencial_usuario (str): Credencial do usuário solicitante.
+        uf (str): Unidade Federativa relacionada à consulta.
+        
+    Returns:
+        dict: Resultado da consulta processual.
+    """
+    logger.info(f"Consulta dummy iniciada para credencial: {credencial_usuario}")
+    
+    # Configura os timeouts
+    timeout = aiohttp.ClientTimeout(total=TIMEOUT)
+    session = aiohttp.ClientSession(timeout=timeout)
+    
+    # Configurando headers
+    session.headers.update(get_headers())
+    
+    # Obtém a lista de advogados cadastrados para o usuário
+    lista_nomes = get_advogados_by_credencial(credencial_usuario, uf)
+    if not lista_nomes:
+        await session.close()
+        return JSONResponse(
+            status_code=status.HTTP_404_NOT_FOUND,
+            content={"code": 404, "message": "Nenhum advogado cadastrado para essa credencial.", "datetime": datetime.now().isoformat()}
+        )
+    
+    try:
+        resultados = []
+        
+        for nome_advogado in lista_nomes:
+            # URLs de consulta para TJSP (primeira e segunda instância)
+            url_primeiro_grau = f"https://esaj.tjsp.jus.br/cpopg/search.do?conversationId=&cbPesquisa=NMADVOGADO&dadosConsulta.valorConsulta={nome_advogado}&cdForo=-1"
+            url_segundo_grau = f"https://esaj.tjsp.jus.br/cposg/search.do?conversationId=&paginaConsulta=0&cbPesquisa=NMADVOGADO&dePesquisa={nome_advogado}&localPesquisa.cdLocal=-1"
+
+            logger.info(f"Consultando processos para: {nome_advogado.replace('+', ' ')}")
+
+            # Primeira Instância
+            async with session.get(url_primeiro_grau, ssl=False, allow_redirects=True) as resp1:
+                html_primeiro_grau = await resp1.read()
+                soup_primeiro_grau = BeautifulSoup(html_primeiro_grau, "html.parser")
+                if "Não existem informações disponíveis para os parâmetros informados." not in soup_primeiro_grau.text:
+                    processos_primeiro_grau = await processamento_lista_soup(soup_primeiro_grau, nome_advogado.replace('+', ' '), "1º Grau")
+                    resultados.extend(processos_primeiro_grau)
+
+            # Segunda Instância
+            async with session.get(url_segundo_grau, ssl=False, allow_redirects=True) as resp2:
+                html_segundo_grau = await resp2.read()
+                soup_segundo_grau = BeautifulSoup(html_segundo_grau, "html.parser")
+                if "Não existem informações disponíveis para os parâmetros informados." not in soup_segundo_grau.text:
+                    processos_segundo_grau = await processamento_lista_soup(soup_segundo_grau, nome_advogado.replace('+', ' '), "2º Grau")
+                    resultados.extend(processos_segundo_grau)
+            
+            # Requisição ao TJDF
+            processos_tjdf = await tjdf_request(nome_advogado)
+            resultados.extend(processos_tjdf)
+
+        processos_48h = []
+        now = datetime.now()
+
+        for proc in resultados:
+            try:
+                data_str = proc['data_recebimento'].split(" - ")[0].strip()
+                dt = datetime.strptime(data_str, "%d/%m/%Y")
+                
+                # Filtra processos dos últimos 2 dias
+                if dt >= now - timedelta(days=2):
+                    proc['data_recebimento_dt'] = dt
+                    processos_48h.append(proc)
+            except Exception as e:
+                logger.error(f"Erro ao converter data: {str(e)}")
+                continue
+
+        processos_48h.sort(key=lambda x: x['data_recebimento_dt'], reverse=True)
+
+        for proc in processos_48h:
+            proc.pop('data_recebimento_dt', None)
+
+        # Envia o e-mail mesmo se nenhum processo for encontrado
+        try:
+            sucesso = await enviar_email(processos_48h)
+            if sucesso:
+                logger.info("E-mail enviado com sucesso!")
+            else:
+                logger.error("Falha ao enviar o e-mail.")
+        except Exception as e:
+            logger.exception(f"Erro inesperado ao enviar e-mail: {str(e)}")
+
+        result = {
+            'code': 200,
+            'message': 'OK',
+            'datetime': datetime.now().isoformat(),
+            'results': processos_48h
+        }
+
+    except aiohttp.ClientError as e:
+        logger.exception('Erro durante a consulta API')
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={'code': 500, 'message': f'INTERNAL_SERVER_ERROR: {str(e)}'}
+        )
+    except Exception as e:
+        logger.exception('Erro inesperado durante a consulta API')
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={'code': 500, 'message': f'INTERNAL_SERVER_ERROR: {str(e)}'}
+        )
+
+    logger.info(f"Consulta finalizada: {result}")
+    await session.close()
+    return result

src/enviador_de_email.py

@@ -0,0 +1,186 @@
+import smtplib
+import email.message
+import asyncio
+from fastapi.logger import logger
+
+async def enviar_email_movimentacao(ultima_movimentacao_texto, numero_processo):
+    """
+    Envia um e-mail informando o andamento de um processo específico, 
+    mesmo quando não houver atualização.
+
+    O parâmetro 'ultima_movimentacao_texto' pode vir em dois formatos, por exemplo:
+      1) "87 15/09/2023 18:46:46 Despacho https://eprocwebcon.tjsc.jus.br/consulta1g/controlador.php?acao=acessar_documento_publico&doc=...&hash=..."
+      2) "88 15/09/2023 18:46:47 Expedida/certificada a intimação eletrônicaRefer.  ao Evento 87(EXEQUENTE -  MUNICÍPIO DE TIMBÓ/SC)Prazo: 30 dias Status:FECHADOData inicial da contagem do prazo: 26/09/2023 00:00:00Data final: 14/11/2023 23:59:59"
+
+    Se o texto estiver vazio ou conter apenas espaços, o e-mail informará que não houve atualização.
+
+    Caso haja conteúdo, a função realiza o parsing dos três primeiros tokens (código, data e hora)
+    e utiliza o restante como descrição. Se houver uma substring iniciada por "http", ela será extraída como link do documento.
+
+    Args:
+        ultima_movimentacao_texto (str): Texto com os detalhes do último andamento.
+        numero_processo (str): Número do processo.
+
+    Returns:
+        bool: True se o e-mail for enviado com sucesso, False caso contrário.
+    """
+    if not ultima_movimentacao_texto or not ultima_movimentacao_texto.strip():
+        corpo_email = f"""
+        <html>
+        <body>
+            <h2>Andamento do Processo</h2>
+            <p><strong>Número do Processo:</strong> {numero_processo}</p>
+            <p>Não houve atualização no andamento deste processo.</p>
+            <p>Atenciosamente,<br>Equipe LexAutomation</p>
+        </body>
+        </html>
+        """
+    else:
+        try:
+            # Tenta extrair um link, se houver
+            pos_link = ultima_movimentacao_texto.find("http")
+            if pos_link != -1:
+                link = ultima_movimentacao_texto[pos_link:].strip()
+                texto_sem_link = ultima_movimentacao_texto[:pos_link].strip()
+                partes = texto_sem_link.split(maxsplit=3)
+            else:
+                link = ""
+                partes = ultima_movimentacao_texto.split(maxsplit=3)
+            
+            if len(partes) < 4:
+                codigo_evento = partes[0] if len(partes) > 0 else "N/A"
+                data_evento = partes[1] if len(partes) > 1 else "N/A"
+                hora_evento = partes[2] if len(partes) > 2 else "N/A"
+                descricao_evento = ""
+            else:
+                codigo_evento, data_evento, hora_evento, descricao_evento = partes
+        except Exception as e:
+            logger.error(f"Erro ao realizar o parsing da movimentação: {e}")
+            codigo_evento = "N/A"
+            data_evento = "N/A"
+            hora_evento = "N/A"
+            descricao_evento = ultima_movimentacao_texto
+            link = ""
+        
+        documento = f'<a href="{link}">Acessar Documento</a>' if link else "Nenhum documento"
+        corpo_email = f"""
+        <html>
+        <body>
+            <h2>Atualização de Andamento do Processo</h2>
+            <p><strong>Número do Processo:</strong> {numero_processo}</p>
+            <p><strong>Código do Evento:</strong> {codigo_evento}</p>
+            <p><strong>Data e Hora:</strong> {data_evento} {hora_evento}</p>
+            <p><strong>Descrição:</strong> {descricao_evento}</p>
+            <p><strong>Documento:</strong> {documento}</p>
+            <p>Atenciosamente,<br>Equipe LexAutomation</p>
+        </body>
+        </html>
+        """
+
+    # Configuração do e-mail
+    remetente = "processosatualizacao@gmail.com"
+    destinatarios = [
+        "brun.rreis@gmail.com",
+        "fontaosthefano@gmail.com"
+    ]
+    senha = "awbz sfki ndtd afwb"  
+
+    def enviar():
+        try:
+            with smtplib.SMTP("smtp.gmail.com", 587) as server:
+                server.starttls()
+                server.login(remetente, senha)
+                for destinatario in destinatarios:
+                    msg = email.message.Message()  
+                    msg['Subject'] = f"Atualização de Andamento - Processo {numero_processo}"
+                    msg['From'] = remetente
+                    msg['To'] = destinatario
+                    msg.add_header('Content-Type', 'text/html')
+                    msg.set_payload(corpo_email)
+                    
+                    server.sendmail(remetente, destinatario, msg.as_string().encode("utf-8"))
+            logger.info("E-mail enviado com sucesso!")
+            return True  
+        except Exception as e:
+            logger.info(f"Erro ao enviar e-mail: {str(e)}")
+            return False  
+
+    return await asyncio.to_thread(enviar)
+
+
+async def enviar_email(resultados):
+    """ Envia um e-mail com a lista de processos atualizada """
+
+    # Configuração do e-mail
+    remetente = "processosatualizacao@gmail.com"
+    destinatarios = [
+        "brun.rreis@gmail.com",
+        "fontaosthefano@gmail.com"
+    ]
+    senha = "awbz sfki ndtd afwb"  
+
+    
+    if not resultados:
+        corpo_email = """
+        <html>
+        <body>
+            <h3>🤖 Monitoramento de Processos</h3>
+            <p>Olá,</p>
+            <p>Informamos que, no período de tempo selecionado, não foram identificados novos processos.</p>
+            <p>Atenciosamente,<br>
+            Equipe LexAutomation</p>
+        </body>
+        </html>
+        """
+    else:
+        corpo_email = """
+        <html>
+        <body>
+            <h2>🤖 Monitoramento de Processos</h2>
+            <h3>Atualização diária de processos</h3>
+            <ul>
+        """
+        for processo in resultados:
+            corpo_email += f"""
+                <li>
+                    <b>Nome do Advogado:</b> {processo['nome_advogado']}<br>
+                    <b>Número do Processo:</b> {processo['numero_processo']}<br>
+                    <b>Tipo do Processo:</b> {processo['tipo_processo']}<br>
+                    <b>Assunto:</b> {processo['assunto_processo']}<br>
+                    <b>Data de Recebimento:</b> {processo.get('data_recebimento', 'N/A')}<br>
+                    <b>Foro:</b> {processo['foro_processo']}<br>
+                    <b>Grau:</b> {processo['grau_processo']}<br>
+                    <b>Link:</b> <a href="{processo['link_processo']}">Acessar Processo</a><br>
+                </li>
+                <hr>
+            """
+        corpo_email += """
+            </ul>
+            <p>Atenciosamente,<br>
+            Equipe LexAutomation</p>
+        </body>
+        </html>
+        """
+
+
+    def enviar():
+        try:
+            with smtplib.SMTP("smtp.gmail.com", 587) as server:
+                server.starttls()
+                server.login(remetente, senha)
+                for destinatario in destinatarios:
+                    msg = email.message.Message()  
+                    msg['Subject'] = "Atualização diária de processos"
+                    msg['From'] = remetente
+                    msg['To'] = destinatario
+                    msg.add_header('Content-Type', 'text/html')
+                    msg.set_payload(corpo_email)
+                    
+                    server.sendmail(remetente, destinatario, msg.as_string().encode("utf-8"))
+            logger.info("E-mail enviado com sucesso!")
+            return True  
+        except Exception as e:
+            logger.info(f"Erro ao enviar e-mail: {str(e)}")
+            return False  
+
+    return await asyncio.to_thread(enviar)

src/models.py

@@ -0,0 +1,64 @@
+from pydantic import BaseModel, EmailStr
+from typing import Optional, List, Union
+
+# -------------------- TJPR --------------------
+class MovimentacaoTJPR(BaseModel):
+    seq: Optional[str] = ""
+    data: Optional[str] = ""
+    evento: Optional[str] = ""
+    movimentado_por: Optional[str] = ""
+
+class ResponseSiteTJPR(BaseModel):
+    movimentacoes: List[MovimentacaoTJPR] = []
+
+# -------------------- TJSP --------------------
+class MovimentacaoTJSP(BaseModel):
+    data_hora: str = ""
+    descricao: str = ""
+    documentos: str = ""
+
+class ResponseSiteTJSP(BaseModel):
+    movimentacoes: List[MovimentacaoTJSP] = []
+
+# -------------------- TJSC --------------------
+class MovimentacaoTJSC(BaseModel):
+    evento: str = ""
+    data_hora: str = ""
+    descricao: str = ""
+    documentos: str = ""
+
+class ResponseSiteTJSC(BaseModel):
+    movimentacoes: List[MovimentacaoTJSC] = []
+
+# -------------------- Union Simplificada --------------------
+Movimentacao = Union[MovimentacaoTJPR, MovimentacaoTJSP, MovimentacaoTJSC]
+
+# -------------------- Genéricos --------------------
+class UserUpdateUsername(BaseModel):
+    new_username: str
+
+class UserUpdatePassword(BaseModel):
+    current_password: str
+    new_password: str
+    
+class Telemetria(BaseModel):
+    tentativas: int
+    tempo_total: float = 0.0
+    bytes_enviados: int = 0
+    captchas_resolvidos: int = 0
+
+class ResponseError(BaseModel):
+    code: int
+    message: str
+
+class ResponseDefault(BaseModel):
+    code: int
+    message: str
+    datetime: str
+
+class UserCreate(BaseModel):
+    username: str
+    senha: str
+    nome: str
+    sobrenome: str
+    email: EmailStr

src/monitoramento_processual/monitoramento_tjpr.py

@@ -0,0 +1,336 @@
+import time
+import re
+import logging
+from datetime import datetime
+from os import environ as env
+
+import httpx
+from fastapi import status
+from fastapi.responses import JSONResponse
+from bs4 import BeautifulSoup
+from gradio_client import Client, handle_file
+import ddddocr  
+
+# Imports locais
+from src.models import ResponseSiteTJPR, Telemetria, MovimentacaoTJPR
+import src.models as models
+
+# Configuração do Logger
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S"
+)
+logger = logging.getLogger(__name__)
+
+# Constantes
+TEMPO_LIMITE = int(env.get('TEMPO_LIMITE', 180))
+TENTATIVAS_MAXIMAS_CAPTCHA = int(env.get('TENTATIVAS_MAXIMAS_CAPTCHA', 30))
+TENTATIVAS_MAXIMAS_RECURSIVAS = int(env.get('TENTATIVAS_MAXIMAS_RECURSIVAS', 30))
+BASE_URL = "https://consulta.tjpr.jus.br"
+
+
+async def extrair_movimentacoes(soup: BeautifulSoup) -> ResponseSiteTJPR:
+    movimentacoes = []
+    tabelas = soup.find_all("table", {"class": "resultTable"})
+    for tabela in tabelas:
+        linhas = tabela.find_all("tr")[1:]
+        for linha in linhas:
+            colunas = linha.find_all("td")
+            if len(colunas) >= 5:
+                seq = colunas[1].get_text(strip=True)
+                data = colunas[2].get_text(strip=True)
+                evento = " ".join(colunas[3].stripped_strings)
+
+                nome = colunas[4].contents[2].strip() if len(colunas[4].contents) > 2 else ""
+                cargo_tag = colunas[4].find("b")
+                cargo = cargo_tag.get_text(strip=True) if cargo_tag else ""
+
+                if not nome:
+                    nome_tag = colunas[4].find(text=True, recursive=False)
+                    nome = nome_tag.strip() if nome_tag else ""
+
+                movimentado_por = f"{nome} - {cargo}" if nome and cargo else (nome or cargo or colunas[4].get_text(strip=True))
+                movimentacoes.append(MovimentacaoTJPR(seq=seq, data=data, evento=evento, movimentado_por=movimentado_por))
+    
+    return ResponseSiteTJPR(movimentacoes=movimentacoes)
+
+
+
+def formatar_numero_processo(numero_processo: str) -> str:
+    """
+    Remove quaisquer caracteres não numéricos do número do processo.
+    """
+    return ''.join(filter(str.isdigit, numero_processo))
+
+
+async def obter_soup(client: httpx.AsyncClient, url: str) -> BeautifulSoup:
+    """Realiza GET na URL e retorna o BeautifulSoup do conteúdo."""
+    resposta = await client.get(url)
+    if resposta.status_code != 200:
+        raise Exception(f"Falha ao acessar {url}: {resposta.status_code}")
+    return BeautifulSoup(resposta.text, "html.parser")
+
+
+async def resolver_captcha(client: httpx.AsyncClient, url_captcha: str, telemetria: Telemetria) -> str:
+    """Faz download e resolve o CAPTCHA utilizando API e fallback OCR."""
+    resposta_captcha = await client.get(url_captcha)
+    if resposta_captcha.status_code != 200:
+        raise Exception(f"Falha ao baixar o CAPTCHA: {resposta_captcha.status_code}")
+    bytes_imagem = resposta_captcha.content
+    with open("captcha_temporario.png", "wb") as arquivo:
+        arquivo.write(bytes_imagem)
+
+    cliente_api = Client("Nischay103/captcha_recognition")
+    telemetria.captchas_resolvidos += 1
+    try:
+        resultado_ocr = cliente_api.predict(
+            input=handle_file("captcha_temporario.png"),
+            api_name="/predict"
+        ).strip()
+        logger.info(f"CAPTCHA reconhecido pela API: {resultado_ocr}")
+    except Exception as e:
+        logger.error(f"Erro ao usar a API captcha_recognition: {e}")
+        try:
+            motor_ocr = ddddocr.DdddOcr()
+            resultado_ocr = motor_ocr.classification(bytes_imagem)
+            logger.info(f"CAPTCHA reconhecido pelo ddddocr (fallback): {resultado_ocr}")
+        except Exception as fallback_e:
+            logger.error(f"Erro no fallback ddddocr: {fallback_e}")
+            raise
+    return resultado_ocr
+
+
+def extrair_url_token(script_tags: list, pattern_str: str) -> str:
+    """Extrai uma URL/token utilizando regex a partir dos scripts."""
+    pattern = re.compile(pattern_str)
+    for script in script_tags:
+        if script.string:
+            match = pattern.search(script.string)
+            if match:
+                token = match.group(1)
+                if "_tj=" in token:
+                    return token
+    return None
+
+
+async def fetch(numero_processo: str, telemetria: Telemetria) -> dict:
+    """
+    Função principal que realiza a consulta. Mantém a estrutura original de tentativas
+    e de recursão para resolver o CAPTCHA, e retorna um dicionário com os resultados e telemetria.
+    """
+    inicio_tempo = time.time()
+    if not numero_processo or not isinstance(numero_processo, str):
+        telemetria.tempo_total = round(time.time() - inicio_tempo, 2)
+        return JSONResponse(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            content={'code': 2, 'message': 'ERRO_ENTIDADE_NAO_PROCESSAVEL'}
+        )
+
+    if telemetria.tentativas >= TENTATIVAS_MAXIMAS_RECURSIVAS:
+        logger.error("Número máximo de tentativas recursivas atingido.")
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={'code': 3, 'message': 'ERRO_SERVIDOR_INTERNO'}
+        )
+
+    logger.info(f'Função fetch() iniciou. Processo: {numero_processo} - Tentativa {telemetria.tentativas}')
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5',
+        'Referer': f'{BASE_URL}/projudi_consulta/'
+    }
+
+    results = {}
+    try:
+        async with httpx.AsyncClient(timeout=TEMPO_LIMITE, headers=headers, follow_redirects=True) as client:
+            # 1º GET: Página inicial
+            url_pagina_consulta = f"{BASE_URL}/projudi_consulta/"
+            resposta_inicial = await client.get(url_pagina_consulta)
+            telemetria.bytes_enviados += len(resposta_inicial.text.encode('utf-8'))
+            if resposta_inicial.status_code != 200:
+                raise Exception(f"Falha ao acessar a página inicial: {resposta_inicial.status_code}")
+
+            soup_inicial = BeautifulSoup(resposta_inicial.text, "html.parser")
+            frame = soup_inicial.find("frame", {"id": "mainFrame"})
+            if not (frame and frame.get("src")):
+                raise Exception("Frame com id='mainFrame' não encontrado ou sem atributo 'src'")
+            src = re.sub(r';jsessionid=[^?]*', '', frame["src"])
+            url_final = f"{BASE_URL}{src}"
+            logger.info(f"URL do mainFrame: {url_final}")
+
+            # 2º GET: cabecalho.jsp
+            url_cabecalho = f"{BASE_URL}/projudi_consulta/cabecalho.jsp"
+            resposta_cabecalho = await client.get(url_cabecalho)
+            telemetria.bytes_enviados += len(resposta_cabecalho.text.encode('utf-8'))
+            if resposta_cabecalho.status_code != 200:
+                raise Exception(f"Falha ao acessar cabecalho.jsp: {resposta_cabecalho.status_code}")
+
+            client.headers.update({'Referer': url_final})
+
+            # 3º GET: Página de consulta pública (mainFrame)
+            resposta_consulta = await client.get(url_final)
+            telemetria.bytes_enviados += len(resposta_consulta.text.encode('utf-8'))
+            if resposta_consulta.status_code != 200:
+                raise Exception(f"Falha ao acessar a página de consulta: {resposta_consulta.status_code}")
+
+            soup_consulta = BeautifulSoup(resposta_consulta.text, "html.parser")
+            # Captura da imagem do CAPTCHA
+            captcha_img_elem = soup_consulta.find("img", {"id": "captchaImage"})
+            if not (captcha_img_elem and captcha_img_elem.get("src")):
+                raise Exception("Imagem do CAPTCHA não encontrada ou sem atributo 'src'!")
+            url_captcha = f"{BASE_URL}{captcha_img_elem['src']}"
+            logger.info(f"URL do CAPTCHA: {url_captcha}")
+
+            # Captura URL AJAX para Autocomplete e demais chamadas
+            script_tags = soup_consulta.find_all("script", {"type": "text/javascript"})
+            url_ajax = extrair_url_token(script_tags, r'AjaxJspTag\.Select\(\s*"([^"]+)"')
+            if not url_ajax:
+                raise Exception("URL com '_tj=' não encontrada no HTML")
+            if "codComarca" not in url_ajax:
+                url_ajax += ("&" if "?" in url_ajax else "?") + "codComarca=-1"
+            url_final_ajax = url_ajax if url_ajax.startswith("http") else f"{BASE_URL}{url_ajax}"
+            resp_ajax = await client.get(url_final_ajax)
+            telemetria.bytes_enviados += len(resp_ajax.text.encode('utf-8'))
+            if resp_ajax.status_code != 200:
+                raise Exception(f"Falha ao acessar a URL AJAX: {resp_ajax.status_code}")
+
+            url_autocomplete = extrair_url_token(script_tags, r'AjaxJspTag\.Autocomplete\(\s*"([^"]+)"')
+            if not url_autocomplete:
+                raise Exception("URL do Autocomplete com '_tj=' não encontrada no HTML")
+            segunda_url_ajax = url_autocomplete if url_autocomplete.startswith("http") else f"{BASE_URL}{url_autocomplete}"
+
+            payload_segundo_ajax = {
+                "numeroProcesso": numero_processo,
+                "flagNumeroUnico": "true",
+                "opcaoConsulta": "1",
+                "_": ""
+            }
+            ajax_headers = {
+                "x-prototype-version": "1.5.1.1",
+                "x-requested-with": "XMLHttpRequest"
+            }
+            resposta_ajax = await client.post(segunda_url_ajax, data=payload_segundo_ajax, headers=ajax_headers)
+            telemetria.bytes_enviados += len(resposta_ajax.text.encode('utf-8'))
+            if resposta_ajax.status_code != 200:
+                raise Exception(f"Falha ao acessar a URL AJAX: {resposta_ajax.status_code}")
+
+            # Resolver CAPTCHA
+            resultado_ocr = await resolver_captcha(client, url_captcha, telemetria)
+
+            # Extrair URL de submissão do formulário a partir dos scripts
+            script_tags_full = soup_consulta.find_all("script")
+            token_url = None
+            for script in script_tags_full:
+                if script.string:
+                    m = re.search(r'document\.getElementById\(["\']buscaProcessoForm["\']\)\.action\s*=\s*["\']([^"\']+)["\']', script.string)
+                    if m:
+                        relative_url = m.group(1)
+                        token_url = relative_url if relative_url.startswith("http") else f"{BASE_URL}{relative_url}"
+                        break
+            if not token_url:
+                raise Exception("URL de submissão do formulário não encontrada.")
+
+            # Submissão final do formulário
+            final_headers = {
+                "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+                "Origin": BASE_URL,
+                "Referer": url_final,
+                "x-prototype-version": "1.5.1.1",
+                "x-requested-with": "XMLHttpRequest"
+            }
+            payload_form = {
+                "processoPageSize": "20",
+                "processoPageNumber": "1",
+                "processoSortColumn": "p.numeroUnico",
+                "processoSortOrder": "asc",
+                "codVaraEscolhida": "",
+                "opcaoConsultaPublica": "1",
+                "flagNumeroUnico": "true",
+                "numeroProcesso": numero_processo,
+                "codComarca": "-1",
+                "tipoCompetencia": "",
+                "turma": "",
+                "nomeParte": "",
+                "cpfCnpj": "",
+                "loginAdvogado": "",
+                "nomeAdvogado": "",
+                "oab": "",
+                "oabComplemento": "N",
+                "oabUF": "PR",
+                "answer": resultado_ocr
+            }
+            resposta_formulario = await client.post(token_url, data=payload_form, headers=final_headers)
+            telemetria.bytes_enviados += len(resposta_formulario.text.encode('utf-8'))
+            if resposta_formulario.status_code != 200:
+                raise Exception(f"Falha ao submeter o formulário: {resposta_formulario.status_code}")
+
+            # Chamada AJAX final para obter os resultados
+            soup_final = BeautifulSoup(resposta_formulario.text, "html.parser")
+            script_tags_final = soup_final.find_all("script", {"type": "text/javascript"})
+            token_ajax = extrair_url_token(script_tags_final, r'AjaxJspTag\.HtmlContent\(\s*"([^"]+)"')
+            if not token_ajax:
+                raise Exception("Token/URL da chamada AjaxJspTag.HtmlContent não encontrado.")
+            final_url_ajax = token_ajax if token_ajax.startswith("http") else f"{BASE_URL}{token_ajax}"
+            payload_ultimo = {"dummy": "true", "_": ""}
+            ultimo_post = await client.post(final_url_ajax, data=payload_ultimo, headers=final_headers)
+            telemetria.bytes_enviados += len(ultimo_post.text.encode('utf-8'))
+            if ultimo_post.status_code != 200:
+                raise Exception(f"Falha ao acessar a URL final: {ultimo_post.status_code}")
+
+            soup_1 = BeautifulSoup(ultimo_post.text, "html.parser")
+            # Verifica se há link para mais movimentações
+            if "Clique para visualizar as movimentações mais antigas" in soup_1.text:
+                script_tags_extra = soup_1.find_all("script", {"type": "text/javascript"})
+                url_desejada = extrair_url_token(script_tags_extra, r'AjaxJspTag\.HtmlContent\(\s*"([^"]+)"')
+                if url_desejada:
+                    full_url = f"{BASE_URL}{url_desejada}"
+                    resp_final = await client.post(full_url, data=payload_ultimo, headers=final_headers)
+                    telemetria.bytes_enviados += len(resp_final.text.encode('utf-8'))
+                    if resp_final.status_code != 200:
+                        raise Exception(f"Falha ao acessar a URL final: {resp_final.status_code}")
+                    soup_2 = BeautifulSoup(resp_final.text, "html.parser")
+                    html_combinado = str(soup_1) + str(soup_2)
+                    soup_combinado = BeautifulSoup(html_combinado, "html.parser")
+                else:
+                    soup_combinado = soup_1
+            else:
+                soup_combinado = soup_1
+
+            movimentacoes = await extrair_movimentacoes(soup_combinado)
+            results = {
+                "code": 200,
+                "message": "SUCESSO",
+                "datetime": datetime.now().isoformat(),
+                "results": movimentacoes.model_dump(),
+                "telemetria": telemetria.model_dump()
+            }
+
+    except Exception as e:
+        logger.error(f"Erro durante a consulta: {e}")
+        if telemetria.tentativas < TENTATIVAS_MAXIMAS_CAPTCHA:
+            logger.info("Tentando resolver o CAPTCHA novamente...")
+            telemetria.tentativas += 1
+            return await fetch(numero_processo, telemetria)
+        else:
+            results = {
+                'code': 4,
+                'message': 'ERRO_SERVIDOR_INTERNO',
+                'telemetria': telemetria
+            }
+    finally:
+        telemetria.tempo_total = round(time.time() - inicio_tempo, 2)
+        if isinstance(results, dict):
+            if "telemetria" not in results:
+                results["telemetria"] = telemetria.dict()
+        return results
+    
+
+async def research_process(numero_processo: str):
+    """
+    Interface externa para pesquisa de processo no TJPR.
+    """
+    str_time = time.time()
+    telem = models.Telemetria(tentativas=1, tempo_total=str_time)
+    return await fetch(numero_processo, telemetria=telem)

src/monitoramento_processual/monitoramento_tjsc.py

@@ -0,0 +1,347 @@
+from os import environ as env
+from datetime import datetime
+import time
+import os
+import certifi
+from urllib.parse import urljoin
+
+from fastapi.logger import logger
+from fastapi.responses import JSONResponse
+import base64
+from fastapi import status
+from bs4 import BeautifulSoup
+import httpx
+from capmonstercloudclient import CapMonsterClient, ClientOptions
+from capmonstercloudclient.requests import TurnstileProxylessRequest
+
+# Local imports
+from src.models import ResponseSiteTJSC, Telemetria, MovimentacaoTJSC
+import src.models as models
+
+
+# Captura variáveis de ambiente e cria constantes
+TEMPO_LIMITE = int(env.get('TEMPO_LIMITE', 180))
+TENTATIVAS_MAXIMAS_CAPTCHA = int(env.get('TENTATIVAS_MAXIMAS_CAPTCHA', 5))  
+TENTATIVAS_MAXIMAS_RECURSIVAS = int(env.get('TENTATIVAS_MAXIMAS_RECURSIVAS', 5))  
+CAPMONSTER_API_KEY = env.get('CAPMONSTER_API_KEY', "51391018af62079a8f9fc3233de7617b")
+
+
+# Função para formatar o número do processo
+def formatar_numero_processo(numero_processo):
+    return ''.join(filter(str.isdigit, numero_processo))
+
+
+# Função para capturar todas as movimentações da página HTML
+async def capturar_todas_movimentacoes(pagina_html: str) -> list[MovimentacaoTJSC]:
+    soup = BeautifulSoup(pagina_html, "html.parser")
+    tabelas = soup.find_all('table', class_='infraTable')
+
+    tabela_eventos = None
+    for tabela in tabelas:
+        cabecalhos = [th.get_text(strip=True) for th in tabela.find_all('th')]
+        if 'Evento' in cabecalhos and 'Data/Hora' in cabecalhos and 'Descrição' in cabecalhos and 'Documentos' in cabecalhos:
+            tabela_eventos = tabela
+            break
+
+    if not tabela_eventos:
+        logger.warning("Tabela de eventos não encontrada na página HTML.")
+        return []
+
+    movimentacoes = []
+    linhas = tabela_eventos.find_all('tr', class_=['infraTrClara', 'infraTrEscura'])
+
+    if not linhas:
+        logger.warning("Nenhuma linha de eventos encontrada na tabela.")
+        return []
+
+    for linha in linhas:
+        celulas = linha.find_all('td')
+        if len(celulas) >= 4:
+            evento = celulas[0].get_text(strip=True)
+            data_hora = celulas[1].get_text(strip=True)
+            descricao = celulas[2].get_text(strip=True)
+
+            link_documento_completo = ""
+            link_documento_elemento = celulas[3].find('a', class_='infraLinkDocumento')
+            if link_documento_elemento and 'href' in link_documento_elemento.attrs:
+                base_url = "https://eprocwebcon.tjsc.jus.br/consulta1g/"
+                link_documento = link_documento_elemento['href']
+                link_documento_completo = urljoin(base_url, link_documento)
+
+            movimentacao = MovimentacaoTJSC(
+                evento=evento,
+                data_hora=data_hora,
+                descricao=descricao,
+                documentos=link_documento_completo
+            )
+            movimentacoes.append(movimentacao)
+            logger.debug(f"Movimentação capturada: {movimentacao.model_dump()}")
+
+    return movimentacoes
+
+
+# Resolve o CAPTCHA Turnstile usando o CapMonster
+async def resolver_captcha_turnstile(website_url: str, site_key: str, page_data: str) -> dict:
+    os.environ['SSL_CERT_FILE'] = certifi.where()
+
+    client_options = ClientOptions(api_key=CAPMONSTER_API_KEY)
+    cap_monster_client = CapMonsterClient(options=client_options)
+
+    turnstile_request = TurnstileProxylessRequest(
+        websiteURL=website_url,
+        websiteKey=site_key,
+        pageData=page_data
+    )
+
+    solution = await cap_monster_client.solve_captcha(turnstile_request)
+    return solution
+
+
+# Função principal para acessar o site do TJSC e capturar as movimentações com httpx
+async def fetch(numero_processo: str, telemetria: Telemetria) -> dict:
+    """
+    Função que acessa a página inicial do TJSC com httpx, resolve o CAPTCHA Turnstile com retry,
+    envia o formulário via POST e captura as movimentações do processo. Retorna os
+    resultados como objetos Movimentacao, incluindo links de documentos e a duração
+    da requisição.
+    """
+
+    # Validação inicial
+    if not numero_processo or not isinstance(numero_processo, str):
+        return JSONResponse(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            content={
+                'code': 2,
+                'message': 'ERRO_ENTIDADE_NAO_PROCESSAVEL'
+            }
+        )
+
+    if telemetria.tentativas >= TENTATIVAS_MAXIMAS_RECURSIVAS:
+        logger.error("Número máximo de tentativas recursivas atingido.")
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={
+                'code': 3,
+                'message': 'ERRO_SERVIDOR_INTERNO'
+            }
+        )
+
+    logger.info(f'Função fetch() iniciou. Processo: {numero_processo} - Tentativa {telemetria.tentativas}')
+
+    headers = {
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+        "Host": "eprocwebcon.tjsc.jus.br",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36 Edg/134.0.0.0"
+    }
+
+    # Criar cliente HTTP para manter cookies e sessão
+    client = httpx.Client(timeout=TEMPO_LIMITE, verify=False, headers=headers)
+    results = None
+
+    try:
+        # Acessar a página inicial
+        url_inicial = "https://eprocwebcon.tjsc.jus.br/consulta1g/externo_controlador.php?acao=processo_consulta_publica"
+        response = client.get(url_inicial, follow_redirects=False)
+        content_length = response.headers.get('Content-Length')
+        if content_length:
+            telemetria.bytes_enviados += int(content_length)
+        else:
+            telemetria.bytes_enviados += len(response.content)
+
+        if response.status_code != 200:
+            raise Exception(f"Falha ao acessar a página inicial: {response.status_code}")
+        
+        page_data = base64.b64encode(response.text.encode('utf-8')).decode('utf-8')
+
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        # Verificar se o CAPTCHA Turnstile está presente
+        turnstile_div = soup.find("div", class_="cf-turnstile")
+        if not turnstile_div:
+            raise Exception("Elemento do CAPTCHA Turnstile não encontrado na página inicial.")
+
+        site_key = turnstile_div.get("data-sitekey")
+        if not site_key:
+            raise Exception("Chave do site (data-sitekey) não encontrada no elemento Turnstile.")
+
+        # Resolver o CAPTCHA Turnstile
+        telemetria.captchas_resolvidos += 1
+        solution = await resolver_captcha_turnstile(url_inicial, site_key, page_data)
+
+        token = solution.get("token")
+
+        form_data = {
+            "hdnInfraTipPagina": "1",
+            "sbmNovo": "Consultar",
+            "txtNumProcesso": numero_processo,
+            "txtNumChave": "",
+            "txtNumChaveDocumentos": "",
+            "txtParte": "",
+            "chkFonetica": "N",
+            "chkFoneticaS": "",
+            "txtStrOAB": "",
+            "rdTipo": "CPF",
+            "cf-turnstile-response": token, 
+            "hdnInfraCaptcha": "0"
+            "hdnInfraSelecoes" "Infra"
+        }
+        url_post = "https://eprocwebcon.tjsc.jus.br/consulta1g/externo_controlador.php?acao=processo_consulta_publica"
+
+        response_post = client.post(url_post, data=form_data, follow_redirects=False)
+        content_length = response_post.headers.get('Content-Length')
+        if content_length:
+            telemetria.bytes_enviados += int(content_length)
+        else:
+            telemetria.bytes_enviados += len(response_post.content)
+
+        pagina_html = response_post.text
+        if "Processo não encontrado" in pagina_html:
+            results = {
+                'code': 200,
+                'message': 'Processo não encontrado',
+                'datetime': datetime.now().strftime('%d-%m-%Y %H:%M:%S'),
+                'telemetria': telemetria
+            }
+            return results
+        else:
+            # Verificar redirecionamento
+            if response_post.status_code == 302:
+                redirect_url = response_post.headers["Location"]
+                logger.info(f"URL de redirecionamento: {redirect_url}")
+            else:
+                raise Exception(f"Requisição POST não resultou em redirecionamento: {response_post.status_code}")
+
+            # Acessar a página de detalhes
+            redirect_url = urljoin(url_inicial, redirect_url)
+            response_get = client.get(redirect_url, follow_redirects=True)
+            content_length = response_get.headers.get('Content-Length')
+            if content_length:
+                telemetria.bytes_enviados += int(content_length)
+            else:
+                telemetria.bytes_enviados += len(response_get.content)
+
+            if response_get.status_code != 200:
+                raise Exception(f"Falha ao acessar a página de detalhes: {response_get.status_code}")
+
+            # Capturar as movimentações
+            pagina_html = response_get.text
+            if "Processo não encontrado" in pagina_html:
+                results = {
+                    'code': 200,
+                    'message': 'Processo não encontrado',
+                    'datetime': datetime.now().strftime('%d-%m-%Y %H:%M:%S'),
+                    'telemetria': telemetria
+                }
+                return results
+            else:
+                # Verificar redirecionamento
+                if response_post.status_code == 302:
+                    redirect_url = response_post.headers["Location"]
+                    logger.info(f"URL de redirecionamento: {redirect_url}")
+                else:
+                    raise Exception(f"Requisição POST não resultou em redirecionamento: {response_post.status_code}")
+
+                # Acessar a página de detalhes
+                redirect_url = urljoin(url_inicial, redirect_url)
+                response_get = client.get(redirect_url, follow_redirects=True)
+                content_length = response_get.headers.get('Content-Length')
+                if content_length:
+                    telemetria.bytes_enviados += int(content_length)
+                else:
+                    telemetria.bytes_enviados += len(response_get.content)
+
+                if response_get.status_code != 200:
+                    raise Exception(f"Falha ao acessar a página de detalhes: {response_get.status_code}")
+
+                # Capturar as movimentações
+                pagina_html = response_get.text
+                soup_novo = BeautifulSoup(pagina_html, "html.parser")
+                link = soup_novo.find(
+                    'a', 
+                    href=lambda href: href and "externo_controlador.php?acao=processo_seleciona_publica" in href,
+                    text=lambda t: t and "listar todos os eventos" in t.lower()
+                )
+                if link:
+                    
+                    link_href = link.get("href")
+                    url_base = "https://eprocwebcon.tjsc.jus.br/consulta1g/"
+                    url_eventos = urljoin(url_base, link_href) 
+                    response_eventos = client.get(url_eventos, follow_redirects=True, timeout=TEMPO_LIMITE)
+                    content_length = response_eventos.headers.get('Content-Length')
+                    if content_length:
+                        telemetria.bytes_enviados += int(content_length)
+                    else:
+                        telemetria.bytes_enviados += len(response_eventos.content)
+                    
+                    if response_eventos.status_code != 200:
+                        raise Exception(f"Falha ao acessar a página de eventos: {response_eventos.status_code}")
+                    
+                    pagina_html = response_eventos.text
+                    
+                    todas_movimentacoes = await capturar_todas_movimentacoes(pagina_html)
+                    
+                else:
+                    logger.warning("Link para eventos não encontrado na página de detalhes.")
+                    todas_movimentacoes = await capturar_todas_movimentacoes(pagina_html)
+
+                # Processar os resultados
+                if not todas_movimentacoes or todas_movimentacoes == ["Nenhuma movimentação encontrada na tabela"]:
+                    logger.error("Nenhuma movimentação encontrada para o processo.")
+                    results = {
+                        'code': 200,
+                        'message': 'Nenhuma movimentação encontrada para o processo.',
+                        'datetime': datetime.now().strftime('%d-%m-%Y %H:%M:%S'),
+                    }
+                else:
+                    
+                    logger.info("Processo consultado com sucesso.")
+                    results = {
+                            "code": 200,
+                            "message": "SUCESSO",
+                            "datetime": datetime.now().isoformat(),
+                            "results": ResponseSiteTJSC(movimentacoes=todas_movimentacoes).model_dump(),
+                            "telemetria": telemetria.model_dump()
+                        }
+
+    except httpx.RequestError as e:
+        logger.error(f"Erro de requisição: {e}")
+        telemetria.tempo_total = round(time.time() - telemetria.tempo_total, 2)
+        results = JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={
+                'code': 4,
+                'message': 'ERRO_SERVIDOR_INTERNO',
+                'telemetria': telemetria
+            }
+        )
+    except Exception as e:
+        logger.error(f"Erro durante a consulta: {e}")
+        if telemetria.tentativas < TENTATIVAS_MAXIMAS_CAPTCHA:
+            logger.info("Tentando resolver o CAPTCHA novamente...")
+            telemetria.tentativas += 1
+            return await fetch(numero_processo, telemetria)
+        else:
+            telemetria.tempo_total = round(time.time() - telemetria.tempo_total, 2)
+            results = JSONResponse(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                content={
+                    'code': 4,
+                    'message': 'ERRO_SERVIDOR_INTERNO',
+                    'telemetria': telemetria
+                }
+            )
+    finally:
+        client.close()
+        telemetria.tempo_total = round(time.time() - telemetria.tempo_total, 2)
+        if results is not None and isinstance(results, dict) and "telemetria" not in results:
+            results["telemetria"] = telemetria
+
+    return results
+
+async def research_process(numero_processo: str):
+    """
+    Interface externa para pesquisa de processo no TJPR.
+    """
+    str_time = time.time()
+    telem = models.Telemetria(tentativas=1, tempo_total=str_time)
+    return await fetch(numero_processo, telemetria=telem)

src/monitoramento_processual/monitoramento_tjsp.py

@@ -0,0 +1,155 @@
+from os import environ as env
+from datetime import datetime
+import time
+from urllib.parse import urlparse, urlunparse, urljoin
+
+from fastapi.logger import logger
+from fastapi.responses import JSONResponse
+from fastapi import status
+from bs4 import BeautifulSoup
+import httpx
+
+# Local imports
+from src.models import ResponseSiteTJSP, Telemetria, MovimentacaoTJSP
+import src.models as models
+
+# Captura variáveis de ambiente e cria constantes
+TEMPO_LIMITE = int(env.get('TEMPO_LIMITE', 180))
+TENTATIVAS_MAXIMAS_RECURSIVAS = int(env.get('TENTATIVAS_MAXIMAS_RECURSIVAS', 30))
+
+
+async def capturar_todas_movimentacoes(pagina_html: str) -> list[MovimentacaoTJSP]:
+    """
+    Extrai todas as movimentações (visíveis e ocultas) do HTML da página.
+    Para cada movimentação, extrai a data, a descrição e o link do documento.
+    """
+    soup = BeautifulSoup(pagina_html, "html.parser")
+    movimentacoes = []
+    tbody_ids = ["tabelaUltimasMovimentacoes", "tabelaTodasMovimentacoes"]
+
+    for tbody_id in tbody_ids:
+        tbody = soup.find("tbody", id=tbody_id)
+        if not tbody:
+            continue
+
+        for tr in tbody.find_all("tr", class_="containerMovimentacao"):
+            td_data = tr.find("td", class_="dataMovimentacao")
+            data_text = td_data.get_text(strip=True) if td_data else ""
+            td_desc = tr.find("td", class_="descricaoMovimentacao")
+            descricao = td_desc.get_text(separator=" ", strip=True) if td_desc else ""
+            link_tag = tr.find("a", class_="linkMovVincProc")
+            documentos = link_tag.get("href", "") if link_tag else ""
+            
+            movimentacoes.append(
+                MovimentacaoTJSP(
+                    data_hora=data_text,
+                    descricao=descricao,
+                    documentos=documentos
+                )
+            )
+
+    return ResponseSiteTJSP(movimentacoes=movimentacoes)
+
+async def fetch(numero_processo: str, telemetria: Telemetria) -> dict:
+    """
+    Acessa a página inicial do TJSC, resolve o CAPTCHA com retry, envia o formulário via GET e
+    captura as movimentações do processo. Retorna os resultados como objetos Movimentacao,
+    incluindo os links completos dos documentos (com ticket).
+    """
+    if not numero_processo or not isinstance(numero_processo, str):
+        return JSONResponse(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            content={'code': 2, 'message': 'ERRO_ENTIDADE_NAO_PROCESSAVEL'}
+        )
+
+    if telemetria.tentativas >= TENTATIVAS_MAXIMAS_RECURSIVAS:
+        logger.error("Número máximo de tentativas recursivas atingido.")
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={'code': 3, 'message': 'ERRO_SERVIDOR_INTERNO'}
+        )
+
+    logger.info(f'Função fetch() iniciou. Processo: {numero_processo} - Tentativa {telemetria.tentativas}')
+
+    headers = {
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+        "Host": "esaj.tjsp.jus.br",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36 Edg/134.0.0.0"
+    }
+
+    client = httpx.Client(timeout=TEMPO_LIMITE, verify=False, headers=headers)
+    results = None
+    base_url = "https://esaj.tjsp.jus.br"
+
+    try:
+        get_inicial = (
+            "https://esaj.tjsp.jus.br/cpopg/search.do?conversationId=&cbPesquisa=NUMPROC"
+            "&numeroDigitoAnoUnificado=&foroNumeroUnificado="
+            "&dadosConsulta.valorConsultaNuUnificado=&dadosConsulta.valorConsultaNuUnificado=UNIFICADO"
+            f"&dadosConsulta.valorConsulta={numero_processo}"
+            "&dadosConsulta.tipoNuProcesso=SAJ"
+        )
+        response = client.get(get_inicial, follow_redirects=False)
+        content_length = response.headers.get('Content-Length')
+        if content_length:
+            telemetria.bytes_enviados += int(content_length)
+        else:
+            telemetria.bytes_enviados += len(response.content)
+        
+        if response.status_code == 302:
+            redirect_url = response.headers.get("Location")
+            logger.info(f"Redirecionamento encontrado para: {redirect_url}")
+            absolute_url = urljoin(base_url, redirect_url)
+            parsed = urlparse(absolute_url)
+            clean_path = parsed.path.split(";")[0]
+            clean_url = urlunparse((parsed.scheme, parsed.netloc, clean_path, parsed.params, parsed.query, parsed.fragment))
+            response = client.get(clean_url, follow_redirects=True)
+            content_length = response.headers.get('Content-Length')
+            if content_length:
+                telemetria.bytes_enviados += int(content_length)
+            else:
+                telemetria.bytes_enviados += len(response.content)
+        
+        capturar_movimentacoes = await capturar_todas_movimentacoes(response.text)
+        results = {
+                "code": 200,
+                "message": "SUCESSO",
+                "datetime": datetime.now().isoformat(),
+                "results": capturar_movimentacoes.model_dump(),
+                "telemetria": telemetria.model_dump()
+            }
+        
+    except httpx.RequestError as e:
+        logger.error(f"Erro de requisição: {e}")
+        telemetria.tempo_total = round(time.time() - telemetria.tempo_total, 2)
+        results = JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={'code': 4, 'message': 'ERRO_SERVIDOR_INTERNO', 'telemetria': telemetria.dict()}
+        )
+    except Exception as e:
+        logger.error(f"Erro durante a consulta: {e}")
+        if telemetria.tentativas < TENTATIVAS_MAXIMAS_RECURSIVAS:
+            logger.info("Tentando novamente...")
+            telemetria.tentativas += 1
+            return await fetch(numero_processo, telemetria)
+        else:
+            telemetria.tempo_total = round(time.time() - telemetria.tempo_total, 2)
+            results = JSONResponse(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                content={'code': 4, 'message': 'ERRO_SERVIDOR_INTERNO', 'telemetria': telemetria.dict()}
+            )
+    finally:
+        client.close()
+        telemetria.tempo_total = round(time.time() - telemetria.tempo_total, 2)
+        if results is not None and isinstance(results, dict) and "telemetria" not in results:
+            results["telemetria"] = telemetria.dict()
+    
+    return results
+
+async def research_process(numero_processo: str):
+    """
+    Interface externa para pesquisa de processo no TJPR.
+    """
+    str_time = time.time()
+    telem = models.Telemetria(tentativas=1, tempo_total=str_time)
+    return await fetch(numero_processo, telemetria=telem)

src/monitoramento_processual/task_dispatcher.py

@@ -0,0 +1,13 @@
+from src.monitoramento_processual import monitoramento_tjpr, monitoramento_tjsc, monitoramento_tjsp
+
+async def process_dispatcher(uf: str, current_user: str):
+    if uf == "PR":
+        resultado = await monitoramento_tjpr.fetch_all(current_user, uf)
+    elif uf == "SC":
+        resultado = await monitoramento_tjsc.fetch_all(current_user, uf)
+    elif uf == "SP":
+        resultado = await monitoramento_tjsp.fetch_all(current_user, uf)
+    else:
+        resultado = {"error": "UF não suportada para monitoramento."}
+    
+    return resultado

src/processamento_tjdf.py

@@ -0,0 +1,192 @@
+import re
+import datetime
+import asyncio
+import aiohttp
+from bs4 import BeautifulSoup
+
+HEADERS = {
+    'User-Agent': ('Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
+                   'AppleWebKit/537.36 (KHTML, like Gecko) '
+                   'Chrome/85.0.4183.83 Safari/537.36')
+}
+
+async def fetch(session: aiohttp.ClientSession, url: str):
+    """
+    Realiza uma requisição GET e retorna o texto da resposta e a URL final.
+    """
+    async with session.get(url, headers=HEADERS, ssl=False) as response:
+        text = await response.text()
+        return text, str(response.url)
+
+async def parse_detail(session: aiohttp.ClientSession, url_proc: str, numero: str, vara: str) -> dict:
+    """
+    Processa a página de detalhe do processo e extrai os dados necessários.
+    """
+    html, _ = await fetch(session, url_proc)
+    proc_soup = BeautifulSoup(html, 'html.parser')
+
+    # Número do processo
+    numero_processo_tag = proc_soup.find("span", id="i_numeroProcesso14")
+    numero_processo = numero_processo_tag.get_text(strip=True) if numero_processo_tag else numero
+
+    # Tipo de processo
+    feito_codigo_tag = proc_soup.find("span", id="i_feitoCodigo")
+    feito_descricao_tag = proc_soup.find("span", id="i_feitoDescricao")
+    if feito_codigo_tag and feito_descricao_tag:
+        tipo_processo = f"{feito_codigo_tag.get_text(strip=True)} - {feito_descricao_tag.get_text(strip=True)}"
+    else:
+        tipo_processo = ""
+
+    # Nome do advogado (autor)
+    advogado_tag = proc_soup.find("span", id="i_advogadoAutor")
+    nome_advogado = advogado_tag.get_text(strip=True) if advogado_tag else ""
+
+    # Foro ou endereço da vara
+    endereco_vara_tag = proc_soup.find("span", id="i_enderecoVara")
+    foro_processo = endereco_vara_tag.get_text(strip=True) if endereco_vara_tag else vara
+
+    # Extração da data de recebimento a partir dos andamentos
+    andamentos = []
+    for data_tag in proc_soup.find_all("span", id=re.compile(r"^i_dataHoraAndamento_")):
+        num_evento = data_tag.get("id").split("_")[-1]
+        desc_tag = proc_soup.find("span", id=f"i_descricaoAndamento_{num_evento}")
+        if desc_tag:
+            desc = desc_tag.get_text(strip=True)
+            date_str = data_tag.get_text(strip=True)
+            try:
+                dt = datetime.datetime.strptime(date_str, "%d/%m/%Y - %H:%M:%S")
+                andamentos.append((dt, desc))
+            except ValueError:
+                continue
+
+    recebimento_candidates = [dt for dt, desc in andamentos
+                              if "007" in desc and "Distribuidos ao cartorio" in desc]
+    if recebimento_candidates:
+        dt_recebimento = min(recebimento_candidates)
+    elif andamentos:
+        dt_recebimento = min([dt for dt, _ in andamentos])
+    else:
+        dt_recebimento = None
+    data_recebimento = dt_recebimento.strftime("%d/%m/%Y - %H:%M:%S") if dt_recebimento else ""
+
+    dados = {
+        "nome_advogado": nome_advogado,
+        "numero_processo": numero_processo,
+        "tipo_processo": tipo_processo,
+        "data_recebimento": data_recebimento,
+        "link_processo": url_proc,
+        "foro_processo": foro_processo,
+        "grau_processo": "TJDF - 1ª Instância"
+    }
+    return dados
+
+async def tjdf_request(nome: str) -> list:
+    """
+    Consulta os processos no TJDF usando requisições assíncronas.
+    Retorna uma lista de dicionários com os dados dos processos encontrados.
+    """
+    dados_processos = []
+    base_url = "https://cache-internet.tjdft.jus.br/cgi-bin/tjcgi1"
+    search_params = f"?NXTPGM=tjhtml101&ORIGEM=INTER&SELECAO=9&CIRC=ZZ&CHAVE={nome}&CHAVE1=&submit=Consultar"
+    url_search = base_url + search_params
+
+    async with aiohttp.ClientSession() as session:
+        html, current_url = await fetch(session, url_search)
+        soup = BeautifulSoup(html, "html.parser")
+
+        # Se nenhum processo foi localizado, retorna lista vazia
+        if "0 processo(s) localizado(s)" in soup.text:
+            return dados_processos
+
+        # Se já é uma página de detalhe
+        if "Advogado Autor" in soup.text:
+            proc_soup = soup
+            url_proc = current_url
+            vara_tag = proc_soup.find("span", id="i_descricaoVara")
+            vara = vara_tag.get_text(strip=True) if vara_tag else ""
+
+            numero_processo_tag = proc_soup.find("span", id="i_numeroProcesso14")
+            if numero_processo_tag:
+                numero_processo = numero_processo_tag.get_text(strip=True)
+            else:
+                hidden_tag = proc_soup.find("hidden", id="detalhamentoDeProcesso")
+                if hidden_tag and hidden_tag.has_attr("value"):
+                    parts = hidden_tag["value"].split(",")
+                    numero_processo = parts[1].strip() if len(parts) >= 2 else nome
+                else:
+                    numero_processo = nome
+
+            feito_codigo_tag = proc_soup.find("span", id="i_feitoCodigo")
+            feito_descricao_tag = proc_soup.find("span", id="i_feitoDescricao")
+            if feito_codigo_tag and feito_descricao_tag:
+                tipo_processo = f"{feito_codigo_tag.get_text(strip=True)} - {feito_descricao_tag.get_text(strip=True)}"
+            else:
+                tipo_processo = ""
+
+            advogado_tag = proc_soup.find("span", id="i_advogadoAutor")
+            nome_advogado = advogado_tag.get_text(strip=True) if advogado_tag else ""
+
+            endereco_vara_tag = proc_soup.find("span", id="i_enderecoVara")
+            foro_processo = endereco_vara_tag.get_text(strip=True) if endereco_vara_tag else vara
+
+            # Extração dos andamentos
+            andamentos = []
+            for data_tag in proc_soup.find_all("span", id=re.compile(r"^i_dataHoraAndamento_")):
+                num_evento = data_tag.get("id").split("_")[-1]
+                desc_tag = proc_soup.find("span", id=f"i_descricaoAndamento_{num_evento}")
+                if desc_tag:
+                    desc = desc_tag.get_text(strip=True)
+                    date_str = data_tag.get_text(strip=True)
+                    try:
+                        dt = datetime.datetime.strptime(date_str, "%d/%m/%Y - %H:%M:%S")
+                        andamentos.append((dt, desc))
+                    except ValueError:
+                        continue
+
+            recebimento_candidates = [dt for dt, desc in andamentos
+                                      if "007" in desc and "Distribuidos ao cartorio" in desc]
+            if recebimento_candidates:
+                dt_recebimento = min(recebimento_candidates)
+            elif andamentos:
+                dt_recebimento = min([dt for dt, _ in andamentos])
+            else:
+                dt_recebimento = None
+            data_recebimento = dt_recebimento.strftime("%d/%m/%Y - %H:%M:%S") if dt_recebimento else ""
+
+            dados = {
+                "nome_advogado": nome_advogado,
+                "numero_processo": numero_processo,
+                "tipo_processo": tipo_processo,
+                "data_recebimento": data_recebimento,
+                "link_processo": url_proc,
+                "foro_processo": foro_processo,
+                "grau_processo": "TJDF - 1ª Instância"
+            }
+            dados_processos.append(dados)
+            return dados_processos
+
+        # Se for uma página com a lista de processos
+        processo_spans = soup.find_all("span", id=re.compile(r"^processo_"))
+        processos = {}
+        for span in processo_spans:
+            numero = span.get_text(strip=True)
+            if numero not in processos:
+                parent_ul = span.find_parent("ul")
+                if parent_ul:
+                    vara_tag = parent_ul.find("span", id=re.compile(r"^vara_"))
+                    vara = vara_tag.get_text(strip=True) if vara_tag else ""
+                else:
+                    vara = ""
+                processos[numero] = vara
+
+        # Cria tarefas para buscar os detalhes de cada processo de forma assíncrona
+        tasks = []
+        for numero, vara in processos.items():
+            url_proc = f"{base_url}?NXTPGM=tjhtml105&ORIGEM=INTER&SELECAO=1&CIRCUN=1&CDNUPROC={numero}"
+            tasks.append(parse_detail(session, url_proc, numero, vara))
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        for res in results:
+            if isinstance(res, dict):
+                dados_processos.append(res)
+
+        return dados_processos

src/tj_research/tj_researcher.py

@@ -0,0 +1,24 @@
+from src.monitoramento_processual import monitoramento_tjpr, monitoramento_tjsc, monitoramento_tjsp
+
+async def research_process(uf: str, process_number: str, current_user: str = None):
+    """
+    Pesquisa um processo específico no tribunal de justiça correspondente à UF.
+    
+    Args:
+        uf (str): Unidade Federativa (ex.: "PR", "SC", "SP").
+        process_number (str): Número do processo a ser pesquisado.
+        current_user (str, optional): Usuário atual, para autenticação ou logging, se necessário.
+    
+    Returns:
+        dict: JSON com os dados do processo ou um erro se a UF não for suportada.
+    """
+    if uf == "PR":
+        resultado = await monitoramento_tjpr.research_process(process_number)
+    elif uf == "SC":
+        resultado = await monitoramento_tjsc.research_process(process_number)
+    elif uf == "SP":
+        resultado = await monitoramento_tjsp.research_process(process_number)
+    else:
+        resultado = {"error": "UF não suportada para pesquisa de processos."}
+    
+    return resultado

static/consulta.html

@@ -0,0 +1,232 @@
+<!DOCTYPE html>
+<html lang="pt-br">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Consulta de Processo - Monitoramento Judicial</title>
+  <style>
+    body {
+      margin: 0;
+      font-family: 'Segoe UI', sans-serif;
+      background-color: #f4f6f8;
+      color: #333;
+    }
+
+    header {
+      background-color: #1e3a8a;
+      color: white;
+      padding: 15px 30px;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+
+    header h1 {
+      margin: 0;
+      font-size: 1.5rem;
+    }
+
+    nav button {
+      background-color: white;
+      color: #1e3a8a;
+      font-size: 1rem;
+      padding: 8px 16px;
+      margin-left: 20px;
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+    }
+
+    nav button:hover {
+      background-color: #f0f0f0;
+    }
+
+    .container {
+      max-width: 700px;
+      margin: 50px auto;
+      padding: 20px;
+      background: white;
+      border-radius: 8px;
+      box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+    }
+
+    h2 {
+      text-align: center;
+    }
+
+    .form-group {
+      margin-bottom: 20px;
+    }
+
+    .form-group label {
+      display: block;
+      margin-bottom: 5px;
+    }
+
+    .form-group input, .form-group select {
+      width: 100%;
+      padding: 10px;
+      font-size: 1rem;
+      border: 1px solid #ccc;
+      border-radius: 4px;
+    }
+
+    button.submit {
+      background-color: #1e3a8a;
+      color: white;
+      padding: 10px 20px;
+      font-size: 1rem;
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+    }
+
+    button.submit:hover {
+      background-color: #163c74;
+    }
+
+    .result {
+      margin-top: 30px;
+    }
+
+    .movimentacao {
+      background-color: #eef2f7;
+      padding: 10px 15px;
+      border-radius: 6px;
+      margin-bottom: 10px;
+    }
+
+    .data {
+      font-weight: bold;
+      color: #1e3a8a;
+    }
+
+    #verMaisBtn {
+      background-color: #d3d3d3;
+      border: none;
+      border-radius: 4px;
+      padding: 8px 16px;
+      margin: 20px auto 0;
+      display: none;
+      cursor: pointer;
+      font-size: 0.95rem;
+    }
+
+    #carregando {
+      text-align: center;
+      margin-top: 20px;
+      font-weight: bold;
+      color: #1e3a8a;
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>Consulta de Processo</h1>
+    <nav>
+      <button onclick="window.location.href='/dashboard'">Dashboard</button>
+      <button onclick="logout()">Sair</button>
+    </nav>
+  </header>
+
+  <div class="container">
+    <h2>Consultar Processo no Tribunal</h2>
+
+    <div class="form-group">
+      <label for="uf">UF:</label>
+      <select id="uf">
+        <option value="PR">PR</option>
+        <option value="SC">SC</option>
+        <option value="SP">SP</option>
+      </select>
+    </div>
+
+    <div class="form-group">
+      <label for="process-number">Número do Processo:</label>
+      <input type="text" id="process-number" placeholder="0000000-00.0000.0.00.0000">
+    </div>
+
+    <button class="submit" onclick="consultarProcesso()">Consultar</button>
+
+    <div id="carregando"></div>
+
+    <div id="resultado" class="result"></div>
+    <button id="verMaisBtn" onclick="alternarVerMais()">Ver mais</button>
+  </div>
+
+  <script>
+    const token = localStorage.getItem('token');
+
+    function logout() {
+      localStorage.clear();
+      window.location.href = '/';
+    }
+
+    let todasMovimentacoes = [];
+    let mostrandoTodas = false;
+
+    function renderizarMovimentacoes() {
+      const resultado = document.getElementById("resultado");
+      resultado.innerHTML = "";
+
+      const movimentacoesParaMostrar = mostrandoTodas
+        ? todasMovimentacoes
+        : todasMovimentacoes.slice(0, 5);
+
+      movimentacoesParaMostrar.forEach(mov => {
+        const div = document.createElement("div");
+        div.className = "movimentacao";
+
+        const data = mov.data || mov.data_hora || "";
+        const evento = mov.evento || "";
+        const descricao = mov.descricao || evento;
+        const documentos = mov.documentos || "";
+
+        div.innerHTML = `
+          <div class="data">${data}</div>
+          <div style="white-space: pre-wrap; margin: 5px 0;">${descricao}</div>
+          ${documentos ? `<a href="${documentos}" target="_blank" style="color: #1e3a8a; text-decoration: none;">📄 Ver documento</a>` : ""}
+        `;
+        resultado.appendChild(div);
+      });
+
+      const verMaisBtn = document.getElementById("verMaisBtn");
+      if (todasMovimentacoes.length > 5) {
+        verMaisBtn.style.display = "block";
+        verMaisBtn.textContent = mostrandoTodas ? "Ver menos" : "Ver mais";
+      } else {
+        verMaisBtn.style.display = "none";
+      }
+    }
+
+    function alternarVerMais() {
+      mostrandoTodas = !mostrandoTodas;
+      renderizarMovimentacoes();
+    }
+
+    async function consultarProcesso() {
+      const uf = document.getElementById('uf').value;
+      const numero = document.getElementById('process-number').value;
+
+      document.getElementById("carregando").innerText = "Consultando processo...";
+      document.getElementById("resultado").innerHTML = "";
+      document.getElementById("verMaisBtn").style.display = "none";
+
+      try {
+        const res = await fetch(`/api/monitoramento-processual/consulta/tjs?uf=${uf}&process_number=${encodeURIComponent(numero)}`, {
+          headers: { 'Authorization': `Bearer ${token}` }
+        });
+
+        const data = await res.json();
+        todasMovimentacoes = data?.results?.movimentacoes || [];
+        mostrandoTodas = false;
+        renderizarMovimentacoes();
+      } catch (e) {
+        document.getElementById("resultado").innerText = "Erro ao consultar processo.";
+      } finally {
+        document.getElementById("carregando").innerText = "";
+      }
+    }
+  </script>
+</body>
+</html>

static/dashboard.html

@@ -0,0 +1,283 @@
+<!DOCTYPE html>
+<html lang="pt-br">
+
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Painel - Monitoramento Judicial</title>
+  <style>
+    body {
+      margin: 0;
+      font-family: 'Segoe UI', sans-serif;
+      background-color: #f4f6f8;
+      color: #333;
+    }
+
+    header {
+      background-color: #1e3a8a;
+      color: white;
+      padding: 15px 30px;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+    }
+
+    header h1 {
+      margin: 0;
+      font-size: 1.5rem;
+    }
+
+    nav {
+      position: relative;
+    }
+
+    nav button {
+      background-color: white;
+      color: #1e3a8a;
+      font-size: 1rem;
+      padding: 8px 16px;
+      margin-left: 10px;
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+    }
+
+    nav button:hover {
+      background-color: #f0f0f0;
+    }
+
+    .user-menu {
+      position: absolute;
+      right: 0;
+      top: 45px;
+      background: white;
+      border: 1px solid #ccc;
+      border-radius: 4px;
+      display: none;
+      flex-direction: column;
+      z-index: 999;
+    }
+
+    .user-menu button {
+      width: 100%;
+      text-align: left;
+      padding: 10px 16px;
+      border: none;
+      background: white;
+      color: #1e3a8a;
+      cursor: pointer;
+    }
+
+    .user-menu button:hover {
+      background-color: #f0f0f0;
+    }
+
+    .container {
+      max-width: 95%;
+      margin: 40px auto;
+      padding: 20px;
+      background: white;
+      border-radius: 8px;
+      box-shadow: 0 0 10px rgba(0, 0, 0, 0.05);
+    }
+
+    .welcome {
+      font-size: 1.2rem;
+      margin-bottom: 20px;
+    }
+
+    .card {
+      background: #f9f9f9;
+      padding: 20px;
+      margin-bottom: 20px;
+      border-radius: 8px;
+      box-shadow: 0 0 5px rgba(0, 0, 0, 0.05);
+    }
+
+    .grid {
+      display: flex;
+      gap: 20px;
+    }
+
+    .half {
+      flex: 1;
+    }
+
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      margin-top: 10px;
+    }
+
+    th, td {
+      padding: 12px;
+      border-bottom: 1px solid #ddd;
+      text-align: left;
+    }
+
+    th {
+      background-color: #f4f4f4;
+    }
+
+    .delete-icon {
+      cursor: pointer;
+      color: red;
+    }
+
+    .status-andamento {
+      color: green;
+      font-weight: bold;
+    }
+
+    .status-pausada {
+      color: red;
+      font-weight: bold;
+    }
+  </style>
+</head>
+
+<body>
+  <header>
+    <h1>Monitoramento Judicial</h1>
+    <nav>
+      <button onclick="window.location.href='/tasks'">Tarefas</button>
+      <button onclick="window.location.href='/consulta'">
+        <span>Consulta</span> 🔍
+      </button>
+      
+
+      <button onclick="toggleUserMenu()" id="user-button">Usuário</button>
+      <div class="user-menu" id="user-menu">
+        <button onclick="abrirConfiguracoes()">Configurações</button>
+        <button onclick="verSaldo()">Saldo</button>
+        <button onclick="logout()">Sair</button>
+      </div>
+    </nav>
+  </header>
+
+  <div class="container">
+    <div class="welcome">Bem-vindo, <span id="user-welcome">usuário</span>!</div>
+
+    <div class="card">
+      <h2>Tarefas em Andamento</h2>
+      <table id="tarefas-table">
+        <thead>
+          <tr>
+            <th>Nome da Tarefa</th>
+            <th>Status</th>
+            <th>Ações</th>
+          </tr>
+        </thead>
+        <tbody></tbody>
+      </table>
+    </div>
+
+    <div class="grid">
+      <div class="card half">
+        <h2>Resultado da Tarefa - Advogados</h2>
+        <table id="advogados-table">
+          <thead>
+            <tr>
+              <th>Nome do Advogado</th>
+              <th>UF</th>
+              <th>Monitoramento</th>
+              <th>Processos</th>
+              <th>Ações</th>
+            </tr>
+          </thead>
+          <tbody></tbody>
+        </table>
+      </div>
+
+      <div class="card half">
+        <h2>Resultado da Tarefa - Processos</h2>
+        <table id="processos-table">
+          <thead>
+            <tr>
+              <th>Número do Processo</th>
+              <th>Data do Andamento</th>
+              <th>Descrição</th>
+              <th>Documentos</th>
+              <th>Status</th>
+              <th>Ações</th>
+            </tr>
+          </thead>
+          <tbody></tbody>
+        </table>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    const token = localStorage.getItem("token");
+    const username = localStorage.getItem('username');
+    const nome = localStorage.getItem('nome');
+    const sobrenome = localStorage.getItem('sobrenome');
+
+    document.getElementById('user-button').innerText = username || 'Usuário';
+    document.getElementById('user-welcome').innerText = `${nome || ''} ${sobrenome || ''}`.trim();
+
+    function toggleUserMenu() {
+      const menu = document.getElementById('user-menu');
+      menu.style.display = menu.style.display === 'flex' ? 'none' : 'flex';
+    }
+
+    function logout() {
+      localStorage.clear();
+      window.location.href = '/';
+    }
+
+    function abrirConfiguracoes() {
+      window.location.href = "/user_config";
+    }
+
+    function verSaldo() {
+      alert("Saldo atual: R$ 0,00 (em desenvolvimento)");
+    }
+
+    async function preencherNome() {
+      const res = await fetch(`/api/monitoramento-processual/usuario-info?username=${username}`, {
+        headers: { 'Authorization': `Bearer ${token}` }
+      });
+      const data = await res.json();
+      document.getElementById('user-welcome').innerText = `${data.nome} ${data.sobrenome}`;
+    }
+
+    async function carregarTarefas() {
+      const res = await fetch('/api/monitoramento-processual/consulta/listar-tarefas', {
+        headers: { 'Authorization': `Bearer ${token}` }
+      });
+      const tarefas = await res.json();
+      const tbody = document.querySelector('#tarefas-table tbody');
+      tbody.innerHTML = '';
+
+      tarefas.forEach(tarefa => {
+        const statusClass = tarefa.monitoramento === 'sim' ? 'status-andamento' : 'status-pausada';
+        const statusLabel = tarefa.monitoramento === 'sim' ? 'Em andamento' : 'Pausada';
+
+        const row = document.createElement('tr');
+        row.innerHTML = `
+          <td>${tarefa.nome}</td>
+          <td class="${statusClass}">${statusLabel}</td>
+          <td><span class="delete-icon" title="Apagar tarefa">🗑️</span></td>
+        `;
+        tbody.appendChild(row);
+      });
+    }
+
+    window.onload = () => {
+      preencherNome();
+      carregarTarefas();
+    };
+
+    window.onclick = function (e) {
+      const menu = document.getElementById("user-menu");
+      if (!document.getElementById("user-button").contains(e.target)) {
+        menu.style.display = "none";
+      }
+    };
+  </script>
+</body>
+
+</html>

static/index.html

@@ -0,0 +1,114 @@
+<!DOCTYPE html>
+<html lang="pt-br">
+
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Monitoramento Judicial - Login</title>
+  <link rel="stylesheet" href="/static/style.css">
+</head>
+
+<body>
+  <div class="container">
+    <div class="app-title">Monitoramento Judicial</div>
+    <div class="description">Consulta e monitoramento de processos judiciais com tecnologia</div>
+
+    <!-- LOGIN -->
+    <div id="login-box">
+      <h1>Login</h1>
+      <input type="text" id="username" placeholder="Usuário">
+      <input type="password" id="password" placeholder="Senha">
+      <button onclick="login()">Entrar</button>
+      <button id="show-register" onclick="showRegister()">Criar Conta</button>
+    </div>
+
+    <!-- CADASTRO -->
+    <div id="register-box" style="display:none;">
+      <h2>Criar Conta</h2>
+      <input type="text" id="nome" placeholder="Nome">
+      <input type="text" id="sobrenome" placeholder="Sobrenome">
+      <input type="email" id="email" placeholder="E-mail">
+      <input type="text" id="newUsername" placeholder="Usuário">
+      <input type="password" id="newPassword" placeholder="Senha">
+      <button onclick="register()">Cadastrar</button>
+      <button onclick="hideRegister()">Voltar</button>
+    </div>
+
+    <div class="divider"></div>
+
+    <button onclick="window.location.href='/docs'">📄 Documentação API</button>
+
+    <div id="message" class="message"></div>
+    <div class="footer">© 2025 Monitoramento Judicial</div>
+  </div>
+
+  <script>
+    function showRegister() {
+      document.getElementById('register-box').style.display = 'block';
+      document.getElementById('login-box').style.display = 'none';
+    }
+
+    function hideRegister() {
+      document.getElementById('register-box').style.display = 'none';
+      document.getElementById('login-box').style.display = 'block';
+    }
+
+    async function login() {
+    const username = document.getElementById('username').value;
+    const password = document.getElementById('password').value;
+    const response = await fetch('/api/monitoramento-processual/login', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ username: username, senha: password })
+    });
+    const data = await response.json();
+    const msg = document.getElementById('message');
+    if (response.ok) {
+      localStorage.setItem('token', data.access_token);
+      localStorage.setItem('username', username);
+
+      // 🔄 Novo: Buscar nome e sobrenome
+      const userInfo = await fetch(`/api/monitoramento-processual/usuario-info?username=${username}`, {
+        headers: { 'Authorization': `Bearer ${data.access_token}` }
+      });
+      const user = await userInfo.json();
+      localStorage.setItem('nome', user.nome);
+      localStorage.setItem('sobrenome', user.sobrenome);
+
+      msg.style.color = 'green';
+      msg.innerText = 'Login bem-sucedido! Redirecionando...';
+      setTimeout(() => {
+        window.location.href = '/dashboard';
+      }, 1000);
+    } else {
+      msg.style.color = 'red';
+      msg.innerText = data.detail || 'Erro no login.';
+    }
+  }
+
+    async function register() {
+      const nome = document.getElementById('nome').value;
+      const sobrenome = document.getElementById('sobrenome').value;
+      const email = document.getElementById('email').value;
+      const username = document.getElementById('newUsername').value;
+      const password = document.getElementById('newPassword').value;
+      const response = await fetch('/api/monitoramento-processual/cadastrar-usuario', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ username, senha: password, nome, sobrenome, email })
+      });
+      const data = await response.json();
+      const msg = document.getElementById('message');
+      if (response.ok) {
+        msg.style.color = 'green';
+        msg.innerText = 'Usuário cadastrado com sucesso!';
+        hideRegister();
+      } else {
+        msg.style.color = 'red';
+        msg.innerText = data.detail || 'Erro no cadastro.';
+      }
+    }
+  </script>
+</body>
+
+</html>

static/script.js

@@ -0,0 +1,138 @@
+const token = localStorage.getItem('token');
+const username = localStorage.getItem('username');
+
+if (username) {
+  document.getElementById('user-name').innerText = username;
+  document.getElementById('user-welcome').innerText = username;
+}
+
+function logout() {
+  localStorage.clear();
+  window.location.href = '/';
+}
+
+function showForm(action) {
+  const container = document.getElementById('form-container');
+  let formHTML = '';
+
+  switch (action) {
+    case 'adv-cad':
+      formHTML = `<h3>Cadastrar Advogado</h3>
+        <input type='text' id='nome-adv' placeholder='Nome Advogado'>
+        <input type='text' id='uf-adv' placeholder='UF'>
+        <button onclick='cadastrarAdvogado()'>Cadastrar</button>`;
+      break;
+    case 'adv-del':
+      formHTML = `<h3>Deletar Advogado</h3>
+        <input type='text' id='nome-adv-del' placeholder='Nome Advogado'>
+        <input type='text' id='uf-adv-del' placeholder='UF'>
+        <button onclick='deletarAdvogado()'>Deletar</button>`;
+      break;
+    case 'proc-cad':
+      formHTML = `<h3>Cadastrar Processo</h3>
+        <input type='text' id='num-proc' placeholder='Número Processo'>
+        <input type='text' id='uf-proc' placeholder='UF'>
+        <button onclick='cadastrarProcesso()'>Cadastrar</button>`;
+      break;
+    case 'proc-del':
+      formHTML = `<h3>Deletar Processo</h3>
+        <input type='text' id='num-proc-del' placeholder='Número Processo'>
+        <input type='text' id='uf-proc-del' placeholder='UF'>
+        <button onclick='deletarProcesso()'>Deletar</button>`;
+      break;
+  }
+
+  container.innerHTML = formHTML;
+}
+
+async function cadastrarAdvogado() {
+  const nome = document.getElementById('nome-adv').value;
+  const uf = document.getElementById('uf-adv').value;
+  const res = await fetch(`/api/monitoramento-processual/consulta/inserir-advogado?nome_advogado=${encodeURIComponent(nome)}&uf=${encodeURIComponent(uf)}`, {
+    method: 'POST',
+    headers: { 'Authorization': `Bearer ${token}` }
+  });
+  if (res.ok) {
+    alert('Advogado cadastrado!');
+    await loadAdvogados();
+  } else {
+    alert('Erro ao cadastrar advogado.');
+  }
+}
+
+async function deletarAdvogado() {
+  const nome = document.getElementById('nome-adv-del').value;
+  const uf = document.getElementById('uf-adv-del').value;
+  const res = await fetch(`/api/monitoramento-processual/consulta/deletar-advogado?nome_advogado=${encodeURIComponent(nome)}&uf=${encodeURIComponent(uf)}`, {
+    method: 'DELETE',
+    headers: { 'Authorization': `Bearer ${token}` }
+  });
+  if (res.ok) {
+    alert('Advogado deletado!');
+    await loadAdvogados();
+  } else {
+    alert('Erro ao deletar advogado.');
+  }
+}
+
+async function cadastrarProcesso() {
+  const num = document.getElementById('num-proc').value;
+  const uf = document.getElementById('uf-proc').value;
+  const res = await fetch(`/api/monitoramento-processual/consulta/inserir-processo?numero_processo=${encodeURIComponent(num)}&uf=${encodeURIComponent(uf)}`, {
+    method: 'POST',
+    headers: { 'Authorization': `Bearer ${token}` }
+  });
+  if (res.ok) {
+    alert('Processo cadastrado!');
+    await loadProcessos();
+  } else {
+    alert('Erro ao cadastrar processo.');
+  }
+}
+
+async function deletarProcesso() {
+  const num = document.getElementById('num-proc-del').value;
+  const uf = document.getElementById('uf-proc-del').value;
+  const res = await fetch(`/api/monitoramento-processual/consulta/deletar-processo?numero_processo=${encodeURIComponent(num)}&uf=${encodeURIComponent(uf)}`, {
+    method: 'DELETE',
+    headers: { 'Authorization': `Bearer ${token}` }
+  });
+  if (res.ok) {
+    alert('Processo deletado!');
+    await loadProcessos();
+  } else {
+    alert('Erro ao deletar processo.');
+  }
+}
+
+async function loadAdvogados() {
+  const res = await fetch(`/api/monitoramento-processual/consulta/listar-advogados`, {
+    headers: { 'Authorization': `Bearer ${token}` }
+  });
+  const data = await res.json();
+  const tbody = document.querySelector('#advogados-table tbody');
+  tbody.innerHTML = '';
+  data.forEach(item => {
+    const row = `<tr><td>${item.nome_advogado}</td><td>${item.uf}</td></tr>`;
+    tbody.innerHTML += row;
+  });
+}
+
+async function loadProcessos() {
+  const res = await fetch(`/api/monitoramento-processual/consulta/listar-processos`, {
+    headers: { 'Authorization': `Bearer ${token}` }
+  });
+  const data = await res.json();
+  const tbody = document.querySelector('#processos-table tbody');
+  tbody.innerHTML = '';
+  data.forEach(item => {
+    const row = `<tr><td>${item.numero_processo}</td><td>${item.uf}</td></tr>`;
+    tbody.innerHTML += row;
+  });
+}
+
+// Carregar ao abrir
+window.onload = () => {
+  loadAdvogados();
+  loadProcessos();
+};

static/style.css

@@ -0,0 +1,99 @@
+body {
+  font-family: Arial, sans-serif;
+  background: linear-gradient(135deg, #f5f7fa, #c3cfe2);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  height: 100vh;
+  margin: 0;
+}
+
+.container {
+  background: white;
+  padding: 40px;
+  border-radius: 12px;
+  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.1);
+  width: 320px;
+  text-align: center;
+}
+
+.app-title {
+  font-size: 1.8rem;
+  margin-bottom: 5px;
+  color: #1e3a8a;
+}
+
+.description {
+  font-size: 0.9rem;
+  color: #555;
+  margin-bottom: 20px;
+}
+
+h1, h2 {
+  margin-bottom: 15px;
+}
+
+input[type="text"], input[type="password"], input[type="email"] {
+  width: 100%;
+  padding: 10px;
+  margin: 10px 0;
+  border: 1px solid #ccc;
+  border-radius: 4px;
+}
+
+button {
+  width: 100%;
+  padding: 10px;
+  background-color: #1e3a8a;
+  color: white;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  margin-top: 10px;
+}
+
+button:hover {
+  background-color: #3749c1;
+}
+
+.message {
+  margin-top: 10px;
+  color: red;
+}
+
+.divider {
+  margin: 20px 0;
+  border-top: 1px solid #ddd;
+}
+
+.footer {
+  margin-top: 25px;
+  font-size: 0.8rem;
+  color: #999;
+}
+
+.ver-mais-btn {
+  margin: 20px auto 0;
+  background: none;
+  border: none;
+  color: #1e3a8a;
+  font-weight: bold;
+  cursor: pointer;
+  font-size: 0.95rem;
+  text-align: center;
+  display: none;
+}
+
+.ver-mais-btn:hover {
+  text-decoration: underline;
+}
+
+.movimentacao {
+  margin-bottom: 15px;
+  padding-bottom: 10px;
+  border-bottom: 1px solid #ccc;
+}
+
+.hidden {
+  display: none;
+}

static/tasks.html

@@ -0,0 +1,170 @@
+<!DOCTYPE html>
+<html lang="pt-br">
+
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Monitoramento Judicial - Tarefas</title>
+  <style>
+    body {
+      margin: 0;
+      font-family: 'Segoe UI', sans-serif;
+      background-color: #f4f6f8;
+      color: #333;
+    }
+
+    header {
+      background-color: #1e3a8a;
+      color: white;
+      padding: 15px 30px;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+    }
+
+    header h1 {
+      margin: 0;
+      font-size: 1.5rem;
+    }
+
+    nav button {
+      background-color: white;
+      color: #1e3a8a;
+      font-size: 1rem;
+      padding: 8px 16px;
+      margin-left: 20px;
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+    }
+
+    nav button:hover {
+      background-color: #f0f0f0;
+    }
+
+    .container {
+      max-width: 800px;
+      margin: 40px auto;
+      padding: 20px;
+      background: white;
+      border-radius: 8px;
+      box-shadow: 0 0 10px rgba(0, 0, 0, 0.05);
+    }
+
+    .welcome {
+      font-size: 1.2rem;
+      margin-bottom: 20px;
+    }
+
+    form {
+      display: flex;
+      flex-direction: column;
+      gap: 10px;
+    }
+
+    input, select, button {
+      padding: 10px;
+      font-size: 1rem;
+    }
+
+    button {
+      background-color: #1e3a8a;
+      color: white;
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+    }
+
+    button:hover {
+      background-color: #354ec4;
+    }
+  </style>
+</head>
+
+<body>
+  <header>
+    <h1>Monitoramento Judicial</h1>
+    <nav>
+      <span id="user-name">Usuário</span>
+      <button onclick="window.location.href='/dashboard'">Dashboard</button>
+      <button onclick="logout()">Sair</button>
+    </nav>
+  </header>
+
+  <div class="container">
+    <div class="welcome">Bem-vindo, <span id="user-welcome">Usuário</span>!</div>
+
+    <h2>Nova Tarefa</h2>
+    <form onsubmit="cadastrarTarefa(event)">
+      <label for="tipo">Tipo:</label>
+      <select id="tipo">
+        <option value="advogado">Advogado</option>
+        <option value="processo">Processo</option>
+      </select>
+
+      <label for="nome">Nome/Número:</label>
+      <input type="text" id="nome" placeholder="Nome do Advogado ou Número do Processo" required>
+
+      <label for="uf">UF:</label>
+      <input type="text" id="uf" placeholder="UF" required>
+
+      <label for="monitoramento">Deseja monitoramento?</label>
+      <select id="monitoramento">
+        <option value="sim">Sim</option>
+        <option value="nao">Não</option>
+      </select>
+
+      <label for="intervalo">Intervalo de Monitoramento:</label>
+      <input type="number" id="intervalo" placeholder="Ex: 15" required>
+
+      <label for="unidade">Unidade:</label>
+      <select id="unidade">
+        <option value="minutos">Minutos</option>
+        <option value="horas">Horas</option>
+        <option value="dias">Dias</option>
+      </select>
+
+      <button type="submit">Cadastrar Tarefa</button>
+    </form>
+
+    <div id="message"></div>
+  </div>
+
+  <script>
+    const token = localStorage.getItem('token');
+    const username = localStorage.getItem('username');
+    document.getElementById('user-name').innerText = username;
+    document.getElementById('user-welcome').innerText = username;
+
+    function logout() {
+      localStorage.clear();
+      window.location.href = '/';
+    }
+
+    async function cadastrarTarefa(event) {
+      event.preventDefault();
+      const tipo = document.getElementById('tipo').value;
+      const nome = document.getElementById('nome').value;
+      const uf = document.getElementById('uf').value;
+      const monitoramento = document.getElementById('monitoramento').value;
+      const intervalo = document.getElementById('intervalo').value;
+      const unidade = document.getElementById('unidade').value;
+
+      const response = await fetch(`/api/monitoramento-processual/consulta/inserir-tarefa?tipo=${tipo}&nome=${nome}&uf=${uf}&monitoramento=${monitoramento}&intervalo=${intervalo}&unidade=${unidade}`, {
+        method: 'POST',
+        headers: { 'Authorization': `Bearer ${token}` }
+      });
+
+      const result = await response.json();
+      const msg = document.getElementById('message');
+      msg.innerText = result.message || result.detail || 'Erro ao cadastrar.';
+      msg.style.color = response.ok ? 'green' : 'red';
+
+      if (response.ok) {
+        document.querySelector('form').reset();
+      }
+    }
+  </script>
+</body>
+</html>

static/user_config.html

@@ -0,0 +1,136 @@
+<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Configuração do Usuário</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      background-color: #f8f9fa;
+      margin: 0;
+      padding: 0;
+    }
+
+    .container {
+      max-width: 500px;
+      margin: 40px auto;
+      padding: 30px;
+      background-color: white;
+      border-radius: 10px;
+      box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+    }
+
+    h2 {
+      margin-bottom: 20px;
+      color: #003366;
+    }
+
+    form {
+      margin-bottom: 30px;
+    }
+
+    label {
+      display: block;
+      margin-bottom: 5px;
+      font-weight: bold;
+    }
+
+    input[type="text"],
+    input[type="password"] {
+      width: 100%;
+      padding: 10px;
+      margin-bottom: 15px;
+      border: 1px solid #ccc;
+      border-radius: 5px;
+    }
+
+    button {
+      background-color: #003366;
+      color: white;
+      padding: 10px 15px;
+      border: none;
+      border-radius: 5px;
+      cursor: pointer;
+    }
+
+    button:hover {
+      background-color: #0052a3;
+    }
+
+    .message {
+      margin-top: 10px;
+      font-weight: bold;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h2>Atualizar Nome de Usuário</h2>
+    <form id="username-form">
+      <label for="newUsername">Novo Nome de Usuário:</label>
+      <input type="text" id="newUsername" required />
+      <button type="submit">Atualizar</button>
+      <div id="usernameMessage" class="message"></div>
+    </form>
+
+    <h2>Atualizar Senha</h2>
+    <form id="password-form">
+      <label for="currentPassword">Senha Atual:</label>
+      <input type="password" id="currentPassword" required />
+
+      <label for="newPassword">Nova Senha:</label>
+      <input type="password" id="newPassword" required />
+
+      <button type="submit">Atualizar</button>
+      <div id="passwordMessage" class="message"></div>
+    </form>
+  </div>
+
+  <script>
+    const token = localStorage.getItem("token");    ;
+
+    document.getElementById("username-form").addEventListener("submit", async (e) => {
+      e.preventDefault();
+      const newUsername = document.getElementById("newUsername").value;
+
+      const res = await fetch("/api/monitoramento-processual/config/usuario/username", {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({ new_username: newUsername }),
+      });
+
+      const data = await res.json();
+      const msgDiv = document.getElementById("usernameMessage");
+      msgDiv.textContent = data.message || data.detail;
+      msgDiv.style.color = res.ok ? "green" : "red";
+    });
+
+    document.getElementById("password-form").addEventListener("submit", async (e) => {
+      e.preventDefault();
+      const currentPassword = document.getElementById("currentPassword").value;
+      const newPassword = document.getElementById("newPassword").value;
+
+      const res = await fetch("/api/monitoramento-processual/config/usuario/password", {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+          current_password: currentPassword,
+          new_password: newPassword,
+        }),
+      });
+
+      const data = await res.json();
+      const msgDiv = document.getElementById("passwordMessage");
+      msgDiv.textContent = data.message || data.detail;
+      msgDiv.style.color = res.ok ? "green" : "red";
+    });
+  </script>
+</body>
+</html>

user_autentication/user_bd.py

@@ -0,0 +1,21 @@
+import sqlite3
+
+
+def initialize_user_table():
+    conn = sqlite3.connect("monitoramento.db")
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS usuarios (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT UNIQUE NOT NULL,
+            senha_hash TEXT NOT NULL,
+            nome TEXT,
+            sobrenome TEXT,
+            email TEXT
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+# Chama a função logo ao iniciar
+initialize_user_table()

user_autentication/user_hash.py

@@ -0,0 +1,51 @@
+import logging
+from passlib.context import CryptContext
+from jose import jwt, JWTError
+from datetime import datetime, timedelta, timezone
+
+# Configurações
+SECRET_KEY = "chave-super-secreta"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 10
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# Logger setup
+logger = logging.getLogger("auth")
+logger.setLevel(logging.INFO)
+handler = logging.StreamHandler()
+formatter = logging.Formatter("[%(asctime)s] %(levelname)s [%(name)s] - %(message)s", "%Y-%m-%d %H:%M:%S")
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+def verificar_senha(senha_pura, senha_hash):
+    return pwd_context.verify(senha_pura, senha_hash)
+
+def gerar_hash(senha):
+    return pwd_context.hash(senha)
+
+def criar_token(data: dict):
+    to_encode = data.copy()
+    expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    logger.info(f"Token criado para usuário: {data.get('sub')}")
+    return encoded_jwt
+
+def verificar_token(token: str):
+    logger.info(f"Token recebido para verificação: {token}")
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM], options={"verify_exp": False})
+        logger.info(f"Payload decodificado: {payload}")
+        username = payload.get("sub")
+        if username is None:
+            logger.error("Campo 'sub' ausente no token!")
+            raise Exception("Token inválido")
+        logger.info(f"Token válido para usuário: {username}")
+        return username
+    except JWTError as e:
+        logger.error(f"Erro JWT ao decodificar: {str(e)}")
+        raise Exception("Token inválido ou expirado")
+    except Exception as e:
+        logger.error(f"Erro geral na verificação do token: {str(e)}")
+        raise Exception("Token inválido ou expirado")

user_autentication/verificar_token.py

@@ -0,0 +1,15 @@
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from user_autentication.user_hash import verificar_token
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/monitoramento-processual/login")
+
+def get_current_user(token: str = Depends(oauth2_scheme)):
+    try:
+        username = verificar_token(token)
+        return username
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Token inválido ou expirado"
+        )

user_configuration/user_config.py

@@ -0,0 +1,62 @@
+import sqlite3
+from fastapi import HTTPException, status
+from src.models import UserUpdatePassword, UserUpdateUsername
+
+from user_autentication.user_hash import gerar_hash, verificar_senha
+
+
+async def trocar_username(usuario_atual: str, novo_username: str):
+    conn = sqlite3.connect("monitoramento.db")
+    cursor = conn.cursor()
+
+    # Verifica se o novo username já existe
+    cursor.execute("SELECT username FROM usuarios WHERE username = ?", (novo_username,))
+    if cursor.fetchone():
+        conn.close()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Nome de usuário já está em uso."
+        )
+
+    # Atualiza o username no banco
+    cursor.execute("UPDATE usuarios SET username = ? WHERE username = ?", (novo_username, usuario_atual))
+    if cursor.rowcount == 0:
+        conn.close()
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Usuário atual não encontrado."
+        )
+
+    conn.commit()
+    conn.close()
+    return {"message": "Username atualizado com sucesso."}
+
+
+async def trocar_senha(usuario_atual: str, senha_atual: str, nova_senha: str):
+    conn = sqlite3.connect("monitoramento.db")
+    cursor = conn.cursor()
+
+    # Busca hash da senha atual
+    cursor.execute("SELECT senha_hash FROM usuarios WHERE username = ?", (usuario_atual,))
+    row = cursor.fetchone()
+    if not row:
+        conn.close()
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Usuário não encontrado."
+        )
+
+    senha_hash = row[0]
+    if not verificar_senha(senha_atual, senha_hash):
+        conn.close()
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Senha atual incorreta."
+        )
+
+    # Atualiza com nova senha
+    nova_hash = gerar_hash(nova_senha)
+    cursor.execute("UPDATE usuarios SET senha_hash = ? WHERE username = ?", (nova_hash, usuario_atual))
+    conn.commit()
+    conn.close()
+    return {"message": "Senha atualizada com sucesso."}

utils/util.py

@@ -0,0 +1,25 @@
+import random
+
+HEADERS = [
+    {
+        'Sec-Ch-Ua': '"Chromium";v="122", "Not(A:Brand";v="24", "Microsoft Edge";v="122"',
+        'Sec-Ch-Ua-Mobile': '?0',
+        'Sec-Ch-Ua-Platform': '"Windows"',
+        'Upgrade-Insecure-Requests': '1' ,
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0',
+    },
+    {
+        'Sec-Ch-Ua': '"Not_A Brand";v="8", "Chromium";v="120", "Opera GX";v="106"',
+        'Sec-Ch-Ua-Mobile': '?0',
+        'Sec-Ch-Ua-Platform': '"Windows"',
+        'Upgrade-Insecure-Requests': '1' ,
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 OPR/106.0.0.0',
+    }
+]
+
+#----------------- Headers data -----------------------------------
+def get_headers():
+    # 0: Brave broser headers
+    # 1: Firefox browser headers
+    # 2: Google Chrome browser headers
+    return HEADERS[random.randint(0, 1)]