Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

ensinar minha vo sonhar lucido, ter um novo estilo de vida pra ela e cuidar codigo:…

  1. User

    ensinar minha vo sonhar lucido, ter um novo estilo de vida pra ela e cuidar

    codigo: import os import logging import time import threading import json from pathlib import Path from dotenv import load_dotenv import telebot from telebot.types import InlineKeyboardMarkup, InlineKeyboardButton import requests

    Carregar variáveis de ambiente

    load_dotenv()

    Configuração dos logs

    logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' ) logger = logging.getLogger(name)

    Configurações a partir do .env

    TOKEN_TELEGRAM = os.getenv('TELEGRAM_TOKEN') PUSHIN_PAY_TOKEN = os.getenv("PUSHIN_PAY_TOKEN") AUDIO1_PATH = os.getenv('AUDIO1_PATH') AUDIO2_PATH = os.getenv('AUDIO2_PATH') GROUP_LINK = os.getenv('GROUP_LINK') PAGAMENTOS_FILE = Path(os.getenv('PAGAMENTOS_FILE', 'pagamentos_pendentes.json')) # Arquivo para armazenar pagamentos

    CHECK_INTERVAL = int(os.getenv('CHECK_INTERVAL', 60)) # Tempo em segundos entre as verificações MONTHLY_PRICE = float(os.getenv('MONTHLY_PRICE', 0.32)) LIFETIME_PRICE = float(os.getenv('LIFETIME_PRICE', 0.43))

    Verificar se todos os tokens e links necessários estão presentes

    if not TOKEN_TELEGRAM: logger.critical("TELEGRAM_TOKEN não está definido no .env") exit(1)

    if not PUSHIN_PAY_TOKEN: logger.critical("PUSHIN_PAY_ACCESS_TOKEN não está definido no .env") exit(1)

    if not GROUP_LINK: logger.critical("GROUP_LINK não está definido no .env") exit(1)

    bot = telebot.TeleBot(TOKEN_TELEGRAM)

    def carregar_pagamentos_pendentes() -> dict: """Carrega os pagamentos pendentes de um arquivo JSON.""" if PAGAMENTOS_FILE.exists(): try: with PAGAMENTOS_FILE.open('r') as f: pagamentos = json.load(f) logger.info("Pagamentos pendentes carregados com sucesso.") return pagamentos except json.JSONDecodeError as e: logger.error(f"Erro ao decodificar o arquivo de pagamentos: {e}") return {} except Exception as e: logger.error(f"Erro ao carregar pagamentos pendentes: {e}") return {} else: logger.info("Arquivo de pagamentos pendentes não encontrado. Criando um novo.") return {}

    def salvar_pagamentos_pendentes(pagamentos: dict): """Salva os pagamentos pendentes em um arquivo JSON.""" try: with PAGAMENTOS_FILE.open('w') as f: json.dump(pagamentos, f, indent=4) logger.info("Pagamentos pendentes salvos com sucesso.") except Exception as e: logger.error(f"Erro ao salvar pagamentos pendentes: {e}")

    def verificar_pagamento(payment_id: str) -> bool: url = f'https://app.pushinpay.com.br/{payment_id}' headers = { 'Authorization': f'Bearer {PUSHIN_PAY_TOKEN}', } response = requests.get(url, headers=headers) if response.status_code == 200: payment_status = response.json().get('status') return payment_status == 'approved' else: logger.error(f"Erro ao verificar pagamento {payment_id}: {response.text}") return False

    def remover_assinatura(chat_id: int): """Remove o status VIP do usuário e notifica.""" try: # Implementar a lógica de remoção, por exemplo, remover de um grupo VIP # Exemplo: bot.kick_chat_member(GROUP_ID, chat_id) # Para este exemplo, apenas envia uma mensagem bot.send_message( chat_id, "⚠️ Sua assinatura VIP expirou após 30 dias. Renove para continuar aproveitando os benefícios!" ) logger.info(f"Assinatura removida do chat_id: {chat_id}") except Exception as e: logger.error(f"Erro ao remover assinatura do chat_id {chat_id}: {e}")

    def verificar_pagamentos(): """Verifica periodicamente os pagamentos pendentes.""" try: pagamentos = carregar_pagamentos_pendentes() pagamentos_atualizados = pagamentos.copy() for payment_id, info in pagamentos.items(): if verificar_pagamento(payment_id): # Enviar link do grupo VIP bot.send_message( info["chat_id"], f"🎉 Obrigado pela sua assinatura! Aqui está o link para o grupo VIP: {GROUP_LINK}" ) logger.info(f"Pagamento {payment_id} aprovado. Link VIP enviado para chat_id {info['chat_id']}.")

                # Se for assinatura mensal, agendar remoção após 30 dias
                if not info["vitalicio"]:
                    tempo_para_expirar = 30 * 24 * 60 * 60  # 30 dias em segundos
                    threading.Timer(tempo_para_expirar, remover_assinatura, args=(info["chat_id"],)).start()
                    logger.info(f"Remoção agendada em 30 dias para chat_id {info['chat_id']}.")
    
                # Remover do pendentes
                pagamentos_atualizados.pop(payment_id)
    
        salvar_pagamentos_pendentes(pagamentos_atualizados)
    except Exception as e:
        logger.error(f"Erro durante a verificação de pagamentos: {e}")
    finally:
        # Reagendar a próxima verificação
        threading.Timer(CHECK_INTERVAL, verificar_pagamentos).start()
    

    def gerar_pix(valor: float, descricao: str, email: str) -> dict: url = 'https://app.pushinpay.com.br/' headers = { 'Authorization': f'Bearer {PUSHIN_PAY_TOKEN}', 'Content-Type': 'application/json' } data = { "amount": valor, "description": descricao, "payer": { "email": email } } response = requests.post(url, headers=headers, json=data) if response.status_code == 201: pix_data = response.json() qr_code = pix_data.get('qr_code') payment_id = pix_data.get('id') return {"payment_id": payment_id, "qr_code": qr_code} else: logger.error(f"Erro ao gerar PIX: {response.text}") return {}

    def gerar_botoes_assinatura() -> InlineKeyboardMarkup: """Gera os botões de assinatura.""" markup = InlineKeyboardMarkup(row_width=2) btn_mensal = InlineKeyboardButton(f"MENSAL: RMONTHLYPRICE:.2f",callbackdata="mensal")btnvitalicio=InlineKeyboardButton(f"VITALIˊCIO:R{MONTHLY_PRICE:.2f}", callback_data="mensal") btn_vitalicio = InlineKeyboardButton(f"VITALÍCIO: R{LIFETIME_PRICE:.2f}", callback_data="vitalicio") markup.add(btn_mensal, btn_vitalicio) return markup

    @bot.message_handler(commands=['start']) def send_welcome(message): """Envia a mensagem de boas-vindas e os botões de assinatura juntamente com o áudio 1.""" try: welcome_message = ( "🌟 Canal VIP Exclusivo em promoção! 🚀\n\n" "Aproveite o melhor conteúdo adulto com nosso Canal VIP! " "Mídias já postadas, atualizações frequentes e diversos temas. " f"Assine agora por apenas RMONTHLYPRICE:.2f/me^souR{MONTHLY_PRICE:.2f}/mês ou R{LIFETIME_PRICE:.2f} no plano vitalício! 🔥\n\n" "✨ Oferta por tempo limitado. ✨" ) bot.send_message(message.chat.id, welcome_message, reply_markup=gerar_botoes_assinatura()) logger.info(f"Mensagem de boas-vindas enviada para chat_id {message.chat.id}.")

        # **Alteração 1**: Enviar somente o primeiro áudio aqui
        if AUDIO1_PATH and Path(AUDIO1_PATH).exists():
            with open(AUDIO1_PATH, 'rb') as audio:
                bot.send_audio(message.chat.id, audio)
            logger.info(f"Áudio 1 enviado: {AUDIO1_PATH}")
        else:
            logger.warning(f"Arquivo de áudio 1 não encontrado ou caminho inválido: {AUDIO1_PATH}")
    except Exception as e:
        logger.error(f"Erro ao enviar mensagem de boas-vindas: {e}")
    

    @bot.callback_query_handler(func=lambda call: call.data in ["mensal", "vitalicio"]) def handle_assinatura(call): """Processa a escolha de assinatura do usuário.""" try: valor = MONTHLY_PRICE if call.data == "mensal" else LIFETIME_PRICE pix_info = gerar_pix(valor)

        if not pix_info or "qr_code" not in pix_info:
            bot.answer_callback_query(call.id, "❌ Erro ao gerar o código PIX. Tente novamente mais tarde.")
            logger.error(f"Falha ao gerar PIX para chat_id {call.message.chat.id}.")
            return
    
        # Enviar instruções e QR Code para pagamento
        instrucoes = (
            "✅ Prontinho! Para pagar, clique na chave Pix abaixo ⬇ para copiar e pague no app do seu banco.\n"
            "‼ Utilize a opção PIX Copia e Cola no seu aplicativo bancário."
        )
        bot.send_message(call.message.chat.id, instrucoes)
        bot.send_message(call.message.chat.id, pix_info["qr_code"])
        bot.answer_callback_query(call.id, "📩 Código PIX enviado!")
    
        # **Alteração 2**: Enviar o segundo áudio após a geração do PIX
        if AUDIO2_PATH and Path(AUDIO2_PATH).exists():
            with open(AUDIO2_PATH, 'rb') as audio:
                bot.send_audio(call.message.chat.id, audio)
            logger.info(f"Áudio 2 enviado: {AUDIO2_PATH}")
        else:
            logger.warning(f"Arquivo de áudio 2 não encontrado ou caminho inválido: {AUDIO2_PATH}")
    
        # Armazenar o pagamento pendente
        pagamentos = carregar_pagamentos_pendentes()
        pagamentos[pix_info["payment_id"]] = {
            "chat_id": call.message.chat.id,
            "vitalicio": call.data == "vitalicio",
            "valor": valor,
            "data_assinatura": time.time()
        }
        salvar_pagamentos_pendentes(pagamentos)
        logger.info(f"Pagamento pendente armazenado: {pix_info['payment_id']} para chat_id {call.message.chat.id}")
    except Exception as e:
        logger.error(f"Erro ao processar assinatura para chat_id {call.message.chat.id}: {e}")
        bot.answer_callback_query(call.id, "❌ Ocorreu um erro ao processar sua assinatura.")
    

    def run_bot(): """Inicia o bot e a verificação de pagamentos.""" try: # Iniciar a verificação de pagamentos em uma thread separada threading.Thread(target=verificar_pagamentos, daemon=True).start() logger.info("Iniciada a verificação periódica de pagamentos pendentes.")

        # Iniciar o polling do bot
        logger.info("Iniciando o bot...")
        bot.infinity_polling(timeout=20, interval=0, long_polling_timeout=20)
    except Exception as e:
        logger.critical(f"Erro crítico ao iniciar o bot: {e}")
    

    if name == "main": run_bot()

    erro: 2024-10-06 00:24:00,114 - main - INFO - Iniciada a verificação periódica de pagamentos pendentes. 2024-10-06 00:24:00,114 - main - INFO - Iniciando o bot... 2024-10-06 00:24:00,116 - main - INFO - Pagamentos pendentes carregados com sucesso. 2024-10-06 00:24:00,208 - main - ERROR - Erro ao verificar pagamento 89366953471:

    2024-10-06 00:24:00,288 - main - ERROR - Erro ao verificar pagamento 89677153946:

    2024-10-06 00:24:00,369 - main - ERROR - Erro ao verificar pagamento 89737372184:

    2024-10-06 00:24:00,452 - main - ERROR - Erro ao verificar pagamento 89426573975:

    2024-10-06 00:24:00,536 - main - ERROR - Erro ao verificar pagamento 89427264941:

    2024-10-06 00:24:00,617 - main - ERROR - Erro ao verificar pagamento 89427265839:

    2024-10-06 00:24:00,707 - main - ERROR - Erro ao verificar pagamento 89741978568:

    2024-10-06 00:24:00,709 - main - INFO - Pagamentos pendentes salvos com sucesso. 2024-10-06 00:24:27,592 - main - ERROR - Erro ao processar assinatura para chat_id 6716999820: gerar_pix() missing 2 required positional arguments: 'descricao' and 'email' 2024-10-06 00:24:29,557 - main - ERROR - Erro ao processar assinatura para chat_id 6716999820: gerar_pix() missing 2 required positional arguments: 'descricao' and 'email' 2024-10-06 00:25:00,713 - main - INFO - Pagamentos pendentes carregados com sucesso. 2024-10-06 00:25:00,802 - main - ERROR - Erro ao verificar pagamento 89366953471:

    2024-10-06 00:25:00,883 - main - ERROR - Erro ao verificar pagamento 89677153946:

    2024-10-06 00:25:00,963 - main - ERROR - Erro ao verificar pagamento 89737372184:

    2024-10-06 00:25:01,043 - main - ERROR - Erro ao verificar pagamento 89426573975:

    2024-10-06 00:25:01,123 - main - ERROR - Erro ao verificar pagamento 89427264941:

    2024-10-06 00:25:01,204 - main - ERROR - Erro ao verificar pagamento 89427265839:

    2024-10-06 00:25:01,287 - main - ERROR - Erro ao verificar pagamento 89741978568:

    2024-10-06 00:25:01,289 - main - INFO - Pagamentos pendentes salvos com sucesso. 2024-10-06 00:25:06,566 - main - ERROR - Erro ao processar assinatura para chat_id 6716999820: gerar_pix() missing 2 required positional arguments: 'descricao' and 'email'

    não sei o que está havendo, recentemente retirei a api do mercado pago e coloquei a do novo banco: pushinpay, muito utilizada para pagamento de um bot do telegram chamada fusion

    com essa api não irá aparecer meus dados no codigo copia e cola do pix, porem mesmo eu colocando a api no .env e alterando no codigo principal e o vscode me mostrando que não tinha mais problemas ou riscos eu apenas iniciei e deu esses erros acima

  2. Assistant

    Olá! Vamos analisar juntos os problemas que você está enfrentando com o seu código após a mudança para a API do PushInPay.

    Problema 1: gerar_pix() faltando argumentos obrigatórios descricao e email

    Erro:

    Erro ao processar assinatura para chat_id XXXXXXXX: gerar_pix() missing 2 required positional arguments: 'descricao' and 'email'
    

    Causa:

    No seu código, a função gerar_pix foi definida com três parâmetros obrigatórios:

    def gerar_pix(valor: float, descricao: str, email: str) -> dict:
        ...
    

    Entretanto, ao chamar essa função dentro do handle_assinatura, você está passando apenas o valor:

    pix_info = gerar_pix(valor)
    

    Solução:

    Você precisa passar os três argumentos exigidos pela função gerar_pix. Além disso, precisará definir valores apropriados para descricao e email. Veja como você pode modificar o código:

    @bot.callback_query_handler(func=lambda call: call.data in ["mensal", "vitalicio"])
    def handle_assinatura(call):
        try:
            valor = MONTHLY_PRICE if call.data == "mensal" else LIFETIME_PRICE
            descricao = "Assinatura Mensal" if call.data == "mensal" else "Assinatura Vitalícia"
            email = "usuario@example.com"  # Ou peça ao usuário informar o email
            pix_info = gerar_pix(valor, descricao, email)
            ...
    

    Observação sobre o email:

    Se possível, é ideal solicitar o email do usuário para que o comprovante de pagamento seja enviado a ele (se aplicável) e também para cumprir com os requisitos da API do PushInPay. Para isso, você pode:

    1. Enviar uma mensagem pedindo o email após o usuário escolher o plano.
    2. Utilizar o reply_markup para solicitar o email através de um botão de solicitação de contato.

    Problema 2: Erro 404 ao verificar pagamento (404 Not Found)

    Erro:

    Erro ao verificar pagamento XXXXXX: <html>
    <head><title>404 Not Found</title></head>
    ...
    

    Causa:

    Os erros 404 indicam que a URL que você está tentando acessar não existe. Isso significa que os endpoints (endereços de API) que você está usando para interagir com a API do PushInPay estão incorretos.

    Solução:

    Você precisa atualizar as URLs nos métodos verificar_pagamento e gerar_pix para corresponder aos endpoints corretos da API do PushInPay.

    Passos para corrigir:

    1. Consulte a documentação da API do PushInPay:

      Você precisa verificar qual é o endpoint correto para gerar um pagamento e para verificar o status de um pagamento. A documentação da API deve fornecer essas informações.

    2. Atualize o endpoint em gerar_pix:

      Por exemplo, se o endpoint correto para criar uma nova cobrança for https://api.pushinpay.com.br/v1/charges, o seu código deve ficar assim:

      def gerar_pix(valor: float, descricao: str, email: str) -> dict:
          url = 'https://api.pushinpay.com.br/v1/charges'
          headers = {
              'Authorization': f'Bearer {PUSHIN_PAY_TOKEN}',
              'Content-Type': 'application/json'
          }
          data = {
              "amount": valor,
              "description": descricao,
              "payer": {
                  "email": email
              }
          }
          response = requests.post(url, headers=headers, json=data)
          if response.status_code == 201:
              pix_data = response.json()
              qr_code = pix_data.get('qr_code')
              payment_id = pix_data.get('id')
              return {"payment_id": payment_id, "qr_code": qr_code}
          else:
              logger.error(f"Erro ao gerar PIX: {response.text}")
              return {}
      
    3. Atualize o endpoint em verificar_pagamento:

      Se o endpoint para verificar o status de um pagamento for algo como https://api.pushinpay.com.br/v1/charges/{payment_id}, atualize a função:

      def verificar_pagamento(payment_id: str) -> bool:
          url = f'https://api.pushinpay.com.br/v1/charges/{payment_id}'
          headers = {
              'Authorization': f'Bearer {PUSHIN_PAY_TOKEN}',
          }
          response = requests.get(url, headers=headers)
          if response.status_code == 200:
              payment_status = response.json().get('status')
              return payment_status == 'approved'
          else:
              logger.error(f"Erro ao verificar pagamento {payment_id}: {response.text}")
              return False
      

    Importante: Substitua as URLs pelos endpoints corretos fornecidos pela documentação do PushInPay.

    Passos Adicionais:

    1. Verifique o formato dos dados enviados:

      Certifique-se de que os dados (payload) enviados nas requisições estão no formato esperado pela API do PushInPay.

    2. Teste as requisições manualmente:

      Antes de implementar no código, use ferramentas como Postman ou cURL para testar as requisições e garantir que você está usando os endpoints e parâmetros corretos.

    3. Utilize logs detalhados:

      Ao debugar, inclua informações adicionais nos logs para facilitar a identificação de problemas, como o URL completo da requisição, os headers, e o payload enviado.

    4. Trate exceções específicas:

      Atualize o código para capturar e tratar exceções específicas, o que ajudará na identificação de erros.

    Exemplo de implementação corrigida:

    # Exemplo de atualização na função gerar_pix
    def gerar_pix(valor: float, descricao: str, email: str) -> dict:
        url = 'https://api.pushinpay.com.br/v1/charges'  # URL atualizada conforme a documentação
        headers = {
            'Authorization': f'Bearer {PUSHIN_PAY_TOKEN}',
            'Content-Type': 'application/json'
        }
        data = {
            "amount": valor,
            "description": descricao,
            "payer": {
                "email": email
            }
        }
        try:
            response = requests.post(url, headers=headers, json=data)
            response.raise_for_status()
            pix_data = response.json()
            qr_code = pix_data.get('qr_code')
            payment_id = pix_data.get('id')
            return {"payment_id": payment_id, "qr_code": qr_code}
        except requests.RequestException as e:
            logger.error(f"Erro ao gerar PIX: {e}")
            return {}
    

    Certifique-se de adaptar o código de acordo com os campos e estruturas fornecidos pela API do PushInPay.

    Conclusão

    • Corrija as chamadas das funções para incluir todos os parâmetros obrigatórios.
    • Atualize os endpoints da API para os corretos fornecidos pelo PushInPay.
    • Considere implementar mecanismos para obter o email do usuário ou lidar com casos em que o email não está disponível.

    Recomendação: Sempre consulte a documentação oficial da API que você está utilizando para garantir que sua implementação esteja de acordo com os requisitos e padrões esperados.

    Se após essas correções você ainda enfrentar problemas, compartilhe os novos logs de erro para que possamos ajudar mais detalhadamente.

    Espero que isso ajude a resolver os problemas que você está enfrentando!