Untitled

# Bibliotecas utilizadas:
import getemail
import subprocess
import time
import keyboard
import pyautogui
import webbrowser
import pyperclip

# Variáveis utilizadas:
botao_de_criar_conta = (1537, 641)
campo_de_email = (1466, 449)
campo_de_senha = (1453, 549)
campo_de_confirmacao_de_senha = (1462, 655)
campo_de_aceitar_termos = (1356, 735)
campo_do_botao_de_criar_conta = (1484, 912)
campo_do_giveaways = (51, 557)
campo_do_site_de_confirmacao_caixa_de_confirmacao = (361, 697)
campo_de_decer_pagina_do_programa = (1911, 189)
campo_do_botao_de_gerar_o_link = (444, 322)
campo_do_botao_de_copiar_o_link = (1145, 733)
campo_fechar_guia_do_link = (1222, 273)
campo_da_configuracao = (32, 861)
campo_de_decer_pagina_do_programa_da_configuracao = (417, 1000)
campo_para_desconectar = (127, 948)
campo_de_confirmar_para_desconectar = (1091, 599)

# Funções para controle de VPN
def abrir_vpn():
    """Abre o cliente NordVPN."""
    try:
        command = ["C:\\Program Files\\NordVPN\\nordvpn.exe"]
        process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        time.sleep(8)  # Aguarda o processo iniciar
        print("Abertura de programa VPN concluída!")
        return process
    except Exception as e:
        print(f"Erro ao abrir o VPN: {e}")
        return None

def conectar_vpn():
    """Conecta-se a um país usando NordVPN."""
    try:
        command = ["C:\\Program Files\\NordVPN\\nordvpn.exe", '-c', '-g', 'Netherlands']
        subprocess.run(command, capture_output=True, text=True)
        time.sleep(7)  # Aguarda a conexão ser estabelecida
        print("Conectado na VPN")
    except Exception as e:
        print(f"Erro ao conectar à VPN: {e}")

def desconectar_vpn():
    """Desconecta da VPN."""
    try:
        command = ["C:\\Program Files\\NordVPN\\nordvpn.exe", '-d']
        subprocess.run(command, capture_output=True, text=True)
        print("Conexão VPN desconectada")
        time.sleep(2)
    except Exception as e:
        print(f"Erro ao desconectar da VPN: {e}")

def fechar_vpn(process):
    try:
        subprocess.call(['taskkill', '/F', '/T', '/PID', str(process.pid)])
        print("VPN fechada")
    except Exception as e:
        print(f"Erro ao fechar a VPN: {e}")

# Funções para controle de email
def gerar_email_temporario():
    """Gera um email temporário e sua senha."""
    try:
        address, token = getemail.mail()
        print(f"Email: {address}, Token: {token}")
        print("Criação de email e senha concluída com sucesso!")
        return address, token
    except Exception as e:
        print(f"Erro ao gerar email temporário: {e}")
        return None, None

def confirmar_email(token):
    """Confirma o email usando o link enviado."""
    try:
        first_url = getemail.check_mail(auth=token, url=2)
        print("Primeiro URL no email:", first_url)
        webbrowser.open(first_url)
        print("Email recebido e aberto!")
        time.sleep(9)
        pyautogui.click(campo_do_site_de_confirmacao_caixa_de_confirmacao)
        time.sleep(9)
        print("Confirmação concluída!")
    except Exception as e:
        print(f"Erro ao confirmar email: {e}")

def fechar_navegador():
    """Fecha o navegador e aba atual."""
    try:
        print("Iniciando o processo de fechar página de navegação")
        keyboard.send("ctrl+w")  # Fecha a aba
        time.sleep(2)
        keyboard.send("alt+F4")  # Fecha o navegador
        print("Navegador fechado")
    except Exception as e:
        print(f"Erro ao fechar o navegador: {e}")

# Funções para controle do SteelSeries GG
def abrir_programa_steelseries():
    """Abre o programa SteelSeries GG."""
    try:
        lnk_path = r"C:\ProgramData\Microsoft\Windows\Start Menu\Programs\SteelSeries\SteelSeries GG\SteelSeries GG.lnk"
        command = f'start "" "{lnk_path}"'
        process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        time.sleep(5)  # Ajuste o tempo de espera conforme necessário
        print("Abertura do programa SteelSeries GG concluída!")
        return process
    except Exception as e:
        print(f"Erro ao abrir o programa SteelSeries GG: {e}")
        return None

def criar_conta_steelseries(address, token):
    """Automatiza o processo de criação de conta na SteelSeries."""
    try:
        print("Iniciando o processo de criação da conta!")
        pyautogui.click(botao_de_criar_conta)
        time.sleep(3)
        pyautogui.click(campo_de_email)
        keyboard.write(address, 0.01)
        time.sleep(2)
        pyautogui.click(campo_de_senha)
        keyboard.write(token, 0.01)
        time.sleep(2)
        pyautogui.click(campo_de_confirmacao_de_senha)
        keyboard.write(token, 0.01)
        time.sleep(2)
        pyautogui.click(campo_de_aceitar_termos)
        time.sleep(2)
        pyautogui.click(campo_do_botao_de_criar_conta)
        print("Conta criada com sucesso!")
    except Exception as e:
        print(f"Erro ao criar conta: {e}")

def fechar_programa(process):
    """Fecha um processo dado."""
    try:
        pyautogui.click(campo_fechar_guia_do_link)
        time.sleep(2)
        pyautogui.click(campo_da_configuracao)
        time.sleep(2)
        pyautogui.click(campo_de_decer_pagina_do_programa_da_configuracao)
        time.sleep(2)
        pyautogui.click(campo_para_desconectar)
        time.sleep(2)
        pyautogui.click(campo_de_confirmar_para_desconectar)
        time.sleep(2)
        subprocess.call(['taskkill', '/F', '/T', '/PID', str(process.pid)])
        print("Programa fechado completamente")
        time.sleep(2)
    except Exception as e:
        print(f"Erro ao fechar o programa: {e}")

# Funções para controle de resgate de link
def resgatar_link():
    """Automatiza o resgate de link de promoção."""
    try:
        time.sleep(5)
        pyautogui.click(campo_do_giveaways)
        print("Clicado na tela para o resgate!")
        time.sleep(2)
        pyautogui.click(campo_de_decer_pagina_do_programa)
        print("Desceu a página!")
        time.sleep(2)
        pyautogui.click(campo_do_botao_de_gerar_o_link)
        print("Clicou no botão para gerar o link!")
        time.sleep(3)
        pyautogui.click(campo_do_botao_de_copiar_o_link)
        print("Copiou o link!")
        time.sleep(7)
    except Exception as e:
        print(f"Erro ao resgatar link: {e}")

def salvar_link():
    """Salva o link gerado em um arquivo de texto."""
    try:
        nome_arquivo = "links.txt"
        data = pyperclip.paste()
        with open(nome_arquivo, 'a') as arquivo:
            arquivo.write(data + '\n')
        print("Link salvo com sucesso")
    except Exception as e:
        print(f"Erro ao salvar o link: {e}")

# Função de tratamento de erro
def erro(process_vpn, process_steelseries):
    fechar_programa(process_steelseries)
    desconectar_vpn()
    fechar_vpn(process_vpn)
    fechar_navegador()

# Função principal do processo de resgate
def processo_resgate():
    """Realiza o processo completo de resgate de promoção."""
    process_vpn = abrir_vpn()
    if not process_vpn:
        return

    conectar_vpn()
    address, token = gerar_email_temporario()
    if not address or not token:
        return

    process_steelseries = abrir_programa_steelseries()
    if not process_steelseries:
        return

    criar_conta_steelseries(address, token)
    confirmar_email(token)
    fechar_navegador()
    desconectar_vpn()
    resgatar_link()
    salvar_link()
    fechar_programa(process_steelseries)
    fechar_vpn(process_vpn)

# Loop para repetir o processo
while True:
    try:
        processo_resgate()
    except Exception as e:
        print(f"Ocorreu um erro: {e}")
        erro()
    # Opcional: adicionar um tempo de espera antes de reiniciar
    time.sleep(10)