csc-cia-stne 0.0.30__py3-none-any.whl → 0.0.31__py3-none-any.whl

csc_cia_stne/servicenow.py

@@ -2,10 +2,35 @@ import requests
 import base64, json
 import os
 import logging
+from pydantic import  ValidationError
+from .utilitarios.validations.ServiceNowValidator import InitParamsValidator, RequestValidator, PutValidator, PostValidator, ListTicketValidator, UpdateTicketValidator, AttachFileTicketValidator, GetAttachValidator
 
 class ServiceNow:
     
     def __init__(self, username: str = None, password: str = None, env: str = None) -> None:
+        """
+        Inicializa uma instância da classe ServiceNow.
+
+        Parâmetros:
+            username (str): Nome de usuário para autenticação. Obrigatório e não pode ser nulo ou vazio.
+            password (str): Senha para autenticação. Obrigatória e não pode ser nula ou vazia.
+            env (str): Ambiente no qual a instância será utilizada. Deve ser 'dev', 'qa', 'qas' ou 'prod'.
+        
+        Raises:
+            ValueError: Caso qualquer um dos parâmetros não seja fornecido, seja nulo ou vazio, ou se 'env' não for um valor válido.
+        
+        Atributos:
+            username (str): Nome de usuário normalizado.
+            password (str): Senha normalizada.
+            env (str): Nome do ambiente em letras maiúsculas.
+            api_url (str): URL base da API correspondente ao ambiente.
+            api_header (dict): Cabeçalhos padrão para requisições API.
+        """
+        try:
+            InitParamsValidator(username=username, password=password, env=env, )
+        except ValidationError as e:
+            raise ValueError("Erro na validação dos dados de input da inicialização da instância 'ServiceNow':", e.errors())
+    
         # Verifica se todos os parâmetros foram fornecidos e não estão vazios
         if not all([username and username.strip(), password and password.strip(), env and env.strip()]):
             raise ValueError("Todos os parâmetros precisam ser fornecidos para a criação da instância ServiceNow, ou algum dos valores esta nulo ou vazio (username, password, env)")
@@ -40,14 +65,47 @@ class ServiceNow:
         """
         return (self.username, self.password)
     
-    def request (self, url, params = ""):
+    def request (self, url : str , params : str = "", timout : int = 15):
+        """
+        Realiza uma requisição GET para a URL especificada.
+
+        Parâmetros:
+            url (str): URL para a qual a requisição será enviada.
+            params (dict, opcional): Parâmetros de consulta (query parameters) a serem incluídos na requisição. 
+                Padrão é uma string vazia.
+
+        Retorno:
+            dict: Um dicionário contendo:
+                - success (bool): Indica se a requisição foi bem-sucedida.
+                - result (dict ou None): Resultado da resposta, se disponível. Contém o conteúdo JSON do campo "result".
+                - error (Exception ou None): Objeto de exceção em caso de erro, ou None se não houver erros.
+
+        Tratamento de exceções:
+            - requests.exceptions.HTTPError: Lança um erro HTTP caso o código de status indique falha.
+            - requests.exceptions.RequestException: Captura outros erros relacionados à requisição, como timeout ou conexão.
+            - Exception: Captura erros inesperados.
+
+        Logs:
+            - Logs de depuração são gerados para erros HTTP, erros de requisição e exceções inesperadas.
+            - Um aviso é registrado caso a resposta não contenha o campo "result".
+
+        Observações:
+            - Utiliza autenticação fornecida pelo método privado `__auth()`.
+            - Define um tempo limite (`timeout`) de 15 segundos.
+            - Verifica o certificado SSL (`verify=True`).
+        """
+        try:
+            RequestValidator(url=url, params=params, timeout=timout)
+        except ValidationError as e:
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+        
         try:
             response = requests.get(
                 url, 
                 params=params,
                 auth=self.__auth(),
                 headers=self.api_header,
-                timeout=15,
+                timeout=timout,
                 verify=True
             )
 
@@ -57,22 +115,55 @@ class ServiceNow:
              # Analisa o conteúdo da resposta JSON
             result = response.json()
             if "result" in result:
-                return result["result"]
+                return {"success" : True, "result" : result}
             else:
-                logging.warning("A resposta não contém o campo 'result'.")
-                return {}
+                logging.debug("A resposta não contém o campo 'result'.")
+                return {"success" : False, "result" : result}
 
         except requests.exceptions.HTTPError as http_err:
-            logging.error(f"Erro HTTP ao buscar os detalhes do ticket: {http_err}")
-            raise
+            logging.debug(f"Erro HTTP ao buscar os detalhes do ticket: {http_err}")
+            return {"success" : False, "result" : None, "error" : str(http_err)}
+        
         except requests.exceptions.RequestException as req_err:
-            logging.error(f"Erro ao buscar os detalhes do ticket: {req_err}")
-            raise
+            logging.debug(f"Erro ao buscar os detalhes do ticket: {req_err}")
+            return {"success" : False, "result" : None, "error" : str(req_err)}
+        
         except Exception as e:
-            logging.error(f"Erro inesperado: {e}")
-            raise
+            logging.debug(f"Erro inesperado: {e}")
+            return {"success" : False, "result" : None, "error" : str(e)}
 
-    def put(self, url, payload):
+    def put(self, url, payload, timeout = 15):
+        """
+        Realiza uma requisição PUT para a URL especificada.
+
+        Parâmetros:
+            url (str): URL para a qual a requisição será enviada.
+            payload (dict): Dados a serem enviados no corpo da requisição. Será convertido para JSON.
+
+        Retorno:
+            dict: Um dicionário contendo:
+                - success (bool): Indica se a requisição foi bem-sucedida.
+                - result (dict ou None): Resultado da resposta, se disponível. Contém o conteúdo JSON do campo "result".
+
+        Tratamento de exceções:
+            - requests.exceptions.HTTPError: Lança um erro HTTP caso o código de status indique falha. O erro é registrado nos logs.
+            - requests.exceptions.RequestException: Captura outros erros relacionados à requisição, como timeout ou problemas de conexão. O erro é registrado nos logs.
+            - Exception: Captura erros inesperados e os registra nos logs.
+
+        Logs:
+            - Registra mensagens de depuração detalhadas quando a atualização é bem-sucedida ou quando a resposta não contém o campo "result".
+            - Registra mensagens de erro para exceções HTTP, erros de requisição e outros erros inesperados.
+
+        Observações:
+            - Utiliza autenticação fornecida pelo método privado `__auth()`.
+            - Define um tempo limite (`timeout`) de 15 segundos.
+            - Verifica o certificado SSL (`verify=True`).
+            - O cabeçalho da requisição é definido com `self.api_header`.
+        """
+        try:
+            PutValidator(url=url, payload=payload, timeout=timeout)
+        except ValidationError as e:
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
         
         payload = json.dumps(payload)
 
@@ -82,7 +173,7 @@ class ServiceNow:
                 auth=self.__auth(),
                 headers=self.api_header,
                 data=f"{payload}",
-                timeout=15,
+                timeout=timeout,
                 verify=True
             )
 
@@ -93,24 +184,26 @@ class ServiceNow:
             result = response.json()
             if "result" in result:
                 update = result["result"]
-                logging.info(f"Atualização concluída com sucesso. Registro atualizado: {update["sys_id"]} | Alterações: {payload}")
+                logging.debug(f"Atualização concluída com sucesso. Registro atualizado: {update["sys_id"]} | Alterações: {payload}")
+                return {"success" : True, "result" : update}
             else:
-                logging.warning(f"A Resposta da sua requisição não contém o campo 'Result'. Segue o retorno: \n {result} | Alterações: {payload}")
+                logging.debug(f"A Resposta da sua requisição não contém o campo 'Result'. Segue o retorno: \n {result} | Alterações: {payload}")
+                return {"success" : False, "result" : result}
         
         #TRATAMENTOS DE ERRO 
         except requests.exceptions.HTTPError as http_err:
-
-            logging.error(f"Erro HTTP ao tentar atualizar o ticket: {http_err} \n Reposta da solicitação: {response.json().get("error").get("message")}")
-            raise
+            logging.debug(f"Erro HTTP ao tentar atualizar o ticket: {http_err} \n Reposta da solicitação: {response.json().get("error").get("message")}")
+            return {"success" : False, "error" : str(http_err) , "result" : None}
+        
         except requests.exceptions.RequestException as req_err:
-            
-            logging.error(f"Erro ao tentar atualizar o ticket: \n {req_err}")
-            raise
+            logging.debug(f"Erro ao tentar atualizar o ticket: \n {req_err}")
+            return {"success" : False, "error" : str(req_err) , "result" : None}
+        
         except Exception as e:
-            logging.error(f"Erro inesperado: \n {e}")
-            raise
+            logging.debug(f"Erro inesperado: \n {e}")
+            return {"success" : False, "error" : str(e) , "result" : None}
     
-    def post(self, url, variables, header_content_type = ""):
+    def post(self, url : str, variables : dict, header_content_type = "", timeout : int = 15):
         """
             Função para criar um novo ticket no servicenow usando o API REST.
 
@@ -122,6 +215,12 @@ class ServiceNow:
                     - Exception: Se ocorrer um erro ao criar o ticket.
 
         """
+        try: 
+            PostValidator(url=url, variables=variables)
+        except ValidationError as e:
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+        
+
         if header_content_type:
             header = header_content_type
         else:
@@ -137,7 +236,8 @@ class ServiceNow:
                 f"{url}",
                 auth=self.__auth(),
                 headers=header,
-                data=f"{payload}"
+                data=f"{payload}",
+                timeout=timeout
             )
 
             # VALIDA SE HOUVE SUCESSO NA REQUISIÇÃO
@@ -148,23 +248,25 @@ class ServiceNow:
             if "result" in result:
                 ticket_number = result["result"].get("number")
                 ticket_sys_id = result["result"].get("sys_id")
-                logging.info(f"Ticket registrado com sucesso. Número: {ticket_number} | SYS_ID: {ticket_sys_id}")
-                return result["result"]
+                logging.debug(f"Ticket registrado com sucesso. Número: {ticket_number} | SYS_ID: {ticket_sys_id}")
+                return {"success" : True, "result" : result["result"]}
             else:
-                logging.warning(f"A Resposta da sua requisição não contém o campo 'Result'. Segue o retorno: \n {result}")
+                logging.debug(f"A Resposta da sua requisição não contém o campo 'Result'. Segue o retorno: \n {result}")
+                return {"success" : False, "result" : result}
         
         #TRATAMENTOS DE ERRO 
         except requests.exceptions.HTTPError as http_err:
 
-            logging.error(f"Erro HTTP ao tentar registrar o ticket: {http_err} \n Reposta da solicitação: {response.json().get("error").get("message")}")
-            raise
+            logging.debug(f"Erro HTTP ao tentar registrar o ticket: {http_err} \n Reposta da solicitação: {response.json().get("error").get("message")}")
+            return {"success" : False, "error" : str(http_err) , "result" : None}
+        
         except requests.exceptions.RequestException as req_err:
-            
-            logging.error(f"Erro ao tentar registrar o ticket: \n {req_err}")
-            raise
+            logging.debug(f"Erro ao tentar registrar o ticket: \n {req_err}")
+            return {"success" : False, "error" : str(req_err) , "result" : None}
+        
         except Exception as e:
-            logging.error(f"Erro inesperado: \n {e}")
-            raise
+            logging.debug(f"Erro inesperado: \n {e}")
+            return {"success" : False, "error" : str(e) , "result" : None}
     
     def listar_tickets(self, tabela: str = None, campos: list = None, query: str = None, limite: int = 50, timeout:int=15)->dict:
         """lista tickets do ServiceNow
@@ -179,43 +281,53 @@ class ServiceNow:
         Returns:
             dict: dicionário com o resultado da query
         """
-        # Validação de 'tabela'
-        if not tabela or not tabela.strip():
-            raise ValueError("O parâmetro 'tabela' precisa ser especificado com o nome da tabela de onde os tickets serão listados.")
-
-        # Validação de 'campos'
-        if not isinstance(campos, list) or not campos or not all(isinstance(campo, str) and campo.strip() for campo in campos):
-            raise ValueError("O parâmetro 'campos' precisa ser uma lista não vazia de strings válidas com os nomes dos campos do formulário.")
-
-        # Validação de 'query'
-        if not query or not query.strip():
-            raise ValueError("O parâmetro 'query' precisa ser uma string não vazia.")
-
-        # Validação de 'timeout'
-        if not isinstance(timeout, int):
-            raise ValueError("O parâmetro 'timeout' precisa ser um valor (int) em segundos.")
-
-        # Validação de 'limite'
-        if not isinstance(limite, int):
-            raise ValueError("O parâmetro 'limite' precisa ser um número inteiro.")
-
-        params = {}
-        params["sysparm_query"] = query
-        params["sysparm_fields"] = ','.join(campos)
-        params["sysparm_display_value"] = "all"
-        params["sysparm_limit"] = limite
+        try:
+            ListTicketValidator(tabela=tabela, campos=campos, query=query, limite=limite, timeout=timeout)
+        except ValidationError as e:
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+        
+        # # Validação de 'tabela'
+        # if not tabela or not tabela.strip():
+        #     raise ValueError("O parâmetro 'tabela' precisa ser especificado com o nome da tabela de onde os tickets serão listados.")
+
+        # # Validação de 'campos'
+        # if not isinstance(campos, list) or not campos or not all(isinstance(campo, str) and campo.strip() for campo in campos):
+        #     raise ValueError("O parâmetro 'campos' precisa ser uma lista não vazia de strings válidas com os nomes dos campos do formulário.")
+
+        # # Validação de 'query'
+        # if not query or not query.strip():
+        #     raise ValueError("O parâmetro 'query' precisa ser uma string não vazia.")
+
+        # # Validação de 'timeout'
+        # if not isinstance(timeout, int):
+        #     raise ValueError("O parâmetro 'timeout' precisa ser um valor (int) em segundos.")
+
+        # # Validação de 'limite'
+        # if not isinstance(limite, int):
+        #     raise ValueError("O parâmetro 'limite' precisa ser um número inteiro.")
+
+        params = {
+            "sysparm_query" : query,
+            "sysparm_fields" : ','.join(campos),
+            "sysparm_display_value" : "all",
+            "sysparm_limit" : limite
+        }
+        # params["sysparm_query"] = query
+        # params["sysparm_fields"] = ','.join(campos)
+        # params["sysparm_display_value"] = "all"
+        # params["sysparm_limit"] = limite
 
         url = f"{self.api_url}/now/table/{tabela}"
         
         try:
-            response = self.request(url, params)
+            response = self.request(url=url, params=params, timout=timeout)
             # response = requests.get(url, params=params, auth=(self.username, self.password), headers=self.api_header, verify=True, timeout=timeout)
-            return {"result":True, "content": response.json()}
+            return {"success":True, "result": response.json()}
         
         except Exception as e:
-            return {}
+            return {"success" : False, "result" : None, "error" : str(e)}
 
-    def update_ticket(self, tabela: str = None, sys_id: str = None, campos: dict = None, timeout:int=15)->dict:
+    def update_ticket(self, tabela: str = None, sys_id: str = None, payload: dict = None, timeout:int=15)->dict:
         """Atualiza as informações de um ticket
 
         Args:
@@ -227,34 +339,36 @@ class ServiceNow:
         Returns:
             dict: resposta do ServiceNow
         """
+        try:
+            UpdateTicketValidator(tabela=tabela, sys_id=sys_id, payload=payload, timeout=timeout)
+        except ValidationError as e:
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+        
+        # # Validação de 'tabela'
+        # if not tabela or not tabela.strip():
+        #     raise ValueError("O parâmetro 'tabela' precisa ser especificado com o nome da tabela de onde o ticket será atualizado.")
 
-        # Validação de 'tabela'
-        if not tabela or not tabela.strip():
-            raise ValueError("O parâmetro 'tabela' precisa ser especificado com o nome da tabela de onde o ticket será atualizado.")
-
-        # Validação de 'sys_id'
-        if not sys_id or not sys_id.strip():
-            raise ValueError("O parâmetro 'sys_id' precisa ser especificado com o sys_id do ticket.")
+        # # Validação de 'sys_id'
+        # if not sys_id or not sys_id.strip():
+        #     raise ValueError("O parâmetro 'sys_id' precisa ser especificado com o sys_id do ticket.")
 
-        # Validação de 'campos'
-        if not isinstance(campos, dict):
-            raise ValueError("O parâmetro 'campos' precisa ser um dicionário contendo os campos do ticket a serem atualizados.")
+        # # Validação de 'payload'
+        # if not isinstance(payload, dict):
+        #     raise ValueError("O parâmetro 'campos' precisa ser um dicionário contendo os campos do ticket a serem atualizados.")
 
-        if "assigned_to" not in campos:
+        if "assigned_to" not in payload:
             
-            campos["assigned_to"] = self.username
+            payload["assigned_to"] = self.username
 
         try:
 
             url = f"{self.api_url}/now/table/{tabela}/{sys_id}"
-            response = self.put(url, payload=campos)
+            response = self.put(url, payload=payload, timeout=timeout)
             # response = requests.patch(url, auth=(self.username, self.password), headers=self.api_header, data=str(campos).encode('utf-8'), verify=True, timeout=timeout)
-
-            return response.json()
+            return {"success" : True, "result" : response.json() , "error" : None}
 
         except Exception as e:
-            
-            raise e
+            return {"success" : False, "result" : None, "error" : str(e) }
 
     def anexar_arquivo_no_ticket(self,header_content_type:dict=None, anexo_path:str=None, tabela:str=None, sys_id:str=None, timeout:int=15):
         """Anexa arquivo em um ticket do ServiceNow
@@ -269,18 +383,22 @@ class ServiceNow:
         Returns:
             dict: resposta do ServiceNow
         """
+        try:
+            AttachFileTicketValidator(header_content_type=header_content_type, anexo_path=anexo_path, tabela=tabela, sys_id=sys_id, timeout=timeout)
+        except ValidationError as e:
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+        
+        # # Validação de 'tabela'
+        # if not tabela or not tabela.strip():
+        #     raise ValueError("O parâmetro 'tabela' precisa ser especificado com o nome da tabela do ticket pra onde o arquivo será anexado.")
 
-        # Validação de 'tabela'
-        if not tabela or not tabela.strip():
-            raise ValueError("O parâmetro 'tabela' precisa ser especificado com o nome da tabela do ticket pra onde o arquivo será anexado.")
-
-        # Validação de 'sys_id'
-        if not sys_id or not sys_id.strip():
-            raise ValueError("O parâmetro 'sys_id' precisa ser especificado com o sys_id do ticket que o arquivo será anexado.")
+        # # Validação de 'sys_id'
+        # if not sys_id or not sys_id.strip():
+        #     raise ValueError("O parâmetro 'sys_id' precisa ser especificado com o sys_id do ticket que o arquivo será anexado.")
 
-        # Validação de 'anexo_path'
-        if not anexo_path or not anexo_path.strip():
-            raise ValueError("O parâmetro 'anexo_path' precisa ser especificado com o path para o arquivo a ser anexado.")
+        # # Validação de 'anexo_path'
+        # if not anexo_path or not anexo_path.strip():
+        #     raise ValueError("O parâmetro 'anexo_path' precisa ser especificado com o path para o arquivo a ser anexado.")
         
         if not os.path.exists(anexo_path):
             raise FileExistsError(f"O arquivo não foi encontrado ({anexo_path})")
@@ -304,15 +422,36 @@ class ServiceNow:
 
         try:
             url = f"{self.api_url}/now/attachment/file?table_name={tabela}&table_sys_id={sys_id}&file_name={nome_arquivo}"
-            response = self.post(url, file_data, header_content_type )
+            # response = self.post(url, file_data, header_content_type )
+            response = self.post(url=url, file_data=file_data, header_content_type=header_content_type_lower, timeout=timeout)
             # response = requests.post(f"{self.api_url}/now/attachment/file?table_name={tabela}&table_sys_id={sys_id}&file_name={nome_arquivo}", headers=header_content_type, auth=(self.username, self.password), data=file_data, timeout=timeout)
-            return response.json()
+            return {"success" : True, "result" : response.json(), "error" : None}
         
         except Exception as e:
-            
-            raise e
+            return {"success" : False, "result" : None, "error" : str(e)}
         
     def valida_header_content_type(self, anexo_path ):
+        """
+        Valida e define o cabeçalho `Content-Type` baseado na extensão do arquivo anexado.
+
+        Parâmetros:
+            anexo_path (str): Caminho do arquivo que será validado e utilizado para determinar o `Content-Type`.
+
+        Funcionalidade:
+            - Baseado na extensão do arquivo especificado, define um valor apropriado para `header_content_type` caso esteja ausente:
+                - `.zip` → `application/zip`
+                - `.xlsx` → `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`
+                - `.pdf` → `application/pdf`
+                - `.txt` → `text/plain`
+            - Gera um erro se `header_content_type` não for do tipo `dict` após a definição.
+
+        Erros:
+            - ValueError: Caso `header_content_type` não seja um dicionário válido após as validações.
+
+        Observação:
+            - O parâmetro `header_content_type` é uma variável local utilizada para compor os cabeçalhos HTTP, contendo informações do tipo de conteúdo do arquivo.
+            
+        """
 
         # Pré validando 'header_content_type'
         if os.path.splitext(anexo_path)[1].lower() == ".zip" and header_content_type is None:
@@ -331,13 +470,13 @@ class ServiceNow:
         
             header_content_type = {"Content-Type": "text/plain"}
 
-        # Validação de 'header_content_type'
-        if not isinstance(header_content_type, dict):
-            raise ValueError("O parâmetro 'header_content_type' precisa ser um dicionário contendo o 'Content-Type' do arquivo a ser anexado. (Ex: {\"Content-Type\": \"application/zip\"})")
+        # # Validação de 'header_content_type'
+        # if not isinstance(header_content_type, dict):
+        #     raise ValueError("O parâmetro 'header_content_type' precisa ser um dicionário contendo o 'Content-Type' do arquivo a ser anexado. (Ex: {\"Content-Type\": \"application/zip\"})")
         
-        # Validação de 'header_content_type'
-        if not isinstance(header_content_type, dict):
-            raise ValueError("O parâmetro 'header_content_type' precisa ser um dicionário contendo o 'Content-Type' do arquivo a ser anexado. (Ex: {\"Content-Type\": \"application/zip\"})")
+        # # Validação de 'header_content_type'
+        # if not isinstance(header_content_type, dict):
+        #     raise ValueError("O parâmetro 'header_content_type' precisa ser um dicionário contendo o 'Content-Type' do arquivo a ser anexado. (Ex: {\"Content-Type\": \"application/zip\"})")
         
         return header_content_type
 
@@ -353,27 +492,32 @@ class ServiceNow:
         Returns:
             dict: dicionário com os anexos do ticket
         """
-
-        # Validação de 'sys_id'
-        if not isinstance(sys_id, str) or not sys_id.strip():
-            raise ValueError("O parâmetro 'sys_id' precisa ser uma string não vazia com o sys_id do ticket.")
+        try:
+            GetAttachValidator(sys_id=sys_id,
+                               tabela=tabela,
+                               timeout=timeout,
+                               download_dir=download_dir,
+                               timeout=timeout )
+        except ValidationError as e:
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+        
+        # # Validação de 'sys_id'
+        # if not isinstance(sys_id, str) or not sys_id.strip():
+        #     raise ValueError("O parâmetro 'sys_id' precisa ser uma string não vazia com o sys_id do ticket.")
         
-        # Validação de 'tabela'
-        if not isinstance(tabela, str) or not tabela.strip():
-            raise ValueError("O parâmetro 'tabela' precisa ser uma string não vazia com o nome da tabela do ticket.")
+        # # Validação de 'tabela'
+        # if not isinstance(tabela, str) or not tabela.strip():
+        #     raise ValueError("O parâmetro 'tabela' precisa ser uma string não vazia com o nome da tabela do ticket.")
 
-        # Validação de 'timeout'
-        if not isinstance(timeout, int):
-            raise ValueError("O parâmetro 'timeout' precisa ser um valor (int) em segundos.")
+        # # Validação de 'timeout'
+        # if not isinstance(timeout, int):
+        #     raise ValueError("O parâmetro 'timeout' precisa ser um valor (int) em segundos.")
 
         # Validação de 'download_dir'
         if download_dir is not None:
             if not isinstance(download_dir, str) or not download_dir.strip():
-            
                 raise ValueError("O parâmetro 'download_dir' precisa ser a pasta pra onde o anexo será feito o download.")
-            
-            if not os.path.exists(download_dir):
-            
+            if not os.path.exists(download_dir):            
                 raise NotADirectoryError(f"A pasta informada '{download_dir}' não existe")
         
         # Validação de 'campo'
@@ -384,12 +528,13 @@ class ServiceNow:
 
         # Convert bytes to base64
         def __bytes_to_base64(image_bytes):
-            base64_encoded = base64.b64encode(image_bytes)
+            # base64_encoded = base64.b64encode(image_bytes)
 
-            # Decode the bytes to a string (UTF-8 encoding)
-            base64_string = base64_encoded.decode('utf-8')
+            # # Decode the bytes to a string (UTF-8 encoding)
+            # base64_string = base64_encoded.decode('utf-8')
 
-            return base64_string 
+            # # return base64_string 
+            return base64.b64encode(image_bytes).decode('utf-8')
         
         def __formatar_tamanho(tamanho_bytes):
             # Converte o valor de string para inteiro
@@ -408,122 +553,164 @@ class ServiceNow:
             return f"{tamanho_bytes:.2f} PB"  # Petabyte
 
         anexo_dict = {"var_servicenow": campo, "anexos":[]}
+        
+        try:
+            if campo == 'default':
+                url = f"{self.api_url}/now/attachment?sysparm_query=table_name={tabela}^table_sys_id={sys_id}"
+                response = self.request(url, timeout=timeout)
+
+                if response.status_code == 200:
+                    for attachment in response.json().get("result", []):
+                        arquivo = {
+                            "file_name": attachment["file_name"],
+                            "size": __formatar_tamanho(attachment["size_bytes"]),
+                            "content_type": attachment["content_type"],
+                            "base64": None
+                        }
+                        byte_response = self.request(attachment["download_link"], timeout=timeout)
+                        if byte_response.status_code == 200:
+                            arquivo["base64"] = __bytes_to_base64(byte_response.content)
+                            if download_dir:
+                                with open(os.path.join(download_dir, arquivo["file_name"]), 'wb') as f:
+                                    f.write(byte_response.content)
+                            anexo_dict["anexos"].append(arquivo)
+                    return {"success": True, "result": anexo_dict}
+                return {"success": False, "error": response.json(), "status_code": response.status_code}
 
-        # Fazendo download do anexo do campo padrao do ticket
-        if campo == 'default':
-            
-            print(f"verificando o campo '{campo}' de anexo")
+            else:
+                url = f"{self.api_url}/now/table/{tabela}?sysparm_query=sys_id={sys_id}&sysparm_fields={campo}&sysparm_display_value=all"
+                response = self.request(url, timeout=timeout)
+                if response.status_code == 200 and response.json().get("result"):
+                    campo_data = response.json()["result"][0].get(campo)
+                    if campo_data:
+                        attachment_id = campo_data["value"]
+                        attachment_url = f"{self.api_url}/now/attachment/{attachment_id}/file"
+                        byte_response = self.request(attachment_url, timeout=timeout)
+                        if byte_response.status_code == 200:
+                            arquivo = {
+                                "file_name": campo_data["display_value"],
+                                "size": __formatar_tamanho(byte_response.headers.get("Content-Length", 0)),
+                                "content_type": byte_response.headers.get("Content-Type"),
+                                "base64": __bytes_to_base64(byte_response.content)
+                            }
+                            if download_dir:
+                                with open(os.path.join(download_dir, arquivo["file_name"]), 'wb') as f:
+                                    f.write(byte_response.content)
+                            anexo_dict["anexos"].append(arquivo)
+                    return {"success": True, "result": anexo_dict, "error" : None}
+                return {"success": False, "error": response.json(), "status_code": response.status_code}
 
-            try:
-                #url = f"{SERVICENOW_API_URL}/now/attachment?sysparm_query=table_name=sc_req_item^table_sys_id={sys_id}"
-                url = f"{self.api_url}/now/attachment?sysparm_query=table_name={tabela}^table_sys_id={sys_id}"
-                response = self.request(url)
-                # response = requests.get(url, auth=(self.username, self.password), verify=True, timeout=timeout)
-                if response.status_code == 200 and len(response.json()["result"]) >= 1:
-
-                    for attachment in response.json()["result"]:
-
-                        print("attachment")
-                        print(attachment)
-                        arquivo = {}
-                        arquivo["file_name"] = attachment["file_name"]
-                        arquivo["size"] = __formatar_tamanho(attachment["size_bytes"]["display_value"])
-                        arquivo["content_type"] = attachment["content_type"]
-                        #arquivo["table_sys_id"] = attachment["table_sys_id"]
-
-                        try:
-                            byte_response = self.request(attachment["download_link"])
-                            # byte_response = requests.get(attachment["download_link"], auth=(self.username, self.password), verify=True, timeout=timeout)
+        except Exception as e:
+            logging.debug("Erro ao obter anexos.")
+            return {"success": False, "error": str(e)}
+        
+        # # Fazendo download do anexo do campo padrao do ticket
+        # if campo == 'default':
+            
+        #     logging.debug(f"verificando o campo '{campo}' de anexo")
+
+        #     try:
+        #         #url = f"{SERVICENOW_API_URL}/now/attachment?sysparm_query=table_name=sc_req_item^table_sys_id={sys_id}"
+        #         url = f"{self.api_url}/now/attachment?sysparm_query=table_name={tabela}^table_sys_id={sys_id}"
+        #         response = self.request(url)
+        #         # response = requests.get(url, auth=(self.username, self.password), verify=True, timeout=timeout)
+        #         if response.status_code == 200 and len(response.json()["result"]) >= 1:
+
+        #             for attachment in response.json()["result"]:
+
+        #                 # print("attachment")
+        #                 # print(attachment)
+        #                 arquivo = {}
+        #                 arquivo["file_name"] = attachment["file_name"]
+        #                 arquivo["size"] = __formatar_tamanho(attachment["size_bytes"]["display_value"])
+        #                 arquivo["content_type"] = attachment["content_type"]
+        #                 #arquivo["table_sys_id"] = attachment["table_sys_id"]
+
+        #                 try:
+        #                     byte_response = self.request(attachment["download_link"])
+        #                     # byte_response = requests.get(attachment["download_link"], auth=(self.username, self.password), verify=True, timeout=timeout)
                             
-                            if byte_response.status_code == 200:
+        #                     if byte_response.status_code == 200:
 
-                                arquivo["base64"] = __bytes_to_base64(byte_response.content)
+        #                         arquivo["base64"] = __bytes_to_base64(byte_response.content)
                                 
-                                if download_dir is not None:
-                                    with open(arquivo["file_name"],'wb') as download_file:
-                                        download_file.write(byte_response.content)
-
-                                #del arquivo["sys_id"]
-                                #del arquivo["download_link"]
-                                #del arquivo["table_sys_id"]
-                                anexo_dict["anexos"].append(arquivo)
-                                #return JSONResponse(content=arquivo, status_code=byte_response.status_code, media_type="application/json")
-                                # Requisicao não OK (!= 200)
+        #                         if download_dir is not None:
+        #                             with open(arquivo["file_name"],'wb') as download_file:
+        #                                 download_file.write(byte_response.content)
+
+        #                         #del arquivo["sys_id"]
+        #                         #del arquivo["download_link"]
+        #                         #del arquivo["table_sys_id"]
+        #                         anexo_dict["anexos"].append(arquivo)
+        #                         #return JSONResponse(content=arquivo, status_code=byte_response.status_code, media_type="application/json")
+        #                         # Requisicao não OK (!= 200)
+        #                         return {"success" : True, "result" : anexo_dict, "error": None, "status_code" : byte_response.status_code }
                         
-                        except Exception as e:
+        #                 except Exception as e:
+        #                     return {"success" : False, "result" : None, "error" : e, "status_code" : byte_response.status_code}
                         
-                            raise e
-                        
-                elif response.status_code != 200:
-                
-                    return response.json()
+        #         elif response.status_code != 200:
+        #             return {"success" : False , "result" : response.json(), "status_code" : response.status_code, "error" : None}
             
-            except Exception as e:
+        #     except Exception as e:
+        #         return {"success" : False, "result" : None, "error" : e}
         
-                raise e
+        # # Fazendo download do anexo do campo especificado do ticket
+        # else:
         
-        # Fazendo download do anexo do campo especificado do ticket
-        else:
-        
-            print(f"verificando o campo '{campo}' de anexo")
+        #     logging.debug(f"verificando o campo '{campo}' de anexo")
 
-            url = f"{self.api_url}/now/table/{tabela}?sysparm_query=sys_id={sys_id}&sysparm_fields={campo}&sysparm_display_value=all&sysparam_limit=1"
-            try:
-                response = requests.get(url, auth=(self.username, self.password), verify=True)
+        #     url = f"{self.api_url}/now/table/{tabela}?sysparm_query=sys_id={sys_id}&sysparm_fields={campo}&sysparm_display_value=all&sysparam_limit=1"
+        #     try:
+        #         response = self.request(url)
+        #         # response = requests.get(url, auth=(self.username, self.password), verify=True)
 
-                # Requisicao OK e com anexo
-                if response.status_code == 200 and len(response.json()["result"]) >= 1:
+        #         # Requisicao OK e com anexo
+        #         if response.status_code == 200 and len(response.json()["result"]) >= 1:
 
-                    for ticket_data in response.json()["result"]:
+        #             for ticket_data in response.json()["result"]:
 
-                        if len(ticket_data) >= 1:
+        #                 if len(ticket_data) >= 1:
                             
-                            try:
-
-                                #temp_file_name = ticket_data[campo]["display_value"]
-                                temp_sys_id = ticket_data[campo]["value"]
-
-                            except Exception as e:
-                                
-                                raise e
+        #                     try:
 
-                            url = f"{self.api_url}/now/table/sys_attachment?sysparm_query=sys_id={temp_sys_id}&sysparm_display_value=all&sysparam_limit=1"
+        #                         #temp_file_name = ticket_data[campo]["display_value"]
+        #                         temp_sys_id = ticket_data[campo]["value"]
+        #                         url = f"{self.api_url}/now/table/sys_attachment?sysparm_query=sys_id={temp_sys_id}&sysparm_display_value=all&sysparam_limit=1"
+        #                         response = self.request(url=url)
 
-                            response = requests.get(url, auth=(self.username, self.password), verify=True)
+        #                     except Exception as e:
+        #                         return {"success" : False, "error" : e, "result" : None}
                             
-                            if response.status_code == 200:
-
-                                attachment = response.json()["result"][0]
-                                arquivo = {}
-                                arquivo["file_name"] = attachment["file_name"]["display_value"]
-                                arquivo["size"] = __formatar_tamanho(attachment["size_bytes"]["display_value"])
-                                #arquivo["sys_id"] = attachment["sys_id"]
-                                arquivo["content_type"] = attachment["content_type"]["value"]
-                                #attach_sys_id = attachment["sys_id"]["display_value"]
-                                #attach_sys_id_table = attachment["table_sys_id"]["value"]
-                                #url = f"{self.api_url}/now/attachment/{sys_id}/file"
-                                try:
-
-                                    url = f"{self.api_url}/now/attachment/{temp_sys_id}/file"
-                                    byte_response = requests.get(url, auth=(self.username, self.password), verify=True)
-                                    arquivo["base64"] = __bytes_to_base64(byte_response.content)
-                                    anexo_dict["anexos"].append(arquivo)
-                                    if download_dir is not None:
-        
-                                        with open(arquivo["file_name"],'wb') as download_file:
-                                            download_file.write(byte_response.content)
-
-                                except Exception as e:
-
-                                    raise e
-                
-                # Requisicao não OK (!= 200)
-                elif response.status_code != 200:
-                
-                    return response.json()
+        #                     if response.status_code == 200:
+
+        #                         attachment = response.json()["result"][0]
+        #                         arquivo = {}
+        #                         arquivo["file_name"] = attachment["file_name"]["display_value"]
+        #                         arquivo["size"] = __formatar_tamanho(attachment["size_bytes"]["display_value"])
+        #                         #arquivo["sys_id"] = attachment["sys_id"]
+        #                         arquivo["content_type"] = attachment["content_type"]["value"]
+        #                         #attach_sys_id = attachment["sys_id"]["display_value"]
+        #                         #attach_sys_id_table = attachment["table_sys_id"]["value"]
+        #                         #url = f"{self.api_url}/now/attachment/{sys_id}/file"
+        #                         try:
+
+        #                             url = f"{self.api_url}/now/attachment/{temp_sys_id}/file"
+        #                             byte_response = self.request(url)
+        #                             # byte_response = requests.get(url, auth=(self.username, self.password), verify=True)
+        #                             arquivo["base64"] = __bytes_to_base64(byte_response.content)
+        #                             anexo_dict["anexos"].append(arquivo)
+        #                             if download_dir is not None:
+        
+        #                                 with open(arquivo["file_name"],'wb') as download_file:
+        #                                     download_file.write(byte_response.content)
+        #                             return {"success" : True, "status_code" : response.status_code, "error" : None, "result" : anexo_dict}
+        #                         except Exception as e:
+        #                             return {"success" : False, "status_code" : response.status_code, "error" : e, "result" : response.json()}
                 
-            except Exception as e:
+        #         # Requisicao não OK (!= 200)
+        #         elif response.status_code != 200:
+        #             return {"success" : False, "status_code" : response.status_code, "error" : e, "result" : response.json()}
                 
-                raise e
-        
-        return anexo_dict
+        #     except Exception as e:
+        #         return {"success" : False, "error" : e, "result" : None}