worker-automate-hub 0.5.10__tar.gz → 0.5.13__tar.gz

{worker_automate_hub-0.5.10 → worker_automate_hub-0.5.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: worker-automate-hub
-Version: 0.5.10
+Version: 0.5.13
 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.5.10 → worker_automate_hub-0.5.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "worker-automate-hub"
-version = "0.5.10"
+version = "0.5.13"
 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.5.10 → worker_automate_hub-0.5.13}/worker_automate_hub/api/rdp_service.py

@@ -14,7 +14,11 @@ async def send_rdp_action(uuid_robo: str, action: str):
         "action": action
     }
     
-    headers_basic = {"Authorization": f"Basic {env_config['API_AUTHORIZATION']}"}
+    headers_basic = {
+        "Authorization": f"Basic {env_config['API_AUTHORIZATION']}",
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+    }
     url = f"{env_config['API_BASE_URL']}/robo/api/manage"
 
     try:

{worker_automate_hub-0.5.10 → worker_automate_hub-0.5.13}/worker_automate_hub/api/rpa_fila_service.py

@@ -1,30 +1,34 @@
-from worker_automate_hub.config.settings import load_env_config
-from worker_automate_hub.utils.logger import logger
+import aiohttp
 from rich.console import Console
 
-import aiohttp
+from worker_automate_hub.config.settings import load_env_config
+from worker_automate_hub.models.dao.rpa_fila import RpaFila
+from worker_automate_hub.utils.logger import logger
 
 console = Console()
 
 
 async def burn_queue(id_fila: str):
     env_config, _ = load_env_config()
-    try:       
+    try:
 
         headers_basic = {"Authorization": f"Basic {env_config["API_AUTHORIZATION"]}"}
-        
 
-        async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(verify_ssl=True)) as session:
+        async with aiohttp.ClientSession(
+            connector=aiohttp.TCPConnector(verify_ssl=True)
+        ) as session:
             async with session.delete(
                 f"{env_config["API_BASE_URL"]}/fila/burn-queue/{id_fila}",
                 headers=headers_basic,
             ) as response:
                 if response.status == 200:
                     logger.info("Fila excluida com sucesso.")
-                    console.print("\nFila excluida com sucesso.\n", style="bold green")    
+                    console.print("\nFila excluida com sucesso.\n", style="bold green")
                 else:
-                    logger.error(f"Erro ao excluir a fila: {response.content}") 
-                    console.print(f"Erro ao excluir a fila: {response.content}", style="bold red")          
+                    logger.error(f"Erro ao excluir a fila: {response.content}")
+                    console.print(
+                        f"Erro ao excluir a fila: {response.content}", style="bold red"
+                    )
 
     except Exception as e:
         err_msg = f"Erro remover registro da fila: {e}"
@@ -34,16 +38,18 @@ async def burn_queue(id_fila: str):
             style="bold red",
         )
         return None
-    
+
+
 async def unlock_queue(id: str):
     env_config, _ = load_env_config()
-    try:      
-        headers_basic = {"Authorization": f"Basic {env_config["API_AUTHORIZATION"]}"}       
-        
+    try:
+        headers_basic = {"Authorization": f"Basic {env_config["API_AUTHORIZATION"]}"}
 
-        async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(verify_ssl=True)) as session:
+        async with aiohttp.ClientSession(
+            connector=aiohttp.TCPConnector(verify_ssl=True)
+        ) as session:
             async with session.get(
-                f"{env_config["API_BASE_URL"]}/fila/unlock-queue/{id}",                
+                f"{env_config["API_BASE_URL"]}/fila/unlock-queue/{id}",
                 headers=headers_basic,
             ) as response:
                 return await response.text()
@@ -55,4 +61,4 @@ async def unlock_queue(id: str):
             f"{err_msg}\n",
             style="bold red",
         )
-        return None
+        return None

worker_automate_hub-0.5.13/worker_automate_hub/api/rpa_historico_service.py

@@ -0,0 +1,258 @@
+from datetime import datetime
+
+import aiohttp
+from pytz import timezone
+from rich.console import Console
+
+from worker_automate_hub.config.settings import load_env_config
+from worker_automate_hub.models.dao.rpa_historico import RpaHistorico
+from worker_automate_hub.models.dao.rpa_processo import RpaProcesso
+from worker_automate_hub.models.dto.rpa_historico_request_dto import (
+    RpaHistoricoRequestDTO,
+    RpaHistoricoStatusEnum,
+    RpaRetornoProcessoDTO,
+)
+from worker_automate_hub.models.dto.rpa_processo_entrada_dto import (
+    RpaProcessoEntradaDTO,
+)
+from worker_automate_hub.utils.logger import logger
+
+console = Console()
+
+
+async def create_store_historico(
+    task: RpaProcessoEntradaDTO,
+    processo: RpaProcesso,
+    status: RpaHistoricoStatusEnum,
+    retorno_processo: RpaRetornoProcessoDTO = None,
+) -> RpaHistorico:
+    """
+    Salva o histórico de um processo com status Processando.
+
+    Recebe um RpaProcessoEntradaDTO e um RpaProcesso como parâmetro e salva o
+    histórico com status Processando. Retorna um dicionário com o uuid do
+    histórico salvo.
+
+    Args:
+        task (RpaProcessoEntradaDTO): O processo a ser salvo.
+        processo (RpaProcesso): O processo que está sendo executado.
+
+    Returns:
+        RpaHistorico: Dicionário com o uuid do histórico salvo.
+    """
+    try:
+        from worker_automate_hub.config.settings import load_worker_config
+
+        worker_config = load_worker_config()
+        tz = timezone("America/Sao_Paulo")
+        start_time = datetime.now(tz).isoformat()
+
+        identificador_processo = (
+            task.configEntrada.get("nfe") or task.configEntrada.get("empresa") or ""
+        )
+
+        # Armazenar início da operação no histórico
+        start_data = RpaHistoricoRequestDTO(
+            uuidProcesso=task.uuidProcesso,
+            uuidRobo=worker_config["UUID_ROBO"],
+            prioridade=processo.prioridade,
+            desStatus=status,
+            configEntrada=task.configEntrada,
+            datInicioExecucao=start_time,
+            datEntradaFila=task.datEntradaFila,
+            identificador=identificador_processo,
+            retorno=retorno_processo,
+        )
+
+        store_response: RpaHistorico = await store(start_data)
+        console.print(
+            f"\nHistorico salvo com o uuid: {store_response.uuidHistorico}\n",
+            style="green",
+        )
+        return store_response
+    except Exception as e:
+        err_msg = f"Erro ao salvar o registro no histórico: {e}"
+        console.print(f"\n{err_msg}\n", style="red")
+        logger.error(f"{err_msg}")
+
+
+async def create_update_historico(
+    historico_uuid: str,
+    task: RpaProcessoEntradaDTO,
+    retorno_processo: RpaRetornoProcessoDTO,
+    processo: RpaProcesso,
+):
+    """
+    Atualiza o histórico de um processo com o status de sucesso ou falha.
+
+    Recebe o uuid do histórico, o RpaProcessoEntradaDTO do processo, um booleano
+    indicando se o processo foi um sucesso ou não, o RpaRetornoProcessoDTO do
+    processo e o RpaProcesso do processo como parâmetro e atualiza o histórico
+    com o status de sucesso ou falha. Retorna um dicionário com o uuid do
+    histórico atualizado.
+
+    Args:
+        historico_uuid (str): O uuid do histórico.
+        task (RpaProcessoEntradaDTO): O RpaProcessoEntradaDTO do processo.
+        sucesso (bool): Um booleano indicando se o processo foi um sucesso ou não.
+        retorno_processo (RpaRetornoProcessoDTO): O RpaRetornoProcessoDTO do processo.
+        processo (RpaProcesso): O RpaProcesso do processo.
+
+    Returns:
+        RpaHistorico: Dicionário com o uuid do histórico atualizado.
+    """
+
+    try:
+        from worker_automate_hub.config.settings import load_worker_config
+
+        worker_config = load_worker_config()
+        tz = timezone("America/Sao_Paulo")
+        des_status: RpaHistoricoStatusEnum = retorno_processo.status
+        end_time = datetime.now(tz).isoformat()
+
+        identificador_processo = (
+            task.configEntrada.get("nfe") or task.configEntrada.get("empresa") or ""
+        )
+        if not retorno_processo.tags:
+            retorno_processo.tags = []
+
+        # Armazenar fim da operação no histórico
+        end_data = RpaHistoricoRequestDTO(
+            uuidHistorico=historico_uuid,
+            uuidProcesso=task.uuidProcesso,
+            uuidRobo=worker_config["UUID_ROBO"],
+            prioridade=processo.prioridade,
+            desStatus=des_status,
+            configEntrada=task.configEntrada,
+            retorno=retorno_processo,
+            datFimExecucao=end_time,
+            identificador=identificador_processo,
+            tags=retorno_processo.tags,
+        )
+
+        update_response: RpaHistorico = await update(end_data)
+        console.print(
+            f"\nHistorico atualizado com o uuid: {update_response.uuidHistorico}\n",
+            style="green",
+        )
+        return update_response
+
+    except Exception as e:
+        err_msg = f"Erro ao atualizar o histórico do processo: {e}"
+        console.print(f"\n{err_msg}\n", style="red")
+        logger.error(err_msg)
+
+
+async def store(data: RpaHistoricoRequestDTO) -> dict:
+    """
+    Armazena o histórico de um processo com status Processando.
+
+    Recebe um RpaHistoricoRequestDTO como parâmetro e salva o
+    histórico com status Processando. Retorna um dicionário com o uuid do
+    histórico salvo.
+
+    Args:
+        data (RpaHistoricoRequestDTO): O histórico a ser salvo.
+
+    Returns:
+        RpaHistorico: Dicionário com o uuid do histórico salvo.
+    """
+    env_config, _ = load_env_config()
+
+    if not data:
+        raise ValueError("Parâmetro data deve ser informado")
+
+    if not isinstance(data, RpaHistoricoRequestDTO):
+        raise TypeError("Parâmetro data deve ser do tipo RpaHistoricoRequestDTO")
+
+    headers_basic = {
+        "Authorization": f"Basic {env_config["API_AUTHORIZATION"]}",
+        "Content-Type": "application/json",
+    }
+    try:
+        async with aiohttp.ClientSession(
+            connector=aiohttp.TCPConnector(verify_ssl=True)
+        ) as session:
+            payload = data.model_dump_json()
+
+            async with session.post(
+                f"{env_config["API_BASE_URL"]}/historico",
+                data=payload,
+                headers=headers_basic,
+            ) as response:
+                response_text = await response.text()
+                logger.info(f"Resposta store: {response_text}")
+
+                if response.status == 200:
+                    try:
+                        response_data = await response.json()
+                        return RpaHistorico(**response_data)
+                    except aiohttp.ContentTypeError:
+                        return {
+                            "error": "Resposta não é JSON",
+                            "status_code": response.status,
+                        }
+                else:
+                    return {"error": response_text, "status_code": response.status}
+    except aiohttp.ClientError as e:
+        logger.error(f"Erro de cliente aiohttp: {str(e)}")
+        return {"error": str(e), "status_code": 500}
+    except Exception as e:
+        logger.error(f"Erro inesperado: {str(e)}")
+        return {"error": str(e), "status_code": 500}
+
+
+async def update(data: RpaHistoricoRequestDTO) -> dict:
+    """
+    Atualiza um registro de histórico com base no uuidHistorico informado.
+
+    Args:
+        data (RpaHistoricoRequestDTO): Os dados do histórico a ser atualizado.
+
+    Returns:
+        RpaHistorico: O histórico atualizado.
+    """
+    env_config, _ = load_env_config()
+    headers_basic = {
+        "Authorization": f"Basic {env_config["API_AUTHORIZATION"]}",
+        "Content-Type": "application/json",
+    }
+    if not data or not isinstance(data, RpaHistoricoRequestDTO):
+        raise TypeError("Parâmetro data deve ser do tipo RpaHistoricoRequestDTO")
+    try:
+        async with aiohttp.ClientSession(
+            connector=aiohttp.TCPConnector(verify_ssl=True)
+        ) as session:
+            if not data.uuidHistorico:
+                raise ValueError("Parâmetro uuidHistorico deve ser informado")
+
+            payload = data.model_dump_json()
+
+            async with session.put(
+                f"{env_config["API_BASE_URL"]}/historico",
+                data=payload,
+                headers=headers_basic,
+            ) as response:
+                response_text = await response.text()
+                logger.info(f"Resposta update: {response_text}")
+
+                if response.status == 200:
+                    try:
+                        response_data = await response.json()
+                        return RpaHistorico(**response_data)
+                    except aiohttp.ContentTypeError:
+                        return {
+                            "error": "Resposta não é JSON",
+                            "status_code": response.status,
+                        }
+                else:
+                    return {"error": response_text, "status_code": response.status}
+    except aiohttp.ClientError as e:
+        logger.error(f"Erro de cliente aiohttp: {str(e)}")
+        return {"error": str(e), "status_code": 500}
+    except ValueError as e:
+        logger.error(f"Erro de valor: {str(e)}")
+        return {"error": str(e), "status_code": 400}
+    except Exception as e:
+        logger.error(f"Erro inesperado: {str(e)}")
+        return {"error": str(e), "status_code": 500}

worker_automate_hub-0.5.13/worker_automate_hub/models/dao/rpa_fila.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class RpaFila(BaseModel):
+    uuidFila: Optional[str] = Field(None, alias="uuidFila")
+    uuidRobo: Optional[str] = Field(None, alias="uuidRobo")
+    uuidProcesso: str = Field(..., alias="uuidProcesso")
+    prioridade: int = Field(..., alias="prioridade")
+    configEntrada: Optional[dict] = Field(None, alias="configEntrada")
+    dtLeituraFila: Optional[datetime] = Field(None, alias="dtLeituraFila")
+    lock: Optional[bool] = Field(None, alias="lock")
+    mutarNotificacao: Optional[int] = Field(None, alias="mutarNotificacao")
+
+    class Config:
+        populate_by_name = True

{worker_automate_hub-0.5.10 → worker_automate_hub-0.5.13}/worker_automate_hub/tasks/jobs/fechar_conexao_rdp.py

@@ -21,7 +21,7 @@ class RDPConnection:
         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")
+        self.uuid_robo = task.configEntrada.get("uuidRobo")
 
     async def verificar_conexao(self) -> bool:
         """

worker_automate_hub-0.5.13/worker_automate_hub/tasks/task_executor.py

@@ -0,0 +1,122 @@
+from pytz import timezone
+from rich.console import Console
+
+from worker_automate_hub.api.client import get_processo, send_gchat_message
+from worker_automate_hub.api.rpa_fila_service import burn_queue
+from worker_automate_hub.api.rpa_historico_service import (
+    create_store_historico,
+    create_update_historico,
+)
+from worker_automate_hub.api.webhook_service import send_to_webhook
+from worker_automate_hub.config.settings import load_worker_config
+from worker_automate_hub.models.dao.rpa_historico import RpaHistorico
+from worker_automate_hub.models.dao.rpa_processo import RpaProcesso
+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 worker_automate_hub.tasks.task_definitions import task_definitions
+from worker_automate_hub.utils.logger import logger
+from worker_automate_hub.utils.toast import show_toast
+from worker_automate_hub.utils.util import capture_and_send_screenshot
+
+console = Console()
+
+
+async def perform_task(task: RpaProcessoEntradaDTO):
+    log_msg = f"Processo a ser executado: {task.nomProcesso}"
+    show_toast("Info", f"Processo a ser executado: {task.nomProcesso}")
+
+    console.print(f"\n{log_msg}\n", style="green")
+    logger.info(log_msg)
+    task_uuid = task.uuidProcesso
+    url_retorno = task.configEntrada.get("urlRetorno", None)
+    processo: RpaProcesso = await get_processo(task_uuid)
+    if processo is None:
+        worker_config = load_worker_config()
+        err_msg = f"[WORKER] [{worker_config['NOME_ROBO']}] Falha ao obter o processo [{task.nomProcesso}] uuid [{task_uuid}] da API, não foi possivel registrar o historico, mas o processo será executado."
+        console.print(err_msg, style="yellow")
+        logger.error(err_msg)
+        show_toast("Erro", err_msg)
+        await send_gchat_message(err_msg)
+        registrar_historico = False
+    else:
+        registrar_historico = True
+
+    if registrar_historico:
+        historico: RpaHistorico = await create_store_historico(
+            task, processo, RpaHistoricoStatusEnum.Processando
+        )
+    try:
+        if task_uuid in task_definitions:
+            # Executar a task
+            if task_uuid == "276d0c41-0b7c-4446-ae0b-dd5d782917cc":
+                task.historico_id = historico.uuidHistorico
+
+            result: RpaRetornoProcessoDTO = await task_definitions[task_uuid](task)
+            if registrar_historico:
+                await create_update_historico(
+                    historico_uuid=historico.uuidHistorico,
+                    task=task,
+                    retorno_processo=result,
+                    processo=processo,
+                )
+
+            if result.sucesso == False:
+                show_toast("Erro", f"Processo executado com falha: {result}")
+
+                await capture_and_send_screenshot(
+                    uuidRelacao=historico.uuidHistorico, desArquivo=result.retorno
+                )
+            else:
+                show_toast("Sucesso", f"Processo executado com sucesso: {result}")
+
+            if url_retorno is not None and result.sucesso == False:
+                await send_to_webhook(url_retorno, result.status, result.retorno)
+            return result
+        else:
+            err_msg = f"Processo não encontrado: {task_uuid}"
+            console.print(err_msg, style="yellow")
+            logger.error(err_msg)
+            show_toast("Erro", err_msg)
+
+            if registrar_historico:
+                await create_update_historico(
+                    historico_uuid=historico.uuidHistorico,
+                    task=task,
+                    retorno_processo=RpaRetornoProcessoDTO(
+                        sucesso=False,
+                        retorno=err_msg,
+                        status=RpaHistoricoStatusEnum.Descartado,
+                    ),
+                    processo=processo,
+                )
+            await burn_queue(task.uuidFila)
+            if url_retorno is not None:
+                await send_to_webhook(
+                    url_retorno, RpaHistoricoStatusEnum.Descartado, err_msg
+                )
+            return None
+    except Exception as e:
+        err_msg = f"Erro ao performar o processo: {e}"
+        console.print(f"\n{err_msg}\n", style="red")
+        logger.error(err_msg)
+        show_toast("Erro", err_msg)
+
+        if registrar_historico:
+            await create_update_historico(
+                historico_uuid=historico.uuidHistorico,
+                task=task,
+                retorno_processo=RpaRetornoProcessoDTO(
+                    sucesso=False, retorno=err_msg, status=RpaHistoricoStatusEnum.Falha
+                ),
+                processo=processo,
+            )
+        await capture_and_send_screenshot(
+            uuidRelacao=historico.uuidHistorico, desArquivo=err_msg
+        )
+        if url_retorno is not None:
+            await send_to_webhook(url_retorno, RpaHistoricoStatusEnum.Falha, err_msg)

{worker_automate_hub-0.5.10 → worker_automate_hub-0.5.13}/worker_automate_hub/worker.py

@@ -3,19 +3,30 @@ import os
 import threading
 from pathlib import Path
 
-from worker_automate_hub.api.rpa_fila_service import burn_queue, unlock_queue
 import pyfiglet
 from rich.console import Console
 
 from worker_automate_hub.api.client import (
     get_new_task,
+    get_processo,
     notify_is_alive,
     send_gchat_message,
 )
+from worker_automate_hub.api.rpa_fila_service import burn_queue
+from worker_automate_hub.api.rpa_historico_service import (
+    create_store_historico,
+)
 from worker_automate_hub.config.settings import (
     load_env_config,
     load_worker_config,
 )
+from worker_automate_hub.models.dao.rpa_processo import RpaProcesso
+from worker_automate_hub.models.dto.rpa_historico_request_dto import (
+    RpaHistoricoStatusEnum,
+    RpaRetornoProcessoDTO,
+    RpaTagDTO,
+    RpaTagEnum,
+)
 from worker_automate_hub.models.dto.rpa_processo_entrada_dto import (
     RpaProcessoEntradaDTO,
 )
@@ -40,15 +51,29 @@ async def check_and_execute_tasks(stop_event: threading.Event):
             worker_config = load_worker_config()
             if task is not None:
                 processo_existe = await is_uuid_in_tasks(task.uuidProcesso)
+                await burn_queue(task.uuidFila)
                 if processo_existe:
-                    await burn_queue(task.uuidFila)
                     logger.info(f"Executando a task: {task.nomProcesso}")
                     await perform_task(task)
                 else:
-                    await unlock_queue(task.uuidFila)
-                    log_message = f"O processo [{task.nomProcesso}] não existe no Worker [{worker_config['NOME_ROBO']}] e foi devolvido para a fila."
+                    log_message = f"O processo [{task.nomProcesso}] não existe no Worker [{worker_config['NOME_ROBO']}] e foi removido da fila."
                     console.print(f"\n{log_message}\n", style="yellow")
                     logger.error(log_message)
+                    try:
+                        processo: RpaProcesso = await get_processo(task.uuidProcesso)
+                        await create_store_historico(
+                            task,
+                            processo,
+                            RpaHistoricoStatusEnum.Descartado,
+                            retorno_processo=RpaRetornoProcessoDTO(
+                                sucesso=False,
+                                retorno=log_message,
+                                status=RpaHistoricoStatusEnum.Descartado,
+                                tags=[RpaTagDTO(descricao=RpaTagEnum.Tecnico)],
+                            ),
+                        )
+                    except Exception as e:
+                        console.print(f"Erro ao salvar histórico de processo não implementado: {e}", style="bold red")
                     await send_gchat_message(log_message)
             else:
                 await asyncio.sleep(5)

worker_automate_hub-0.5.10/worker_automate_hub/api/rpa_historico_service.py

@@ -1,123 +0,0 @@
-import aiohttp
-
-from worker_automate_hub.config.settings import load_env_config
-from worker_automate_hub.models.dao.rpa_historico import RpaHistorico
-from worker_automate_hub.models.dto.rpa_historico_request_dto import (
-    RpaHistoricoRequestDTO,
-)
-from worker_automate_hub.utils.logger import logger
-
-
-async def store(data: RpaHistoricoRequestDTO) -> dict:
-    """
-    Armazena o histórico de um processo com status Processando.
-
-    Recebe um RpaHistoricoRequestDTO como parâmetro e salva o
-    histórico com status Processando. Retorna um dicionário com o uuid do
-    histórico salvo.
-
-    Args:
-        data (RpaHistoricoRequestDTO): O histórico a ser salvo.
-
-    Returns:
-        RpaHistorico: Dicionário com o uuid do histórico salvo.
-    """
-    env_config, _ = load_env_config()
-
-    if not data:
-        raise ValueError("Parâmetro data deve ser informado")
-
-    if not isinstance(data, RpaHistoricoRequestDTO):
-        raise TypeError("Parâmetro data deve ser do tipo RpaHistoricoRequestDTO")
-
-    headers_basic = {
-        "Authorization": f"Basic {env_config["API_AUTHORIZATION"]}",
-        "Content-Type": "application/json",
-    }
-    try:
-        async with aiohttp.ClientSession(
-            connector=aiohttp.TCPConnector(verify_ssl=True)
-        ) as session:
-            payload = data.model_dump_json()
-
-            async with session.post(
-                f"{env_config["API_BASE_URL"]}/historico",
-                data=payload,
-                headers=headers_basic,
-            ) as response:
-                response_text = await response.text()
-                logger.info(f"Resposta store: {response_text}")
-
-                if response.status == 200:
-                    try:
-                        response_data = await response.json()
-                        return RpaHistorico(**response_data)
-                    except aiohttp.ContentTypeError:
-                        return {
-                            "error": "Resposta não é JSON",
-                            "status_code": response.status,
-                        }
-                else:
-                    return {"error": response_text, "status_code": response.status}
-    except aiohttp.ClientError as e:
-        logger.error(f"Erro de cliente aiohttp: {str(e)}")
-        return {"error": str(e), "status_code": 500}
-    except Exception as e:
-        logger.error(f"Erro inesperado: {str(e)}")
-        return {"error": str(e), "status_code": 500}
-
-
-async def update(data: RpaHistoricoRequestDTO) -> dict:
-    """
-    Atualiza um registro de histórico com base no uuidHistorico informado.
-
-    Args:
-        data (RpaHistoricoRequestDTO): Os dados do histórico a ser atualizado.
-
-    Returns:
-        RpaHistorico: O histórico atualizado.
-    """
-    env_config, _ = load_env_config()
-    headers_basic = {
-        "Authorization": f"Basic {env_config["API_AUTHORIZATION"]}",
-        "Content-Type": "application/json",
-    }
-    if not data or not isinstance(data, RpaHistoricoRequestDTO):
-        raise TypeError("Parâmetro data deve ser do tipo RpaHistoricoRequestDTO")
-    try:
-        async with aiohttp.ClientSession(
-            connector=aiohttp.TCPConnector(verify_ssl=True)
-        ) as session:
-            if not data.uuidHistorico:
-                raise ValueError("Parâmetro uuidHistorico deve ser informado")
-
-            payload = data.model_dump_json()
-
-            async with session.put(
-                f"{env_config["API_BASE_URL"]}/historico",
-                data=payload,
-                headers=headers_basic,
-            ) as response:
-                response_text = await response.text()
-                logger.info(f"Resposta update: {response_text}")
-
-                if response.status == 200:
-                    try:
-                        response_data = await response.json()
-                        return RpaHistorico(**response_data)
-                    except aiohttp.ContentTypeError:
-                        return {
-                            "error": "Resposta não é JSON",
-                            "status_code": response.status,
-                        }
-                else:
-                    return {"error": response_text, "status_code": response.status}
-    except aiohttp.ClientError as e:
-        logger.error(f"Erro de cliente aiohttp: {str(e)}")
-        return {"error": str(e), "status_code": 500}
-    except ValueError as e:
-        logger.error(f"Erro de valor: {str(e)}")
-        return {"error": str(e), "status_code": 400}
-    except Exception as e:
-        logger.error(f"Erro inesperado: {str(e)}")
-        return {"error": str(e), "status_code": 500}

worker_automate_hub-0.5.10/worker_automate_hub/tasks/task_executor.py

@@ -1,247 +0,0 @@
-from datetime import datetime
-
-from pytz import timezone
-from worker_automate_hub.api.webhook_service import send_to_webhook
-from rich.console import Console
-
-from worker_automate_hub.api.client import (
-    get_processo,
-    send_gchat_message,
-)
-from worker_automate_hub.api.rpa_fila_service import unlock_queue
-from worker_automate_hub.api.rpa_historico_service import store, update
-from worker_automate_hub.models.dao.rpa_historico import RpaHistorico
-from worker_automate_hub.models.dao.rpa_processo import RpaProcesso
-from worker_automate_hub.models.dto.rpa_historico_request_dto import (
-    RpaHistoricoRequestDTO,
-    RpaHistoricoStatusEnum,
-    RpaRetornoProcessoDTO,
-)
-from worker_automate_hub.models.dto.rpa_processo_entrada_dto import (
-    RpaProcessoEntradaDTO,
-)
-from worker_automate_hub.tasks.task_definitions import task_definitions
-from worker_automate_hub.utils.logger import logger
-from worker_automate_hub.utils.toast import show_toast
-from worker_automate_hub.utils.util import capture_and_send_screenshot
-from worker_automate_hub.config.settings import (
-    load_worker_config,
-)
-
-console = Console()
-
-
-async def perform_task(task: RpaProcessoEntradaDTO):
-    log_msg = f"Processo a ser executado: {task.nomProcesso}"
-    show_toast("Info", f"Processo a ser executado: {task.nomProcesso}")
-
-    console.print(f"\n{log_msg}\n", style="green")
-    logger.info(log_msg)
-    task_uuid = task.uuidProcesso
-    url_retorno = task.configEntrada.get("urlRetorno", None)
-    processo: RpaProcesso = await get_processo(task_uuid)
-    if processo is None:
-        worker_config = load_worker_config()
-        err_msg = f"[WORKER] [{worker_config['NOME_ROBO']}] Falha ao obter o processo [{task.nomProcesso}] uuid [{task_uuid}] da API, não foi possivel registrar o historico, mas o processo será executado."
-        console.print(err_msg, style="yellow")
-        logger.error(err_msg)
-        show_toast("Erro", err_msg)
-        await send_gchat_message(err_msg)
-        registrar_historico = False
-    else:
-        registrar_historico = True
-
-    if registrar_historico:
-        historico: RpaHistorico = await _store_historico(task, processo)
-    try:
-        if task_uuid in task_definitions:
-            # Executar a task
-            if task_uuid == "276d0c41-0b7c-4446-ae0b-dd5d782917cc":
-                task.historico_id = historico.uuidHistorico
-
-            result: RpaRetornoProcessoDTO = await task_definitions[task_uuid](task)
-            if registrar_historico:
-                await _update_historico(
-                    historico_uuid=historico.uuidHistorico,
-                    task=task,
-                    retorno_processo=result,
-                    processo=processo,
-                )
-
-            if result.sucesso == False:
-                show_toast("Erro", f"Processo executado com falha: {result}")
-
-                await capture_and_send_screenshot(
-                    uuidRelacao=historico.uuidHistorico, desArquivo=result.retorno
-                )
-            else:
-                show_toast("Sucesso", f"Processo executado com sucesso: {result}")
-
-            if url_retorno is not None and result.sucesso == False:
-                await send_to_webhook(url_retorno, result.status, result.retorno)
-            return result
-        else:
-            err_msg = f"Processo não encontrado: {task_uuid}"
-            console.print(err_msg, style="yellow")
-            logger.error(err_msg)
-            show_toast("Erro", err_msg)
-
-            if registrar_historico:
-                await _update_historico(
-                    historico_uuid=historico.uuidHistorico,
-                    task=task,
-                    retorno_processo=RpaRetornoProcessoDTO(
-                        sucesso=False,
-                        retorno=err_msg,
-                        status=RpaHistoricoStatusEnum.Falha,
-                    ),
-                    processo=processo,
-                )
-            await unlock_queue(task.uuidFila)
-            if url_retorno is not None:
-                await send_to_webhook(url_retorno, RpaHistoricoStatusEnum.Falha, err_msg)
-            return None
-    except Exception as e:
-        err_msg = f"Erro ao performar o processo: {e}"
-        console.print(f"\n{err_msg}\n", style="red")
-        logger.error(err_msg)
-        show_toast("Erro", err_msg)
-
-        if registrar_historico:
-            await _update_historico(
-                historico_uuid=historico.uuidHistorico,
-                task=task,
-                retorno_processo=RpaRetornoProcessoDTO(
-                    sucesso=False, retorno=err_msg, status=RpaHistoricoStatusEnum.Falha
-                ),
-                processo=processo,
-            )
-        await capture_and_send_screenshot(
-            uuidRelacao=historico.uuidHistorico, desArquivo=err_msg
-        )
-        if url_retorno is not None:
-            await send_to_webhook(url_retorno, RpaHistoricoStatusEnum.Falha, err_msg)
-
-
-async def _store_historico(
-    task: RpaProcessoEntradaDTO, processo: RpaProcesso
-) -> RpaHistorico:
-    """
-    Salva o histórico de um processo com status Processando.
-
-    Recebe um RpaProcessoEntradaDTO e um RpaProcesso como parâmetro e salva o
-    histórico com status Processando. Retorna um dicionário com o uuid do
-    histórico salvo.
-
-    Args:
-        task (RpaProcessoEntradaDTO): O processo a ser salvo.
-        processo (RpaProcesso): O processo que está sendo executado.
-
-    Returns:
-        RpaHistorico: Dicionário com o uuid do histórico salvo.
-    """
-    try:
-        from worker_automate_hub.config.settings import load_worker_config
-
-        worker_config = load_worker_config()
-        tz = timezone("America/Sao_Paulo")
-        start_time = datetime.now(tz).isoformat()
-
-        identificador_processo = (
-            task.configEntrada.get("nfe") or 
-            task.configEntrada.get("empresa") or 
-            ""
-        )
-
-
-        # Armazenar início da operação no histórico
-        start_data = RpaHistoricoRequestDTO(
-            uuidProcesso=task.uuidProcesso,
-            uuidRobo=worker_config["UUID_ROBO"],
-            prioridade=processo.prioridade,
-            desStatus=RpaHistoricoStatusEnum.Processando,
-            configEntrada=task.configEntrada,
-            datInicioExecucao=start_time,
-            datEntradaFila=task.datEntradaFila,
-            identificador=identificador_processo,
-        )
-
-        store_response: RpaHistorico = await store(start_data)
-        console.print(
-            f"\nHistorico salvo com o uuid: {store_response.uuidHistorico}\n",
-            style="green",
-        )
-        return store_response
-    except Exception as e:
-        err_msg = f"Erro ao salvar o registro no histórico: {e}"
-        console.print(f"\n{err_msg}\n", style="red")
-        logger.error(f"{err_msg}")
-
-
-async def _update_historico(
-    historico_uuid: str,
-    task: RpaProcessoEntradaDTO,
-    retorno_processo: RpaRetornoProcessoDTO,
-    processo: RpaProcesso,
-):
-    """
-    Atualiza o histórico de um processo com o status de sucesso ou falha.
-
-    Recebe o uuid do histórico, o RpaProcessoEntradaDTO do processo, um booleano
-    indicando se o processo foi um sucesso ou não, o RpaRetornoProcessoDTO do
-    processo e o RpaProcesso do processo como parâmetro e atualiza o histórico
-    com o status de sucesso ou falha. Retorna um dicionário com o uuid do
-    histórico atualizado.
-
-    Args:
-        historico_uuid (str): O uuid do histórico.
-        task (RpaProcessoEntradaDTO): O RpaProcessoEntradaDTO do processo.
-        sucesso (bool): Um booleano indicando se o processo foi um sucesso ou não.
-        retorno_processo (RpaRetornoProcessoDTO): O RpaRetornoProcessoDTO do processo.
-        processo (RpaProcesso): O RpaProcesso do processo.
-
-    Returns:
-        RpaHistorico: Dicionário com o uuid do histórico atualizado.
-    """
-
-    try:
-        from worker_automate_hub.config.settings import load_worker_config
-
-        worker_config = load_worker_config()
-        tz = timezone("America/Sao_Paulo")
-        des_status: RpaHistoricoStatusEnum = retorno_processo.status
-        end_time = datetime.now(tz).isoformat()
-
-        identificador_processo = (
-            task.configEntrada.get("nfe") or 
-            task.configEntrada.get("empresa") or 
-            ""
-        )
-        if not retorno_processo.tags:
-            retorno_processo.tags = []
-
-        # Armazenar fim da operação no histórico
-        end_data = RpaHistoricoRequestDTO(
-            uuidHistorico=historico_uuid,
-            uuidProcesso=task.uuidProcesso,
-            uuidRobo=worker_config["UUID_ROBO"],
-            prioridade=processo.prioridade,
-            desStatus=des_status,
-            configEntrada=task.configEntrada,
-            retorno=retorno_processo,
-            datFimExecucao=end_time,
-            identificador=identificador_processo,
-            tags=retorno_processo.tags,
-        )
-
-        update_response: RpaHistorico = await update(end_data)
-        console.print(
-            f"\nHistorico atualizado com o uuid: {update_response.uuidHistorico}\n",
-            style="green",
-        )
-        return update_response
-
-    except Exception as e:
-        err_msg = f"Erro ao atualizar o histórico do processo: {e}"
-        console.print(f"\n{err_msg}\n", style="red")
-        logger.error(err_msg)