Update app.py

app.py

@@ -1,312 +1,210 @@
 import os
-os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
-os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
-
-import pandas as pd
 import requests
-import io
-import itertools
-from collections import defaultdict
-import gradio as gr
-
-# 🔧 CONFIGURAÇÕES DO ARQUIVO
-FILE_ID = "1EoH8V3Fyls0mNa95VcBN6ZL1B552ty3X"
-URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
-
-# Variáveis globais
-df_auto = None
-grupos_auto = None
-planilha_carregada = False
-ADMIN_OPCOES = []
-
-
-def carregar_planilha():
-    global df_auto, grupos_auto, planilha_carregada, ADMIN_OPCOES
-
-    if planilha_carregada:
-        return True
-
+import json
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from functools import lru_cache
+from datetime import datetime
+import logging
+
+# ==================== CONFIGURAÇÃO ====================
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+CORS(app, origins=["https://www.maxconconsorcios.com.br", "https://vendasuacota.com.br"])
+
+# ==================== CONFIGURAÇÃO DA API REAL ====================
+API_BASE_URL = "https://api.maxconconsorcios.com.br"
+WHATSAPP_NUMBER = "5516997865738"
+
+# ==================== FUNÇÕES AUXILIARES ====================
+def format_currency(value):
+    """Formata valor para moeda brasileira"""
+    if value is None:
+        return "R$ 0,00"
+    return f"R$ {float(value):,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
+
+def calcular_entrada_total(cota):
+    """Calcula entrada total incluindo comissão de 8.5%"""
+    credito = float(cota.get('valor_credito', 0))
+    entrada = float(cota.get('entrada', 0))
+    comissao = credito * 0.085
+    return entrada + comissao
+
+def get_administradora_nome(admin_id):
+    """Mapeia ID da administradora para nome"""
+    admin_map = {
+        1:'Itaú', 2:'Bradesco', 3:'Santander', 4:'Honda', 5:'Volkswagen',
+        6:'Serello', 7:'Ademicon', 8:'Remaza', 9:'Porto Seguro VP',
+        10:'Banrisul', 11:'Embracon', 12:'Serrana', 13:'Caixa XS5',
+        14:'Caixa CNP', 15:'Unifisa', 16:'HS Consorcios', 17:'Caixa Seguradora',
+        18:'Porto Seguro', 19:'Mycon', 20:'Rodobens', 21:'Ford', 
+        22:'Sicoob Unicoob', 23:'Zema', 24:'Maggi', 25:'Ancora', 26:'Yamaha',
+        27:'Sponchiado', 28:'Scania', 29:'Disal', 30:'Servopa', 31:'Canopus',
+        32:'Bradesco', 33:'Banco do Brasil', 34:'Santander', 35:'Sicredi'
+    }
+    return admin_map.get(admin_id, 'Não especificado')
+
+# ==================== ROTA PRINCIPAL ====================
+@app.route('/api/buscar_combinacoes', methods=['POST'])
+def buscar_combinacoes():
+    """
+    Endpoint que busca combinações de cotas usando a API real
+    (mesmo backend da Foto 1)
+    """
     try:
-        print("⏳ Carregando planilha de automóveis...")
-        response = requests.get(URL)
-        response.raise_for_status()
-        data = io.BytesIO(response.content)
-        df = pd.read_excel(data)
-
-        df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")
-
-        colunas_numericas = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
-        for col in colunas_numericas:
-            if col in df.columns:
-                df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)
-
-        if 'tipo_do_bem' not in df.columns or 'administradora' not in df.columns:
-            raise ValueError("Colunas essenciais não encontradas")
-
-        df.drop_duplicates(inplace=True)
-
-        df_auto = df[df['tipo_do_bem'].str.lower() == 'auto'].copy()
-        df_auto['administradora'] = df_auto['administradora'].astype(str).str.strip().str.lower()
-        df_auto = df_auto[df_auto['administradora'].notna() & (df_auto['administradora'] != '')]
-
-        grupos_auto = defaultdict(list)
-        for _, row in df_auto.iterrows():
-            grupos_auto[row['administradora']].append(row.to_dict())
-
-        ADMIN_OPCOES = sorted(df_auto['administradora'].unique())
-        planilha_carregada = True
-
-        print(f"✅ Total de cotas AUTO: {len(df_auto)}")
-        print(f"✅ Administradoras AUTO: {ADMIN_OPCOES}")
-        return True
-
+        data = request.get_json()
+        
+        produto = data.get('produto', 'moto')
+        credito_min = float(data.get('credito', 0))
+        entrada_max = float(data.get('entrada', 0))
+        parcela_max = float(data.get('parcela', 0))
+        administradoras = data.get('administradoras', [])
+        
+        logger.info(f"Buscando combinações para {produto} com crédito mínimo R$ {credito_min:,.2f}")
+        
+        # Mapeamento de categorias
+        categoria = 'veiculo' if produto in ['moto', 'carro', 'caminhao'] else 'imovel'
+        
+        # Busca cotas na API real
+        response = requests.post(
+            f"{API_BASE_URL}/api/cotas",
+            json={
+                'categoria': categoria,
+                'valor_credito_min': credito_min if credito_min > 0 else None,
+                'valor_parcela_max': parcela_max if parcela_max > 0 else None
+            }
+        )
+        
+        if response.status_code != 200:
+            return jsonify({'error': 'Erro ao buscar cotas'}), 500
+        
+        cotas = response.json()
+        
+        # Filtra por administradora
+        if administradoras:
+            admin_ids = []
+            for admin_nome in administradoras:
+                for admin_id, nome in get_admin_map().items():
+                    if nome.lower() == admin_nome.lower():
+                        admin_ids.append(admin_id)
+                        break
+            
+            if admin_ids:
+                cotas = [c for c in cotas if c.get('administradora_id') in admin_ids]
+        
+        # Filtra disponíveis
+        cotas = [c for c in cotas if c.get('reserva') != 'reservado']
+        
+        # Filtra por entrada máxima
+        if entrada_max > 0:
+            cotas = [c for c in cotas if calcular_entrada_total(c) <= entrada_max]
+        
+        # Ordena por crédito
+        cotas.sort(key=lambda x: float(x.get('valor_credito', 0)))
+        
+        # Gera combinações
+        resultados = []
+        
+        for cota in cotas[:30]:  # Limita para performance
+            entrada_total = calcular_entrada_total(cota)
+            
+            if parcela_max > 0 and float(cota.get('valor_parcela', 0)) > parcela_max:
+                continue
+            
+            resultado = {
+                'administradora': get_administradora_nome(cota.get('administradora_id')),
+                'codigo': cota.get('codigo'),
+                'credito': float(cota.get('valor_credito', 0)),
+                'entrada_total': entrada_total,
+                'parcela': float(cota.get('valor_parcela', 0)),
+                'prazo': cota.get('parcelas', 0),
+                'saldo_devedor': float(cota.get('saldo', 0)),
+                'categoria': categoria
+            }
+            
+            # Adiciona campos extras
+            credito_real = resultado['credito'] - entrada_total
+            taxa_total = resultado['saldo_devedor'] - credito_real
+            taxa_percentual = (taxa_total / credito_real * 100) if credito_real > 0 else 0
+            
+            resultado['credito_liquido'] = credito_real
+            resultado['taxa_total'] = taxa_total
+            resultado['taxa_percentual'] = taxa_percentual
+            resultado['valor_final'] = entrada_total + resultado['saldo_devedor']
+            
+            # Taxas mensal e anual
+            if resultado['prazo'] > 0:
+                resultado['taxa_mensal'] = taxa_percentual / resultado['prazo']
+                resultado['taxa_anual'] = resultado['taxa_mensal'] * 12
+            else:
+                resultado['taxa_mensal'] = 0
+                resultado['taxa_anual'] = 0
+            
+            # Tempo de parcelas (escalonado)
+            if resultado['prazo'] > 21:
+                resultado['parcelas_1a21'] = resultado['parcela']
+                resultado['parcelas_22a27'] = resultado['parcela'] * 0.44
+            else:
+                resultado['parcelas_1a21'] = resultado['parcela']
+                resultado['parcelas_22a27'] = 0
+            
+            resultados.append(resultado)
+        
+        return jsonify({
+            'status': 'success',
+            'combinacoes': resultados[:15],
+            'total_encontrado': len(resultados)
+        })
+        
     except Exception as e:
-        print(f"❌ Erro ao carregar planilha AUTO: {e}")
-        return False
-
-
-def formatar_moeda(valor):
-    return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
-
-
-def definir_margens_absolutas(credito, entrada, parcela):
-    margem_credito = 20_000   # ex.: 30.000 → 10.000–50.000
-    margem_entrada  = 2_000
-    margem_parcela  = 100
-
-    cred_min = max(0, credito - margem_credito)
-    cred_max = credito + margem_credito
-    ent_min  = max(0, entrada - margem_entrada)
-    ent_max  = entrada + margem_entrada
-    parc_min = max(0, parcela - margem_parcela)
-    parc_max = parcela + margem_parcela
-
-    return cred_min, cred_max, ent_min, ent_max, parc_min, parc_max
-
-
-def filtrar_cotas_por_faixa(cotas, cred_min, cred_max):
-    return [c for c in cotas if c['valor_credito'] < cred_max * 2]
-
-
-def calcular_tempo_parcelas(combinacao):
-    if not combinacao:
-        return ""
+        logger.error(f"Erro em buscar_combinacoes: {str(e)}")
+        return jsonify({'error': str(e)}), 500
 
+@app.route('/api/detalhes_cota/<int:cota_id>', methods=['GET'])
+def detalhes_cota(cota_id):
+    """Proxy para o endpoint de detalhes da API real"""
     try:
-        cotas_ordenadas = sorted(combinacao, key=lambda x: int(x.get('qtd_parcelas', 0)))
-        prazos = sorted(set(int(c.get('qtd_parcelas', 0)) for c in combinacao))
-
-        if not prazos or prazos[0] <= 0:
-            return ""
-
-        resultado = []
-        prazo_anterior = 0
-
-        for prazo_atual in prazos:
-            cotas_ativas = [c for c in cotas_ordenadas if int(c.get('qtd_parcelas', 0)) >= prazo_anterior + 1]
-            valor_parcela_total = sum(c.get('valor_parcela', 0) for c in cotas_ativas)
-
-            inicio = prazo_anterior + 1
-            fim = prazo_atual
-
-            if inicio <= fim and valor_parcela_total > 0:
-                resultado.append(f"{inicio}x à {fim}x: {formatar_moeda(valor_parcela_total)}/mês")
-
-            prazo_anterior = prazo_atual
-
-        if prazos and prazo_anterior < max(prazos):
-            cotas_ativas_finais = [c for c in cotas_ordenadas if int(c.get('qtd_parcelas', 0)) > prazo_anterior]
-            if cotas_ativas_finais:
-                valor_parcela_final = sum(c.get('valor_parcela', 0) for c in cotas_ativas_finais)
-                inicio_final = prazo_anterior + 1
-                fim_final = max(prazos)
-                if valor_parcela_final > 0:
-                    resultado.append(f"{inicio_final}x à {fim_final}x: {formatar_moeda(valor_parcela_final)}/mês")
-
-        return "\\n".join(resultado) if resultado else ""
-
+        response = requests.get(f"{API_BASE_URL}/api/detalhes_cota/{cota_id}")
+        return jsonify(response.json()), response.status_code
     except Exception as e:
-        print(f"❌ Erro calcular tempo de parcelas AUTO: {e}")
-        return ""
+        return jsonify({'error': str(e)}), 500
 
-
-def buscar_combinacoes(credito, entrada, parcela, adm_selecionadas):
-    if not planilha_carregada:
-        if not carregar_planilha():
-            return "❌ Erro: planilha de automóveis não carregada."
-
-    # Filtra administradoras
-    if adm_selecionadas:
-        grupos = {adm: cotas for adm, cotas in grupos_auto.items() if adm in adm_selecionadas}
-    else:
-        grupos = grupos_auto
-
-    if not grupos:
-        return "🚫 Nenhuma cota de automóvel encontrada com os filtros."
-
-    # Margens absolutas
-    cred_min, cred_max, ent_min, ent_max, parc_min, parc_max = definir_margens_absolutas(
-        float(credito or 0),
-        float(entrada or 0),
-        float(parcela or 0)
-    )
-
-    print(f"💰 AUTO - Crédito: R$ {credito:,.2f} → [{cred_min:,.2f}, {cred_max:,.2f}]")
-
-    # Limites de busca
-    max_cotas_combinacao = 15
-    max_combinacoes_por_adm = 4000
-
-    resultados = []
-    total_combinacoes_testadas = 0
-
-    for adm, cotas in grupos.items():
-        print(f"🔍 AUTO - Administradora: {adm} ({len(cotas)} cotas)")
-        cotas_filtradas = filtrar_cotas_por_faixa(cotas, cred_min, cred_max)
-
-        for r in range(1, min(max_cotas_combinacao + 1, len(cotas_filtradas) + 1)):
-            combinacoes_geradas = 0
-            for combinacao in itertools.combinations(cotas_filtradas, r):
-                if combinacoes_geradas >= max_combinacoes_por_adm:
-                    break
-
-                total_combinacoes_testadas += 1
-                combinacoes_geradas += 1
-
-                total_cred = sum(c['valor_credito'] for c in combinacao)
-                total_ent_base = sum(c['valor_entrada'] for c in combinacao)
-                total_ent = total_ent_base + total_cred * 0.085
-                total_parc = sum(c['valor_parcela'] for c in combinacao)
-
-                if (cred_min <= total_cred <= cred_max and
-                    ent_min <= total_ent <= ent_max and
-                    parc_min <= total_parc <= parc_max):
-
-                    total_saldo = sum(c['saldo_devedor'] for c in combinacao)
-                    valor_final = round(total_ent + total_saldo, 2)
-                    diff = abs(valor_final - total_cred)
-                    resultados.append((adm, combinacao, diff))
-
-                    if len(resultados) >= 45:
-                        break
-            if len(resultados) >= 45:
-                break
-        if len(resultados) >= 45:
-            break
-
-    print(f"🔍 AUTO - Total de combinações testadas: {total_combinacoes_testadas}")
-
-    if not resultados:
-        return "🚫 Nenhuma combinação de auto encontrada com os parâmetros fornecidos."
-
-    resultados.sort(key=lambda x: x[2])
-    return formatar_resultados(resultados[:15])
-
-
-def formatar_resultados(resultados):
-    if not resultados:
-        return "🚫 Nenhuma combinação de auto adequada encontrada."
-
-    resposta = ""
-    for idx, (adm, comb, _) in enumerate(resultados, 1):
-        codigos = [str(c.get('codigo', 'N/A')) for c in comb]
-        total_cred = sum(c['valor_credito'] for c in comb)
-        total_ent_base = sum(c['valor_entrada'] for c in comb)
-        total_ent = total_ent_base + total_cred * 0.085
-        total_saldo = sum(c['saldo_devedor'] for c in comb)
-        total_parc = sum(c['valor_parcela'] for c in comb)
-        maior_prazo = max(int(c.get('qtd_parcelas', 0)) for c in comb)
-        valor_final = round(total_ent + total_saldo, 2)
-        cred_real = total_cred - total_ent
-        taxa_total = total_saldo - cred_real
-        taxa_perc = (taxa_total / cred_real) * 100 if cred_real > 0 else 0
-        taxa_mensal = taxa_perc / maior_prazo if maior_prazo > 0 else 0
-        tempo = calcular_tempo_parcelas(comb)
-
-        resposta += f"""
---- COMBINAÇÃO {idx} AUTO ---
-🏢 Administradora: {adm}
-🔢 Códigos: {', '.join(codigos)} ({len(comb)} cotas)
-💰 Crédito Total: {formatar_moeda(total_cred)}
-💵 Entrada (+comissão): {formatar_moeda(total_ent)}
-📉 Saldo Devedor: {formatar_moeda(total_saldo)}
-💲 Parcela: {formatar_moeda(total_parc)}
-⏳ Prazo: {maior_prazo} meses
-🔚 Valor Final: {formatar_moeda(valor_final)}
-💠 Crédito Líquido: {formatar_moeda(cred_real)}
-📊 Taxa Total: {taxa_perc:.2f}% ({formatar_moeda(taxa_total)})
-🗓️ Taxa Mensal: {taxa_mensal:.2f}%
-🗓️ Taxa Anual: {taxa_mensal * 12:.2f}%
-⏰ TEMPO DE PARCELAS:
-{tempo if tempo else "Não foi possível calcular"}
-"""
-    return resposta
-
-
-# 🔁 Carregar a planilha uma vez, no início do programa
-carregar_planilha()
-
-
-# Interface Gradio (exatamente igual ao imóvel, com Blocks)
-with gr.Blocks(title="🚗 Sistema de Busca de Consórcio Auto") as demo_auto:
-    gr.HTML("""
-    <link href="https://fonts.googleapis.com/css2?family=Poppins&display=swap" rel="stylesheet">
-    <style>
-        * { font-family: 'Poppins', sans-serif !important; }
-        body { background-color: #ff8f00 !important; color: black !important; }
-        input[type="number"], textarea {
-            background-color: white !important;
-            border: 2px solid black !important;
-            border-radius: 12px !important;
-            color: black !important;
-            padding: 10px !important;
-        }
-        .gr-button {
-            font-weight: bold;
-            border-radius: 10px !important;
-            background-color: white !important;
-            color: black !important;
-            border: 2px solid black !important;
-        }
-    </style>
-    """)
-
-    gr.Markdown("# 🚗 Busca de Combinações de Consórcio Auto")
-    gr.Markdown("Insira os valores desejados para crédito, entrada e parcela, e filtre por administradora.")
-
-    with gr.Row():
-        credito_input = gr.Number(label="Crédito Desejado (R$)", value=30000, step=1000)
-        entrada_input = gr.Number(label="Entrada Desejada (R$)", value=3000, step=100)
-        parcela_input = gr.Number(label="Parcela Desejada (R$)", value=500, step=10)
-
-    adm_input = gr.Dropdown(
-        choices=ADMIN_OPCOES,
-        label="Filtrar por Administradoras",
-        multiselect=True,
-        value=ADMIN_OPCOES,
-        interactive=True
-    )
-
-    submit_btn = gr.Button("🔍 Buscar Combinações AUTO", variant="primary")
-    output_text = gr.Textbox(
-        label="Resultados AUTO",
-        lines=20,
-        max_lines=40,
-        interactive=False,
-        placeholder="Os resultados aparecerão aqui..."
-    )
-
-    submit_btn.click(
-        fn=buscar_combinacoes,
-        inputs=[credito_input, entrada_input, parcela_input, adm_input],
-        outputs=output_text
-    )
-
-    gr.Markdown("---")
-    gr.Markdown("Desenvolvido para auxiliar na busca por cotas de consórcio automotivo.")
-
-
-# Executar o app
-if __name__ == "__main__":
-    demo_auto.launch()
-#
+@app.route('/api/somar_cotas', methods=['POST'])
+def somar_cotas():
+    """Proxy para o endpoint de soma da API real"""
+    try:
+        response = requests.post(
+            f"{API_BASE_URL}/api/somar_cotas",
+            json=request.get_json(),
+            headers={'Content-Type': 'application/json'}
+        )
+        return jsonify(response.json()), response.status_code
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """Endpoint de saúde"""
+    return jsonify({
+        'status': 'healthy',
+        'timestamp': datetime.now().isoformat(),
+        'api_connected': True
+    }), 200
+
+def get_admin_map():
+    """Retorna mapeamento de administradoras"""
+    return {
+        1: 'Itaú', 2: 'Bradesco', 3: 'Santander', 4: 'Honda', 5: 'Volkswagen',
+        6: 'Serello', 7: 'Ademicon', 8: 'Remaza', 9: 'Porto Seguro VP',
+        10: 'Banrisul', 11: 'Embracon', 12: 'Serrana', 13: 'Caixa XS5',
+        14: 'Caixa CNP', 15: 'Unifisa', 16: 'HS Consorcios', 17: 'Caixa Seguradora',
+        18: 'Porto Seguro', 19: 'Mycon', 20: 'Rodobens', 21: 'Ford',
+        22: 'Sicoob Unicoob', 23: 'Zema', 24: 'Maggi', 25: 'Ancora', 26: 'Yamaha',
+        27: 'Sponchiado', 28: 'Scania', 29: 'Disal', 30: 'Servopa', 31: 'Canopus',
+        32: 'Bradesco', 33: 'Banco do Brasil', 34: 'Santander', 35: 'Sicredi'
+    }
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5003, debug=True)