worker-automate-hub 0.4.426__tar.gz → 0.4.428__tar.gz

{worker_automate_hub-0.4.426 → worker_automate_hub-0.4.428}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: worker-automate-hub
-Version: 0.4.426
+Version: 0.4.428
 Summary: Worker Automate HUB é uma aplicação para automatizar rotinas de RPA nos ambientes Argenta.
 Author: Joel Paim
 Requires-Python: >=3.12,<4.0

{worker_automate_hub-0.4.426 → worker_automate_hub-0.4.428}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "worker-automate-hub"
-version = "0.4.426"
+version = "0.4.428"
 description = "Worker Automate HUB é uma aplicação para automatizar rotinas de RPA nos ambientes Argenta."
 authors = ["Joel Paim"]
 readme = "README.md"

worker_automate_hub-0.4.428/worker_automate_hub/models/dto/rpa_processo_rdp_dto.py

@@ -0,0 +1,15 @@
+from typing import Dict, Optional
+from pydantic import BaseModel
+
+class ConfigEntrada(BaseModel):
+    ip: str
+    user: str
+    password: str
+    processo: str
+    uuid_robo: Optional[str]
+
+    def get(self, key, default=None):
+        return getattr(self, key, default)
+
+class RpaProcessoRdpDTO(BaseModel):
+    configEntrada: ConfigEntrada

worker_automate_hub-0.4.428/worker_automate_hub/tasks/jobs/conexao_rdp.py

@@ -0,0 +1,209 @@
+import asyncio
+import platform
+import subprocess
+import socket
+import pyautogui
+import pygetwindow as gw
+from rich.console import Console
+import pygetwindow as gw
+from pywinauto import Application
+from worker_automate_hub.models.dto.rpa_historico_request_dto import RpaHistoricoStatusEnum, RpaRetornoProcessoDTO
+from worker_automate_hub.models.dto.rpa_processo_rdp_dto import RpaProcessoRdpDTO
+from worker_automate_hub.utils.logger import logger
+from worker_automate_hub.utils.util import worker_sleep
+
+console = Console()
+
+
+class RDPConnection:
+    def __init__(self, task: RpaProcessoRdpDTO):
+        self.task = task
+        self.ip = task.configEntrada.get("ip")
+        self.user = task.configEntrada.get("user")
+        self.password = task.configEntrada.get("password")
+        self.processo = task.configEntrada.get("processo")
+        self.uuid_robo = task.configEntrada.get("uuid_robo")
+    
+    async def verificar_conexao(self) -> bool:
+        sistema_operacional = platform.system().lower()
+        logger.info(f"Sistema operacional detectado: {sistema_operacional}")
+        if sistema_operacional == "windows":
+            comando_ping = ["ping", "-n", "1", "-w", "1000", self.ip]
+        else:
+            comando_ping = ["ping", "-c", "1", "-W", "1", self.ip]
+        logger.info(f"Executando comando de ping: {' '.join(comando_ping)}")
+        try:
+            resposta_ping = subprocess.run(comando_ping, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            ping_alcancado = resposta_ping.returncode == 0
+            logger.info(f"Ping {'sucesso' if ping_alcancado else 'falhou'}")
+        except Exception as e:
+            logger.error(f"Erro ao executar ping: {e}")
+            ping_alcancado = False
+        
+        porta_aberta = False
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.settimeout(10)
+                logger.info(f"Verificando porta 3389 em {self.ip}")
+                resposta_porta = sock.connect_ex((self.ip, 3389))
+                porta_aberta = resposta_porta == 0
+                logger.info(f"Porta 3389 {'aberta' if porta_aberta else 'fechada'}")
+        except Exception as e:
+            logger.error(f"Erro ao verificar a porta RDP: {e}")
+            porta_aberta = False
+        
+        return ping_alcancado and porta_aberta
+    
+    async def clicar_no_titulo(self):
+        """
+        Função para clicar no título das janelas de Conexão de Área de Trabalho Remota
+        com o botão direito do mouse e executar comandos.
+        """
+        janelas_rdp = [
+            win
+            for win in gw.getAllTitles()
+            if "Conexão de Área de Trabalho Remota" in win
+            or "Remote Desktop Connection" in win
+        ]
+
+        for titulo in janelas_rdp:
+            janela = gw.getWindowsWithTitle(titulo)[0]
+            if not janela:
+                print(f"Erro ao localizar a janela: {titulo}")
+                continue
+
+            print(f"Processando janela: {titulo}")
+
+            # Obtém as coordenadas da janela
+            x, y = janela.left, janela.top
+
+            try:
+                # Move o mouse para o título da janela e clica com o botão direito
+                pyautogui.moveTo(x + 10, y + 10)  # Ajuste para alinhar ao título da janela
+                pyautogui.click(button="right")
+                
+                await worker_sleep(5)
+                pyautogui.press("down", presses=7, interval=0.1)
+                await worker_sleep(5)
+                pyautogui.hotkey("enter")
+                await worker_sleep(5)
+                pyautogui.hotkey("enter")
+
+            except Exception as e:
+                print(f"Erro ao interagir com a janela {titulo}: {e}")
+    
+    async def conectar(self):
+        logger.info(f"Iniciando cliente RDP para {self.ip}")
+        try:
+            pyautogui.hotkey("win", "d")
+            await worker_sleep(5)  # Tempo para garantir que todas as janelas sejam minimizadas
+            logger.info("Todas as janelas minimizadas com sucesso.")
+        
+            subprocess.Popen(["mstsc", f"/v:{self.ip}"], close_fds=True, start_new_session=True)
+            await worker_sleep(10)  # Tempo aumentado para garantir abertura
+            
+            logger.info("Procurando janela 'Conexão de Área de Trabalho Remota'")
+            windows = gw.getWindowsWithTitle("Conexão de Área de Trabalho Remota")
+            if not windows:
+                logger.warning("Tentando encontrar janela com título em inglês 'Remote Desktop Connection'")
+                windows = gw.getWindowsWithTitle("Remote Desktop Connection")
+            
+            if not windows:
+                logger.error("Janela de RDP não encontrada.")
+                return False
+            
+            rdp_window = windows[0]
+            logger.info(f"Janela '{rdp_window.title}' encontrada. Focando na janela.")
+            
+            # Restaurar janela se estiver minimizada
+            if rdp_window.isMinimized:
+                rdp_window.restore()
+                await worker_sleep(5)
+            
+            # Redimensionar para 50% da tela
+            screen_width, screen_height = pyautogui.size()
+            new_width = screen_width // 2
+            new_height = screen_height // 2
+            rdp_window.resizeTo(new_width, new_height)
+            rdp_window.moveTo(screen_width // 4, screen_height // 4)
+            logger.info(f"Janela redimensionada para {new_width}x{new_height}.")
+            
+            rdp_window.activate()
+            await worker_sleep(5)  # Tempo extra para garantir que a janela está ativa
+            
+            # Clique para garantir o foco
+            pyautogui.click(rdp_window.left + 50, rdp_window.top + 50)
+            await worker_sleep(3)
+            
+            # Inserir credenciais
+            
+            try:
+                app = Application(backend="uia").connect(title="Segurança do Windows")
+                dialog = app.window(title="Segurança do Windows")
+
+                edit_field = dialog.child_window(auto_id="EditField_1", control_type="Edit")
+
+                if edit_field.exists():
+                    logger.info("Inserindo usuário.")
+                    pyautogui.write(self.user, interval=0.1)
+                    pyautogui.press("tab")
+                    await worker_sleep(5)
+            except:
+                pass
+           
+            logger.info("Inserindo senha.")
+            pyautogui.write(self.password, interval=0.1)
+            pyautogui.press("enter")
+            await worker_sleep(5)
+            pyautogui.press("left")
+            await worker_sleep(5)
+            pyautogui.press("enter")
+            logger.info("Credenciais inseridas.")
+            await worker_sleep(5)  # Tempo para conexão ser concluída
+            
+            logger.info("Conexão RDP ativa. Mantendo o script em execução.")
+            return True
+        except Exception as e:
+            logger.error(f"Erro ao tentar conectar via RDP: {e}")
+            return False
+
+async def conexao_rdp(task: RpaProcessoRdpDTO) -> RpaRetornoProcessoDTO:
+    try:
+        logger.info("Iniciando processo de conexão RDP.")
+        rdp = RDPConnection(task)
+        conectado = await rdp.verificar_conexao()
+        if not conectado:
+            logger.warning("Não foi possível estabelecer conexão RDP. Verifique o IP e a disponibilidade da porta.")
+            return RpaRetornoProcessoDTO(
+                sucesso=False,
+                retorno="Não foi possível estabelecer conexão RDP. Verifique o IP e a disponibilidade da porta.",
+                status=RpaHistoricoStatusEnum.Falha,
+            )
+        sucesso_conexao = await rdp.conectar()
+        if sucesso_conexao:
+            logger.info("Processo de conexão RDP executado com sucesso.")
+            
+            await rdp.clicar_no_titulo()
+            
+            # Mantém o script ativo para manter a conexão RDP aberta
+            return RpaRetornoProcessoDTO(
+                sucesso=True,
+                retorno="Conexão RDP estabelecida com sucesso.",
+                status=RpaHistoricoStatusEnum.Sucesso,
+            )
+        else:
+            logger.error("Falha ao tentar conectar via RDP.")
+            return RpaRetornoProcessoDTO(
+                sucesso=False,
+                retorno="Falha ao tentar conectar via RDP.",
+                status=RpaHistoricoStatusEnum.Falha,
+            )
+    except Exception as ex:
+        err_msg = f"Erro ao executar conexao_rdp: {ex}"
+        logger.error(err_msg)
+        console.print(err_msg, style="bold red")
+        return RpaRetornoProcessoDTO(
+            sucesso=False,
+            retorno=err_msg,
+            status=RpaHistoricoStatusEnum.Falha,
+        )

worker_automate_hub-0.4.426/worker_automate_hub/tasks/jobs/conexao_rdp.py

@@ -1,303 +0,0 @@
-import asyncio
-import os
-import subprocess
-import time
-
-import pyautogui
-import pygetwindow._pygetwindow_win as gw
-from worker_automate_hub.models.dto.rpa_historico_request_dto import RpaHistoricoStatusEnum, RpaRetornoProcessoDTO
-from worker_automate_hub.models.dto.rpa_processo_entrada_dto import RpaProcessoEntradaDTO
-from pygetwindow._pygetwindow_win import Win32Window
-from rich.console import Console
-
-from worker_automate_hub.utils.logger import logger
-
-console = Console()
-
-
-def tirar_screenshot(nome_etapa: str):
-    """
-    Tira um screenshot da tela atual e salva em um arquivo com o nome
-    especificado e a data/hora atual.
-
-    :param nome_etapa: nome da etapa que est  sendo executada
-    :type nome_etapa: str
-    :return: caminho do arquivo de screenshot gerado
-    :rtype: str
-    """
-    if nome_etapa is None:
-        raise ValueError("Nome da etapa não pode ser nulo")
-
-    caminho_screenshot = f"{nome_etapa}_{int(time.time())}.png"
-    try:
-        pyautogui.screenshot(caminho_screenshot)
-        console.print(f"Screenshot tirada: {caminho_screenshot}")
-        return caminho_screenshot
-
-    except Exception as e:
-        console.print(f"Erro ao tirar screenshot: {e}")
-        return None
-
-
-def deletar_screenshots(caminhos_screenshots: str):
-    """
-    Recebe uma lista de caminhos de arquivos de screenshots e deleta cada um deles.
-
-    :param caminhos_screenshots: lista de caminhos de arquivos de screenshots
-    :type caminhos_screenshots: list[str]
-    """
-    if caminhos_screenshots is None:
-        raise ValueError("Lista de caminhos de screenshots não pode ser nula")
-
-    for caminho in caminhos_screenshots:
-        if caminho is None:
-            raise ValueError("Caminho de screenshot não pode ser nulo")
-
-        try:
-            os.remove(caminho)
-            console.print(f"Screenshot deletada: {caminho}")
-        except OSError as e:
-            console.print(f"Erro ao deletar screenshot {caminho}: {e}")
-
-
-def fechar_janelas_rdp_sem_ip():
-    """
-    Fecha as janelas de conex o RDP sem IP.
-
-    Caso não tenha nenhuma conexão RDP aberta, não fará  nada.
-    """
-    janelas_rdp = [
-        win
-        for win in gw.getAllTitles()
-        if "Conexão de  Área de Trabalho Remota" in win
-        or "Remote Desktop Connection" in win
-    ]
-    for titulo in janelas_rdp:
-        if not any(char.isdigit() for char in titulo):
-            console.print(f"Fechando pop-up de conexão sem IP: {titulo}")
-            janela: Win32Window = gw.getWindowsWithTitle(titulo)[0]
-            if janela is None:
-                raise RuntimeError(f"Janela {titulo} não existe")
-            try:
-                janela.close()
-            except Exception as e:
-                logger.error(f"Erro ao fechar janela {titulo}: {e}")
-            time.sleep(2)
-
-
-def fechar_janela_existente(ip: str):
-    """
-    Fecha a janela existente com o IP informado.
-
-    Args:
-        ip (str): IP da janela a ser fechada.
-
-    Raises:
-        Exception: Erro ao tentar fechar a janela.
-    """
-    try:
-        janelas_encontradas = gw.getAllTitles()
-        for titulo in janelas_encontradas:
-            if ip in titulo:
-                janela: Win32Window = gw.getWindowsWithTitle(titulo)[0]
-                if janela is None:
-                    raise RuntimeError(f"Janela {titulo} não existe")
-                console.print(f"Fechando janela existente: {titulo}")
-                janela.activate()
-                pyautogui.hotkey("alt", "f4")
-                time.sleep(1)
-                break
-        else:
-            console.print(f"Nenhuma janela encontrada com o IP: {ip}")
-
-        fechar_janelas_rdp_sem_ip()
-
-    except Exception as e:
-        console.print(f"Erro ao tentar fechar a janela: {e}", style="bold red")
-
-
-def restaurar_janelas_rdp():
-    """
-    Função para restaurar todas as janelas de Conexão de área de Trabalho Remota
-    que estão minimizadas e mover elas para uma posicão na tela.
-    """
-    janelas_rdp = [
-        win
-        for win in gw.getAllTitles()
-        if "Conexão de Área de Trabalho Remota" in win
-        or "Remote Desktop Connection" in win
-    ]
-
-    offset_x = 0
-    offset_y = 0
-    step_x = 30
-    step_y = 30
-
-    for titulo in janelas_rdp:
-        janela: Win32Window = gw.getWindowsWithTitle(titulo)[0]
-        if janela is None:
-            console.print(
-                f"Erro ao restaurar janela {titulo}: janela não existe",
-                style="bold red",
-            )
-            continue
-
-        console.print(f"Processando janela: {titulo}")
-        if janela.isMinimized:
-            try:
-                janela.restore()
-            except Exception as e:
-                console.print(
-                    f"Erro ao restaurar janela {titulo}: {e}", style="bold red"
-                )
-            else:
-                console.print(f"Janela restaurada: {titulo}")
-        else:
-            console.print(f"Janela já está aberta: {titulo}")
-
-        try:
-            janela.moveTo(offset_x, offset_y)
-        except Exception as e:
-            console.print(f"Erro ao mover janela {titulo}: {e}", style="bold red")
-        else:
-            offset_x += step_x
-            offset_y += step_y
-
-        try:
-            janela.activate()
-        except Exception as e:
-            console.print(f"Erro ao ativar janela {titulo}: {e}", style="bold red")
-        time.sleep(2)
-
-
-def redimensionar_janela_rdp(largura: int, altura: int):
-    """
-    Redimensiona a janela da Conexão de Área de Trabalho Remota.
-
-    :param largura: Largura da janela em pixels
-    :type largura: int
-    :param altura: Altura da janela em pixels
-    :type altura: int
-    """
-    janelas_rdp = [
-        win
-        for win in gw.getAllTitles()
-        if "Conexão de Área de Trabalho Remota" in win
-        or "Remote Desktop Connection" in win
-    ]
-
-    if janelas_rdp:
-        try:
-            janela_rdp: Win32Window = gw.getWindowsWithTitle(janelas_rdp[0])[0]
-            if janela_rdp is None:
-                raise RuntimeError("Janela RDP não existe")
-            janela_rdp.resizeTo(largura, altura)
-            janela_rdp.moveTo(20, 20)
-            console.print(f"Janela redimensionada para {largura}x{altura}.")
-            janela_rdp.activate()
-            janela_rdp.restore()
-            time.sleep(1)
-        except Exception as e:
-            console.print(f"Erro ao redimensionar janela RDP: {e}", style="bold red")
-    else:
-        console.print("Não foi possível encontrar a janela RDP para redimensionar.")
-
-
-async def conexao_rdp(task: RpaProcessoEntradaDTO) -> RpaRetornoProcessoDTO:
-
-    caminhos_screenshots = []
-    try:
-        if not task or not task.configEntrada:
-            raise ValueError("Task inválida ou sem configurações de entrada.")
-
-        ip = task.configEntrada.get("ip", "")
-        user = task.configEntrada.get("user", "")
-        password = task.configEntrada.get("password", "")
-
-        if not ip or not user or not password:
-            raise ValueError(
-                "Configurações de entrada inválidas. Verifique se o IP, Usuário e Senha estão preenchidos."
-            )
-
-        pyautogui.hotkey("win", "d")
-        console.print("1 - Minimizando todas as telas...")
-        await asyncio.sleep(2)
-
-        fechar_janela_existente(ip)
-
-        subprocess.Popen("mstsc")
-        console.print("2 - Abrindo conexão de trabalho remota...")
-        await asyncio.sleep(2)
-
-        redimensionar_janela_rdp(500, 500)
-
-        await asyncio.sleep(2)
-
-        janelas_rdp = [
-            win
-            for win in gw.getAllTitles()
-            if "Conexão de Área de Trabalho Remota" in win
-            or "Remote Desktop Connection" in win
-        ]
-        if not janelas_rdp:
-            raise RuntimeError("Nenhuma janela RDP foi encontrada.")
-
-        janela_rdp: Win32Window = gw.getWindowsWithTitle(janelas_rdp[0])[0]
-        if janela_rdp is None:
-            raise RuntimeError("Janela RDP não existe.")
-
-        janela_rdp.activate()
-        janela_rdp.restore()
-        await asyncio.sleep(1)
-
-        caminhos_screenshots.append(tirar_screenshot("antes_de_inserir_ip"))
-        console.print("3 - Inserindo o IP...")
-        pyautogui.write(ip)
-        await asyncio.sleep(10)
-        caminhos_screenshots.append(tirar_screenshot("depois_de_inserir_ip"))
-        pyautogui.press("enter")
-        await asyncio.sleep(5)
-        caminhos_screenshots.append(tirar_screenshot("depois_de_inserir_usuario"))
-        await asyncio.sleep(5)
-
-        console.print("5 - Inserindo a Senha...")
-        pyautogui.write(password)
-        pyautogui.press("enter")
-        await asyncio.sleep(10)
-        caminhos_screenshots.append(tirar_screenshot("depois_de_inserir_senha"))
-
-        console.print("6 - Apertando left...")
-        pyautogui.press("left")
-        await asyncio.sleep(2)
-        console.print("7 - Apertando Enter...")
-        pyautogui.press("enter")
-        await asyncio.sleep(20)
-        caminhos_screenshots.append(tirar_screenshot("depois_do_certificado"))
-
-        console.print("8 - Minimizando todas as telas no final...")
-        pyautogui.hotkey("win", "d")
-        await asyncio.sleep(2)
-        caminhos_screenshots.append(tirar_screenshot("depois_de_minimizar_todas"))
-
-        restaurar_janelas_rdp()
-        caminhos_screenshots.append(tirar_screenshot("depois_de_restaurar_janelas"))
-
-        deletar_screenshots(caminhos_screenshots)
-
-        return RpaRetornoProcessoDTO(
-            sucesso=True,
-            retorno="Processo de conexão ao RDP executado com sucesso.",
-            status=RpaHistoricoStatusEnum.Sucesso,
-        )
-
-    except Exception as ex:
-        err_msg = f"Erro ao executar conexao_rdp: {ex}"
-        logger.error(err_msg)
-        console.print(err_msg, style="bold red")
-        caminhos_screenshots.append(tirar_screenshot("erro"))
-        deletar_screenshots(caminhos_screenshots)
-        return RpaRetornoProcessoDTO(
-            sucesso=False,
-            retorno=err_msg,
-            status=RpaHistoricoStatusEnum.Falha,
-        )