Zion

O Desafio

Processar, limpar e validar dados financeiros de múltiplos convênios (INSS, Zetra, Consiglog, etc.) é um processo manual, lento e suscetível a erros. Cada convênio possui arquivos com layouts diferentes, regras de negócio distintas e nomes de colunas inconsistentes.

Era necessário criar uma ferramenta centralizada que pudesse não apenas limpar esses arquivos de forma inteligente, mas também validá-los de forma robusta contra um banco de dados, aplicando regras de negócio complexas via SQL.

A Solução: Aplicação Desktop Zion

Desenvolvi o "Zion", uma aplicação desktop completa em Python (PyQt5) que unifica o fluxo de tratamento de dados financeiros em duas abas principais:

• Interface Gráfica (PyQt5): Design moderno e intuitivo dividido em "Limpeza de Planilhas" e "Validador de Convênios".
• Módulo de Limpeza Dinâmico: Permite ao usuário selecionar um tipo de limpeza (ex: "Orbital"). A aplicação então usa um dicionário de regras (`regras_limpeza.py`) para aplicar transformações específicas.
• Módulo de Validação (SQL): O usuário seleciona um convênio (ex: "INSS") e a interface exibe dinamicamente os arquivos necessários para o upload, com base no `configuracoes.py`.
• Processamento em Banco (ETL): A aplicação carrega os arquivos CSV/Excel para tabelas em um banco de dados PostgreSQL, usando schemas pré-definidos (`criacao_tabelas.py`) ou gerando-os dinamicamente.
• Execução de Regras de Negócio: Após o carregamento, o Zion executa scripts SQL transacionais específicos para cada convênio (`validacao_base.py`), realizando as validações e cálculos complexos.
• Configuração Segura: Inclui um modal de configurações onde o usuário pode definir e testar os parâmetros de conexão (Host, Porta, DB, Usuário, Senha).

Interface da Aplicação

Visualização das principais funcionalidades do Zion.

Código em Destaque

Trecho do `validacao_base.py` que orquestra o processo de validação. Ele demonstra como o sistema busca as configurações de conexão, se conecta ao banco (Psycopg2), importa os dados e executa os scripts SQL em etapas transacionais (commit/rollback).

import psycopg2
from psycopg2 import sql
from design.settings_manager import get_db_config

def run_validation_process(
    convenio,
    file_paths,
    output_path,
    progress_callback=None,
    **kwargs
):
    conn = None
    try:
        if progress_callback:
            progress_callback.emit(5, "Conectando...")

        current_db_config = get_db_config()
        conn = psycopg2.connect(**current_db_config)
        cur = conn.cursor()

        for i, (table_name, file_path) in enumerate(file_paths.items()):
            progress = 10 + int((i / len(file_paths)) * 65)
            if progress_callback:
                progress_callback.emit(progress, f"Importando '{table_name}'...")
            import_csv_to_postgres(conn, cur, table_name, file_path, convenio)

        if progress_callback:
            progress_callback.emit(75, "Executando script principal...")

        conn.autocommit = False
        cur.execute("BEGIN;")

        try:
            for i, step in enumerate(steps):
                if progress_callback:
                    progress_callback.emit(step_progress, f"SQL: {step['name']}...")
                
                if step['sql'].strip():
                     cur.execute(step['sql'])

            conn.commit()
            print("Script SQL executado com sucesso.")

        except Exception as e_sql:
             conn.rollback()
             raise Exception(f"Erro na etapa SQL '{step['name']}':\n{e_sql}")

        finally:
            conn.autocommit = True
        
    except psycopg2.Error as e:
        if conn:
            conn.rollback()
        if "password authentication failed" in str(e):
             raise Exception("Erro de Banco de Dados: Autenticação falhou.")
    
    finally:
        if conn:
            cur.close()
            conn.close()