Instalação e Setup

pip install Flask Flask-SQLAlchemy Flask-Login Flask-SocketIO APScheduler pandas openpyxl requests beautifulsoup4 cryptography Werkzeug==2.3.7 concurrent-log-handler pytz urllib3

python app.py

Arquitetura do Sistema

A aplicação é dividida em componentes claros e coesos. O diagrama abaixo ilustra o fluxo de informação entre as principais partes do sistema e o mundo externo, destacando o servidor Flask como o orquestrador central.

Backend: app.py - Coração do Servidor

Este é o arquivo principal que inicializa a aplicação Flask, define as rotas da API, gerencia a comunicação em tempo real via Flask-SocketIO e orquestra todas as operações de automação e scraping.

• Configuração: Inicializa Flask, SQLAlchemy, Flask-Login e Flask-SocketIO. Define diretórios de arquivos (saída, uploads, logs) e configura o logging para registro de eventos.
• Decorators de Permissão: Controla o acesso a diferentes rotas com base nos papéis (`Admin`, `Controlador`, `Financeiro`) e no status de `is_genesis` do usuário, garantindo a segurança.
• `AplicacaoScraper`: Classe central que encapsula toda a lógica de estado, execução, parada e comunicação do scraper. Roda em uma thread separada para manter a UI responsiva.
• Descoberta Automática de IDs: Através de _perform_id_discovery, o sistema busca e atualiza a base de IDs de profissionais no profissionais.json, garantindo que o scraper trabalhe com os dados mais recentes.
• Processamento Paralelo: Utiliza multiprocessing.Pool para coletar dados de múltiplos IDs simultaneamente através da função extrair_dados_paralelo.
• Geração de Relatórios: Cria relatórios detalhados em .xlsx e .html para cada lote e um relatório consolidado no final da varredura.
• Sistema de Notificações: Envia alertas e mensagens de sucesso/erro para os administradores em tempo real através de create_notification.
• Gerenciamento de Snapshots: Permite criar "cópias de segurança" do banco de dados de cache e dos relatórios em um ponto específico no tempo, facilitando a auditoria e a recuperação.
• API de Análises Avançadas: Contém as rotas para o Dashboard Admin, Análise de Churn, Análise de Coorte, Empenhos Frequentes, Engajamento por Serviço/Cliente e Análise de Horas Extras.
• Módulo Financeiro: Orquestra o processamento de planilhas de pagamento e a geração de planilhas Santander, delegando a lógica principal ao payment_sheet_service.py.

# Exemplo simplificado de inicialização e orquestração em app.py
from flask import Flask, render_template
from flask_socketio import SocketIO
import threading # Importado para a AplicaçãoScraper

app = Flask(__name__)
# ... configs ...
socketio = SocketIO(app, async_mode='threading')

class AplicacaoScraper:
    def __init__(self, socketio_instance, notification_callback):
        self.socketio = socketio_instance
        self.notification_callback = notification_callback
        self.status = {} # Estado atual do scraping
        # ... outros atributos ...

    def executar_processo_principal(self, email, password, force_scan, ids_to_process=None):
        self.notification_callback('info', 'Processo de scraping iniciado!')
        # ... lógica de login, coleta, processamento de lotes ...
        self.socketio.emit('status_update', self.status) # Atualiza o frontend

# Instanciação e execução
scraper_app = AplicacaoScraper(socketio, notification_callback=lambda level, msg: print(f"Notificação: {level} - {msg}")) # Simplificado para o exemplo
if __name__ == '__main__':
    # ... setup_default_settings() ...
    socketio.run(app, host='0.0.0.0', port=5000, debug=False)
                    

Backend: auth.py - Modelos de Dados

Este arquivo define a estrutura do banco de dados da aplicação utilizando o ORM SQLAlchemy. Cada classe de modelo corresponde a uma tabela no banco de dados, e seus atributos são as colunas.

• `User`: Armazena informações dos usuários (nome, e-mail, senha, papel/role, e se é o usuário "Gênesis").
• `Setting`: Usado para armazenar configurações chave-valor do sistema, como as credenciais do scraper e o agendamento de tarefas.
• `AuditLog`: Registra todas as ações críticas realizadas por usuários na plataforma, crucial para rastreabilidade e segurança.
• `PaymentSheetJob`: Rastreia o status de cada processamento de planilha de pagamento, incluindo nome do arquivo, status (pendente, processando, completo, falhou) e mensagens de erro.
• `SantanderSheetJob`: Similar ao `PaymentSheetJob`, mas dedicado aos processos de geração de planilhas no formato Santander.
• `Notification`: Armazena notificações internas para os administradores, exibidas no painel de administração.
• `EngagementThreshold`: Guarda os valores configuráveis para os limiares de alerta das análises de engajamento (ex: porcentagem mínima de atividade para alerta).
• `ProfessionalMonthlySummary`: Armazena dados de engajamento mensal dos profissionais, usados para análises de tendência.
• `Snapshot`: Contém metadados sobre cada "fotografia" do banco de dados de cache e arquivos relacionados, incluindo o caminho para o diretório do snapshot.

# Exemplo simplificado de modelos em auth.py
from flask_sqlalchemy import SQLAlchemy
from flask_login import UserMixin
from datetime import datetime

db = SQLAlchemy()

class User(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=True) # Nome do usuário
    email = db.Column(db.String(100), unique=True, nullable=False)
    password = db.Column(db.String(200), nullable=False)
    role = db.Column(db.String(50), nullable=False, default='Visualizador')
    is_genesis = db.Column(db.Boolean, default=False, nullable=False) # Admin principal

class PaymentSheetJob(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    job_uuid = db.Column(db.String(36), unique=True, nullable=False)
    status = db.Column(db.String(20), default='pending', nullable=False)
    original_filename = db.Column(db.String(255), nullable=False)
    # ... outros campos ...

class Snapshot(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(255), nullable=False)
    file_path = db.Column(db.String(500), nullable=False, unique=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    # ... outros campos ...
                    

Backend: security.py - Criptografia

Este módulo é dedicado exclusivamente à criptografia e descriptografia de dados sensíveis, como as credenciais do scraper salvas no banco de dados.

• Geração de Chave: A chave de criptografia é derivada de forma segura a partir da `SECRET_KEY` do Flask, garantindo que ela seja única para a sua aplicação e não armazenada diretamente.
• Criptografia (`encrypt_data`): Transforma uma string legível em uma sequência de caracteres ilegíveis antes de ser salva no banco de dados.
• Descriptografia (`decrypt_data`): Converte a sequência de caracteres ilegíveis de volta para a string original quando o sistema precisa usar a informação.

# Exemplo simplificado de segurança em security.py
from cryptography.fernet import Fernet
import os
import base64

def _get_key() -> bytes:
    # A chave é gerada a partir da SECRET_KEY da aplicação Flask
    # Isso garante que a criptografia seja única para sua instalação
    password = os.environ.get('FLASK_SECRET_KEY', 'your-fallback-secret-key').encode('utf-8')
    # ... lógica de derivação de chave ...
    return base64.urlsafe_b64encode(b'derived_key_from_secret') # Exemplo simplificado

def encrypt_data(data: str) -> str:
    f = Fernet(_get_key())
    return f.encrypt(data.encode('utf-8')).decode('utf-8')

def decrypt_data(encrypted_data: str) -> str:
    f = Fernet(_get_key())
    return f.decrypt(encrypted_data.encode('utf-8')).decode('utf-8')
                    

Backend: payment_sheet_service.py

Este módulo de serviço encapsula toda a complexa lógica de negócio para o processamento de planilhas financeiras. Ele é projetado para ser independente, recebendo um arquivo de entrada e produzindo os arquivos de saída (planilhas processadas) e logs detalhados.

• Processamento Flexível: Aceita planilhas para calcular valores de pagamento com base em um conjunto de regras de negócio configuráveis.
• Geração Santander: Possui uma funcionalidade dedicada (generate_santander_sheets_and_zip_service) para converter planilhas de origem em arquivos no formato exigido pelo Banco Santander, gerando um ZIP com os arquivos para diferentes regimes de trabalho (Intermitente por empresa e Freelance).
• Regras Especiais: Antes de aplicar as regras padrão, o serviço verifica regras_especiais.json para aplicar qualquer lógica de exceção específica (ex: um valor fixo para um funcionário ou cliente particular).
• Limpeza e Normalização: Funções como normalizar_texto, clean_and_truncate e abreviar_servico garantem que os dados sejam padronizados e adequados aos requisitos de sistemas externos.
• Log Detalhado: Registra cada alteração de valor e o método de cálculo usado, gerando logs em formato .txt e .html para auditoria e depuração.

# Exemplo simplificado de uma função de cálculo de valor
# payment_sheet_service.py
import openpyxl
# ... outras imports e classes ...

def calcular_valor_dispatcher(dados: DadosLinha, summary: ExecutionSummary, regras: list) -> Optional[float]:
    # Prioriza regras especiais
    valor_especial = processar_regras_especiais(dados, CalculadoraBase(dados), regras)
    if valor_especial is not None:
        summary.calculos_por_tipo["Regra Especial"] = summary.calculos_por_tipo.get("Regra Especial", 0) + 1
        return valor_especial
        
    # Lógica de cálculo padrão baseada no cliente e serviço
    if dados.cliente_normalizado.startswith("INDIGO"):
        return CalculadoraIndigo(dados).calcular()
    elif any(termo in dados.cliente_normalizado for termo in config.TERMOS_PARANA_ES):
        return CalculadoraParana(dados).calcular()
    else:
        return CalculadoraEstapar(dados).calcular()

def generate_santander_sheets_and_zip_service(caminho_entrada: str, pasta_saida: str) -> tuple[str, List[str]]:
    # ... lógica de carregamento, consolidação e geração de Excel para Santander ...
    # Retorna o nome do arquivo ZIP gerado e quaisquer erros
    pass
                    

Backend: config.py - Regras de Negócio

Este arquivo centraliza todas as tabelas de valores, adicionais noturnos e palavras-chave de categorização. Ele não contém lógica de programação, apenas dados, o que facilita a atualização das regras de negócio sem a necessidade de modificar o código principal do sistema.

• Tabelas de Valores (`VALORES_INDIGO`, `VALORES_ESTAPAR_CAPITAL`, `VALORES_LIMPEZA`, etc.): Definem os valores de pagamento por hora/diária para diferentes funções, clientes e regimes de trabalho (freelance, intermitente).
• Adicionais Noturnos (`ADICIONAL_PADRAO`, `ADICIONAL_MANOBRISTA`): Especificam os valores de adicionais noturnos por hora e por tipo de serviço.
• Palavras-chave (`PALAVRAS_MANOBRISTA`, `TERMOS_INTERIOR`, `TERMOS_PARANA_ES`, etc.): Listas de termos usadas para categorizar automaticamente serviços e clientes, direcionando-os para as tabelas de valores corretas.

# Exemplo de como as tabelas de valores são definidas
# config.py
VALORES_INDIGO = {
    "capital": {
        "orientacao": {
            8:  {"freelance": 90.00,  "intermitente": 115.00},
            10: {"freelance": 105.00, "intermitente": 130.00},
            12: {"freelance": 135.00, "intermitente": 160.00},
        },
        "manobrista": {
            8:  {"freelance": 110.00, "intermitente": 140.00},
            # ...
        }
    },
    "interior": {
        # ...
    }
}

PALAVRAS_MANOBRISTA = ["MANOBRISTA", "MENSALISTA (COM CNH)", "MENSALISTA DIURNO (COM CNH)", ...]
TERMOS_PARANA_ES = ["PARANA", "CE MED LIFE VIX MALL", "ED COM PETRO TOWER - ERES"]
                    

Backend: regras_especiais.json

Este arquivo no formato JSON permite definir regras de exceção de forma declarativa, sem a necessidade de modificar o código Python. O sistema lê este arquivo a cada processamento, permitindo que novas regras personalizadas sejam adicionadas ou ajustadas "a quente".

• Flexibilidade: Permite criar lógicas de cálculo específicas para casos que não se encaixam nas regras gerais do `config.py`.
• Estrutura da Regra: Cada regra possui uma lista de condicoes (definindo o campo, operador e valor) e uma acao (indicando o tipo de cálculo, tabela ou valor fixo a ser aplicado se as condições forem satisfeitas).
• Prioridade: As regras definidas aqui são avaliadas antes das regras padrão do `config.py`, funcionando como exceções à regra.

{
  "regras": [
    {
      "nome_regra": "Supervisor por Nome no Zoológico",
      "condicoes": [
        {
          "campo": "cliente_normalizado",
          "operador": "igual",
          "valor": "INDIGO SP - ZOOLOGICO"
        },
        {
          "campo": "nome_normalizado",
          "operador": "contem",
          "valor": "LAYSA" 
        }
      ],
      "acao": {
        "tipo": "calculo_tabela_dinamica",
        "tabela": "VALORES_SUPERVISOR",
        "adicional": "especial"
      }
    },
    {
      "nome_regra": "Valor Fixo para Reinaldo Macedo Costa",
      "condicoes": [
        {
          "campo": "nome_normalizado",
          "operador": "igual",
          "valor": "REINALDO MACEDO COSTA"
        }
      ],
      "acao": {
        "tipo": "valor_fixo",
        "valor": 200.00
      }
    }
  ]
}
                    

Frontend: Arquivos HTML

Os arquivos HTML definem a estrutura de cada página da aplicação. Eles são renderizados pelo backend Flask e utilizam o motor de templates Jinja2 para exibir dados dinâmicos e controlar o fluxo de exibição de conteúdo.

• `login.html`: A página de autenticação, com campos de e-mail e senha, e a opção de lembrar o usuário. Possui um design limpo e responsivo.
• `index.html`: O dashboard principal, onde o usuário pode iniciar/parar varreduras, monitorar o progresso em tempo real, visualizar logs e acessar relatórios gerados.
• `admin.html`: A "casca" do Painel de Administração. É uma página única que contém todas as seções administrativas (usuários, análises, ferramentas, logs, etc.), que são exibidas ou ocultadas e preenchidas dinamicamente pelo admin.js.
• `professional_profile.html`: Uma página dedicada a exibir uma análise aprofundada de um único profissional, incluindo seus KPIs de desempenho, gráficos de assiduidade e um histórico detalhado de empenhos.
• `documentacao.html`: O arquivo que você está lendo! Ele serve como o guia completo do sistema, explicando cada componente e funcionalidade.

Frontend: script.js - Lógica do Dashboard

Este arquivo JavaScript é responsável pela interatividade da página principal (index.html). Sua principal função é estabelecer a comunicação em tempo real com o servidor Flask e atualizar a interface do usuário com os dados de status do scraping.

• Conexão WebSocket: Utiliza Socket.IO para manter uma conexão persistente com o servidor, permitindo que o backend "empurre" atualizações de status sem a necessidade de recarregar a página.
• Atualização da UI em Tempo Real: Escuta eventos como 'status_update' (para progresso, logs, estatísticas) e 'run_finished' (para recarregar o histórico) e chama funções para redesenhar a interface.
• Gerenciamento do Formulário: Lida com o envio do formulário de início de varredura, botões de parar e reprocessar falhas.
• Persistência de Credenciais: Salva e carrega e-mail e senha do scraper no localStorage se a opção "Lembrar-me" estiver marcada.
• Gráfico de Atividade: Inicializa e atualiza um gráfico (Chart.js) que mostra a atividade de profissionais ao longo do tempo.
• Tabela de Histórico: Gerencia a tabela de histórico de execuções com DataTables, incluindo a formatação de status e duração.

// Trecho de script.js mostrando a conexão WebSocket e atualização da UI
document.addEventListener('DOMContentLoaded', () => {
    // ... seletores de elementos ...

    function connectWebSocket() {
        const socket = io();
        socket.on('connect', () => console.log('Conectado ao servidor via WebSocket.'));
        
        socket.on('status_update', (data) => updateUI(data)); // Atualiza o dashboard principal
        socket.on('run_finished', () => fetchHistory()); // Recarrega a tabela de histórico
    }

    function updateUI(data) {
        // Atualiza a mensagem de status e as barras de progresso
        document.getElementById('status-message').textContent = data.message;
        document.getElementById('overall-progress-bar').style.width = `\${data.overall_progress}%`;
        
        // Atualiza estatísticas (sucesso, falhas, etc.)
        document.getElementById('stats-success').textContent = data.stats.success || 0;
        
        // Adiciona novas linhas ao log em tempo real
        document.getElementById('log-container').innerHTML = data.log.map(line => `<div>\${line}</div>`).join('');
        
        // Atualiza o gráfico de atividade mensal
        if (data.chart_data && activityChart) {
            activityChart.data.labels = data.chart_data.labels || [];
            activityChart.data.datasets[0].data = data.chart_data.data || [];
            activityChart.update();
        }
    }

    connectWebSocket(); // Inicia a conexão WebSocket ao carregar a página
    // ... outras inicializações de UI ...
});
                    

Frontend: admin.js - Lógica do Painel Admin

Este é o arquivo JavaScript mais extenso e complexo da aplicação. Ele gerencia toda a interatividade e a lógica do painel de administração (admin.html), transformando-o em uma aplicação web dinâmica e responsiva.

• Navegação por Abas e Menus: Controla a exibição e o carregamento dinâmico do conteúdo entre as diferentes seções (Dashboard, Análise, Usuários, Ferramentas, etc.) através de um sistema de abas e menus recolhíveis (`collapsible`).
• Atualizações de Dashboard: Escuta eventos 'admin_dashboard_update' do servidor para manter os cards e gráficos do Dashboard Administrativo sempre atualizados.
• Gráficos e Visualizações: Inicializa e gerencia múltiplas instâncias de gráficos Chart.js para exibir dados de desempenho, atividade de usuários, saúde do cache, churn, coorte, empenhos e mais.
• Explorador de Dados Dinâmico: Implementa a lógica para filtrar, ordenar, paginar e pesquisar dados do cache em tempo real. Permite ações em massa (deletar, atualizar) e a visualização de dados de Snapshots passados.
• Gerenciamento de Usuários: Lida com a exibição, adição, edição e exclusão de usuários através de modais interativos.
• Módulo Financeiro: Gerencia o upload de planilhas, o monitoramento do histórico de processamento (jobs de cálculo e Santander), e o download dos arquivos gerados.
• Análises Avançadas Detalhadas:
  • Engajamento por Serviço/Cliente: Filtra e exibe profissionais com base em seus empenhos por serviço e cliente, com exportação para Excel.
  • Empenhos Frequentes: Identifica e analisa profissionais com alto volume de empenhos, incluindo filtros por regime, cliente e um gráfico de dispersão (`scatter plot`). Permite configurar e salvar limiares de alerta.
  • Análise de Horas Extras/Adicional Noturno: Exibe o cálculo detalhado de HE e AN para profissionais intermitentes, com gráficos e uma tabela detalhada com funcionalidade de *drill-down*.
  • Consulta por Colaborador: Implementa um campo de busca com *autocomplete* que, ao selecionar um profissional, carrega um modal com um resumo detalhado, que inclui KPIs, quebras por cliente, e um gráfico de tendência mensal de empenhos.
  • Análise de Churn e Coorte: Renderiza gráficos e tabelas para identificar profissionais em risco de inatividade e analisar padrões de retenção ao longo do tempo.
• Notificações: Exibe mensagens de feedback (toasts) e gerencia o painel de notificações do sistema.

// Trecho de admin.js mostrando a lógica de navegação e carregamento de conteúdo
document.addEventListener('DOMContentLoaded', () => {
    const navLinks = document.querySelectorAll('.admin-nav-link');
    const contentSections = document.querySelectorAll('.admin-content-section');

    navLinks.forEach(link => {
        link.addEventListener('click', (event) => {
            event.preventDefault();
            const targetId = link.getAttribute('data-target');
            activateTab(targetId); // Ativa a aba visualmente e carrega o conteúdo
        });
    });

    function activateTab(targetId) {
        navLinks.forEach(navLink => { /* ... remove classes de ativo ... */ });
        const activeLink = document.querySelector(`.admin-nav-link[data-target="\${targetId}"]`);
        activeLink?.classList.add('bg-gray-200', 'dark:bg-gray-700'); // Adiciona estilo de ativo
        
        contentSections.forEach(section => { /* ... mostra/esconde seções com animação ... */ });
        
        loadContentForTab(targetId); // Chama a função para carregar dados específicos da aba
    }

    function loadContentForTab(targetId) {
        if (targetId === 'dashboard-section') loadAdminDashboard();
        if (targetId === 'users-section') loadUsersTable();
        if (targetId === 'analytics-section') loadAnalyticsData();
        if (targetId === 'explorer-section') fetchExplorerData(true); // Recarrega dados do explorador
        // ... muitas outras chamadas para carregar dados específicos de cada aba ...
    }

    // Inicialização do explorador de dados ao carregar a página
    // fetchExplorerData(true); // Ou chamada pelo activateTab inicial
    // ... muitas outras funções para gerenciar gráficos, modais, filtros, etc. ...
});
                    

Funcionalidades Chave

Explore as principais funcionalidades que o Portal de Gestão e Automação oferece para otimizar suas operações e tomadas de decisão.

Funcionalidades: Módulo Financeiro

O módulo financeiro é uma ferramenta poderosa para automatizar o cálculo de pagamentos e a geração de planilhas bancárias.

• Cálculo de Pagamentos: Processa planilhas de origem, aplicando regras de negócio para calcular valores de pagamento por serviço e regime de trabalho. Gera relatórios detalhados.
• Geração de Planilhas Santander: Converte planilhas de pagamento em um formato específico para importação no sistema do Banco Santander, otimizando o processo de pagamentos.
• Tabelas de Valores: As regras de cálculo são baseadas em tabelas de valores configuráveis (como por cliente, serviço, horas e regime), permitindo alta flexibilidade.
• Regras Especiais: Suporta a aplicação de regras de negócio personalizadas para casos de exceção no cálculo de pagamentos.
• Histórico de Jobs: Permite acompanhar o status de cada processamento de planilha (pendente, processando, concluído, falhou) e baixar os arquivos gerados.

Funcionalidades: Análises Avançadas

A seção de Análises Avançadas oferece insights profundos sobre o desempenho e o comportamento dos profissionais, ajudando na tomada de decisões estratégicas.

• Análise de Churn: Identifica profissionais em risco de inatividade com base em seu histórico de empenhos, permitindo ações proativas.
• Análise de Coorte: Avalia a retenção de profissionais ao longo do tempo, mostrando como diferentes grupos (coortes) se engajam nos meses seguintes à sua primeira atividade.
• Empenhos Frequentes: Destaca profissionais com alto volume de empenhos em um período específico, com filtros avançados, gráficos de dispersão e a capacidade de configurar limiares de alerta para atividade mínima ou queda.
• Engajamento por Serviço/Cliente: Detalha o engajamento dos profissionais agrupados por tipo de serviço e cliente, oferecendo uma visão granular da demanda e da alocação de mão de obra, com exportação para Excel.
• Análise de Horas Extras e Adicional Noturno: Calcula e exibe o total de horas extras e adicional noturno para profissionais intermitentes em um período, com gráficos de top colaboradores e detalhes por turno.
• Consulta por Colaborador: Permite buscar um profissional específico e visualizar um perfil detalhado com KPIs de desempenho (assiduidade, frequência, score), histórico completo de empenhos e tendências mensais.

Funcionalidades: Gerenciamento do Sistema

As ferramentas de gerenciamento do sistema oferecem controle total sobre a infraestrutura e as operações da plataforma.

• Diagnóstico do Sistema: Exibe o status do agendador de varreduras, o tamanho dos bancos de dados e a existência de diretórios essenciais, facilitando a identificação de problemas.
• Agendamento de Varreduras: Permite configurar e ativar varreduras automáticas de dados usando expressões Cron, garantindo que o cache esteja sempre atualizado.
• Backup e Restauração: Funcionalidades para criar backups completos dos bancos de dados e restaurar o sistema a partir de um backup, protegendo contra perda de dados.
• Credenciais do Scraper: Gerencia as credenciais de login para o sistema Primícia, que são armazenadas de forma segura e criptografada.
• Configurações Globais: Permite ajustar parâmetros como o número de processos paralelos e a pausa entre lotes de scraping.
• Tabelas de Valores: Acesso visual às regras de cálculo configuradas no config.py.

Funcionalidades: Gerenciamento de Usuários

O painel permite um controle granular sobre o acesso e as permissões de cada usuário da plataforma.

• Gestão de Usuários: Adicione, edite (nome, e-mail, senha) e exclua usuários. O sistema possui diferentes papéis (`Admin`, `Controlador`, `Visualizador`, `Financeiro`) com níveis de acesso específicos.
• Usuário "Gênesis": O primeiro administrador criado possui privilégios especiais, sendo o único capaz de realizar certas ações críticas, como deletar outros usuários.
• Sessões Ativas: Monitore quem está conectado ao sistema em tempo real e, se necessário, force a desconexão de sessões ativas.
• Atividade de Usuários: Visualize um resumo das ações mais comuns e dos usuários mais ativos na plataforma.
• Logs de Auditoria: Um registro detalhado de todas as ações críticas realizadas no sistema, incluindo quem fez o quê e quando, essencial para segurança e conformidade.
• Notificações: Um sistema de notificações internas mantém os administradores informados sobre eventos importantes do sistema em tempo real.

Funcionalidades: Explorador de Dados

O Explorador de Dados é uma ferramenta poderosa para consultar, filtrar e analisar os dados brutos do cache de forma flexível.

• Filtros Avançados: Aplique múltiplos filtros por diversos campos (nome, ID, status, regime, empresa, cliente, serviço no histórico) para refinar a busca.
• Pesquisa Rápida: Busque rapidamente por nome ou ID de profissional em toda a base de dados.
• Paginação e Ordenação: Navegue por grandes volumes de dados de forma eficiente, com opções de paginação e ordenação por colunas.
• Ações em Massa: Selecione múltiplos itens para realizar ações como deletar ou forçar a atualização dos dados do cache.
• Visualização de Snapshots: Explore os dados do cache de um snapshot específico, permitindo analisar o histórico do sistema em diferentes pontos no tempo.
• Exportação: Exporte os dados filtrados para um arquivo Excel para análises offline.

Funcionalidades: Construtor de Relatórios

O Construtor de Relatórios permite que você crie relatórios personalizados em formato Excel, selecionando as colunas e aplicando os filtros que desejar.

• Seleção de Colunas: Escolha exatamente quais informações você quer incluir no seu relatório (ID, Nome, Status, Regime de Trabalho, Empresa, Data do Cache, etc.).
• Filtros Customizados: Adicione filtros específicos (contém, igual a) para refinar os dados que aparecerão no relatório, garantindo que você tenha apenas as informações relevantes.
• Exportação para Excel: Gere e baixe o relatório personalizado em formato .xlsx, pronto para suas análises.

Fluxo Completo de Automação

O diagrama abaixo ilustra o fluxo completo de uma execução de scraping, desde o comando do usuário (ou agendador) até a geração e persistência dos relatórios e dados.

Glossário de Termos

FAQ e Solução de Problemas