csc-cia-stne 0.0.37__py3-none-any.whl → 0.0.39__py3-none-any.whl

csc_cia_stne/servicenow.py

@@ -3,7 +3,7 @@ import base64, json
 import os
 import logging
 from pydantic import  ValidationError
-from .utilitarios.validations.ServiceNowValidator import InitParamsValidator, RequestValidator, PutValidator, PostValidator, ListTicketValidator, UpdateTicketValidator, AttachFileTicketValidator, GetAttachValidator
+from .utilitarios.validations.ServiceNowValidator import *
 
 class ServiceNow:
     
@@ -27,14 +27,10 @@ class ServiceNow:
             api_header (dict): Cabeçalhos padrão para requisições API.
         """
         try:
-            InitParamsValidator(username=username, password=password, env=env, )
+            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)")
-
+        
         # Normaliza o valor de 'env' para maiúsculas
         env = env.strip().upper()
 
@@ -51,22 +47,21 @@ class ServiceNow:
             raise ValueError("O valor de 'env' precisa ser 'dev', 'qa', 'qas' ou 'prod'.")
 
         # Atribui as variáveis de instância
-        self.username = username.strip()
-        self.password = password.strip()
+        self.__username = username.strip()
+        self.__password = password.strip()
         self.env = env
         self.api_url = valid_envs[env]
         self.api_header = {"Content-Type":"application/json","Accept":"application/json"}
         
-    # Criação de funções básicas para reutilizar nas funções especificas
 
     def __auth(self):
         """
             Retorna o e-mail e senha para realizar a autenticação.
         """
-        return (self.username, self.password)
+        return (self.__username, self.__password)
     
 
-    def request (self, url : str , params : str = "", timout : int = 15):
+    def request (self, url : str , params : str = "", timeout : int = 15):
         """
         Realiza uma requisição GET para a URL especificada.
 
@@ -96,7 +91,7 @@ class ServiceNow:
             - Verifica o certificado SSL (`verify=True`).
         """
         try:
-            RequestValidator(url=url, params=params, timeout=timout)
+            RequestValidator(url=url, params=params, timeout=timeout)
         except ValidationError as e:
             raise ValueError("Erro na validação dos dados de input do método:", e.errors())
         
@@ -106,7 +101,7 @@ class ServiceNow:
                 params=params,
                 auth=self.__auth(),
                 headers=self.api_header,
-                timeout=timout,
+                timeout=timeout,
                 verify=True
             )
 
@@ -116,7 +111,7 @@ class ServiceNow:
              # Analisa o conteúdo da resposta JSON
             result = response.json()
             if "result" in result:
-                return {"success" : True, "result" : result}
+                return {"success" : True, "result" : result.get("result")}
             else:
                 logging.debug("A resposta não contém o campo 'result'.")
                 return {"success" : False, "result" : result}
@@ -134,6 +129,67 @@ class ServiceNow:
             return {"success" : False, "result" : None, "error" : str(e)}
 
 
+    def __request_download(self, url, params = "", timeout = 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:
+            response = requests.get(
+                url, 
+                params=params,
+                auth=self.__auth(),
+                headers=self.api_header,
+                timeout=timeout,
+                verify=True
+            )
+
+            # VALIDA SE HOUVE SUCESSO NA REQUISIÇÃO
+            response.raise_for_status()
+             # Analisa o conteúdo da resposta JSON
+            if response.status_code == 200:
+                return  {"success" : True, "result" : response}
+            else:
+                logging.debug("Erro ao realizar a consulta")
+                return {"success" : False, "result" : response.status_code}
+
+        except requests.exceptions.HTTPError as http_err:
+            logging.debug(f"Erro HTTP ao buscar os detalhes do ticket: {http_err}")
+            return {"success" : False, "error" : str(http_err), "result" : None}
+        
+        except requests.exceptions.RequestException as req_err:
+            logging.debug(f"Erro ao buscar os detalhes do ticket: {req_err}")
+            return {"success" : False, "error" : str(req_err), "result" : None}
+        
+        except Exception as e:
+            logging.debug(f"Erro inesperado: {e}")
+            return {"success" : False, "error" : str(e), "result" : None}
+
+
     def put(self, url, payload, timeout = 15):
         """
         Realiza uma requisição PUT para a URL especificada.
@@ -272,7 +328,7 @@ class ServiceNow:
             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:
+    def listar_tickets(self, tabela: str = None, campos: list = None, query: str = None, limite: int = 50, timeout:int=15, sysparm_display_value: str = "")->dict:
         """lista tickets do ServiceNow
 
         Args:
@@ -290,46 +346,23 @@ class ServiceNow:
         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_display_value" : sysparm_display_value,
             "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=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 {"success":True, "result": response.json()}
+            response = self.request(url=url, params=params, timeout=timeout)
+            return response
         
         except Exception as e:
-            return {"success" : False, "result" : None, "error" : str(e)}
+            logging.debug(f"erro: {e}")
+            return str(e)
 
 
     def update_ticket(self, tabela: str = None, sys_id: str = None, payload: dict = None, timeout:int=15)->dict:
@@ -348,32 +381,17 @@ class ServiceNow:
             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 '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 '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 payload:
-            
-            payload["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=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 {"success" : True, "result" : response.json() , "error" : None}
+            return response
 
         except Exception as e:
-            return {"success" : False, "result" : None, "error" : str(e) }
+            return 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):
@@ -389,55 +407,40 @@ class ServiceNow:
         Returns:
             dict: resposta do ServiceNow
         """
+        if header_content_type is None:
+            header_content_type = self.__valida_header_content_type(anexo_path, header_content_type)
+        
         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 '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.")
-        
         if not os.path.exists(anexo_path):
             raise FileExistsError(f"O arquivo não foi encontrado ({anexo_path})")
 
-        header_content_type = self.valida_header_content_type(anexo_path)
+        
 
         # Converte as chaves do dicionário para minúsculas
         header_content_type_lower = {k.lower(): v for k, v in header_content_type.items()}
 
         
-        
         if "content-type" not in header_content_type_lower:
-            
             raise ValueError("O parâmetro 'header_content_type' não possui a chave 'Content-Type' com o tipo do anexo")
 
         nome_arquivo = os.path.basename(anexo_path)
-
-        with open(anexo_path, 'rb') as f:
-
-            file_data = f
-
         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=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 {"success" : True, "result" : response.json(), "error" : None}
+            with open(anexo_path, 'rb') as f:
+                url = f"{self.api_url}/now/attachment/file?table_name={tabela}&table_sys_id={sys_id}&file_name={nome_arquivo}"
+                response = requests.post(url, headers=header_content_type, auth=(self.__username, self.__password), data=f, timeout=timeout)
+            
+            logging.debug("Arquivo adicionado no ticket")
+            return {"success": True, "result" : response}
         
         except Exception as e:
             return {"success" : False, "result" : None, "error" : str(e)}
         
 
-    def valida_header_content_type(self, anexo_path ):
+    def __valida_header_content_type(self, anexo_path, header_content_type):
         """
         Valida e define o cabeçalho `Content-Type` baseado na extensão do arquivo anexado.
 
@@ -477,17 +480,106 @@ 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\"})")
         
+       
         return header_content_type
 
 
+    def download_anexo(self, sys_id_file : str, file_path : str, timeout : int = 15):
+        """
+        Faz o download de um anexo do ServiceNow utilizando o `sys_id` do arquivo e salva no caminho especificado.
+
+        Parâmetros:
+            sys_id_file (str): O identificador único (sys_id) do arquivo no ServiceNow.
+            file_path (str): O caminho completo onde o arquivo será salvo localmente.
+            timeout (int, opcional): O tempo limite, em segundos, para a requisição HTTP. Padrão é 15 segundos.
+
+        Retorna:
+            bool: Retorna `True` se o arquivo foi salvo com sucesso no caminho especificado.
+            dict: Em caso de erro, retorna um dicionário com os seguintes campos:
+                - "success" (bool): Indica se a operação foi bem-sucedida (`False` em caso de falha).
+                - "error" (str): Mensagem de erro detalhada em caso de falha.
+                - "path" (str, opcional): O caminho do arquivo salvo, caso tenha sido criado após a criação de diretórios.
+
+        Comportamento:
+            - Em caso de sucesso na requisição HTTP (status code 200), o arquivo é salvo no `file_path`.
+            - Caso o caminho do arquivo não exista, tenta criá-lo automaticamente.
+            - Registra logs de erros ou informações em caso de falha.
+
+        Exceções Tratadas:
+            - FileNotFoundError: Se o caminho especificado não existir, tenta criar os diretórios necessários.
+            - Exception: Registra quaisquer outros erros inesperados durante o salvamento.
+
+        Logs:
+            - `logging.debug`: Para erros de salvamento no arquivo.
+            - `logging.error`: Para erros genéricos durante o processo.
+            - `logging.info`: Para informações sobre falhas na requisição HTTP.
+
+        Exemplo:
+            obj.download_anexo("abc123sysid", "/caminho/para/salvar/arquivo.txt")
+            {'success': False, 'error': 'Status code: 404'}
+        """
+        try:
+            DownloadFileValidator(sys_id_file=sys_id_file, file_path=file_path)
+        except ValidationError as e:
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+        
+        url = f"{self.api_url}/now/attachment/{sys_id_file}/file"
+        response = self.__request_download(url=url, timeout=timeout)
+        response = response.get("result")
+        if response.status_code == 200:
+            try:
+                if not os.path.exists(file_path):
+                    diretorio = os.path.dirname(file_path)
+                    print(diretorio)
+                    os.makedirs(diretorio, exist_ok=True)
+                    logging.debug(f"Diretorio criado: {diretorio}")
+                with open(file_path, 'wb') as f:
+                    f.write(response.content)
+                return {"success" : True, "path" : file_path }
+            
+            except FileNotFoundError:
+                try:
+                    path = os.path.dirname(file_path)
+                    os.makedirs(path)
+                    with open(file_path, 'wb') as f:
+                        f.write(response.content)
+                    return {"success" : True, "path" : file_path }
+                except Exception as e:
+                    logging.debug(f"Erro ao salvar o arquivo. Erro: {e}")
+                return {"success" : False, "error" : str(e) }
+            except Exception as e:
+                logging.error(f"Erro ao salvar o arquivo. Erro: {e}")
+                return {"success" : False, "error" : str(e) }
+        else:
+            logging.debug(f"{response.status_code}")
+            return {"success" : False, "error" : f"Status code: {response.status_code }"}
+
+    def get_variables_from_ticket(self, sys_id : str, campos : str = ''):
+        """
+        Obtém as variáveis associadas ao ticket.
+        args:
+            sys_id : STR - Id do ticket
+        """
+        if isinstance(campos, list):
+            campos = ','.join(campos)
+        if campos == "":
+            campos = 'name,question_text,type,default_value, sys_id'
+
+        logging.debug(f"Obtendo variáveis do ticket {sys_id}")
+        url = f"{self.api_url}/now/table/item_option_new"
+        params = {
+            'sysparm_query': f'cat_item={sys_id}',
+            'sysparm_display_value': 'true',
+            'sysparm_fields': campos,
+        }
+        response = self.request(url, params=params)
+        return response
+    
+
     def get_anexo(self, sys_id: str = None, tabela: str = None, campo: str = 'default', download_dir:str=None, timeout:int=15)->dict:
         """Traz os anexos de um campo do ticket especificado
 
@@ -508,19 +600,6 @@ class ServiceNow:
         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 '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.")
@@ -535,12 +614,7 @@ class ServiceNow:
 
         # Convert bytes to base64
         def __bytes_to_base64(image_bytes):
-            # base64_encoded = base64.b64encode(image_bytes)
-
-            # # Decode the bytes to a string (UTF-8 encoding)
-            # base64_string = base64_encoded.decode('utf-8')
 
-            # # return base64_string 
             return base64.b64encode(image_bytes).decode('utf-8')
         
         def __formatar_tamanho(tamanho_bytes):
@@ -564,8 +638,8 @@ class ServiceNow:
         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)
-
+                response = self.__request_download(url, timeout=timeout)
+                response = response.get("result")
                 if response.status_code == 200:
                     for attachment in response.json().get("result", []):
                         arquivo = {
@@ -574,7 +648,8 @@ class ServiceNow:
                             "content_type": attachment["content_type"],
                             "base64": None
                         }
-                        byte_response = self.request(attachment["download_link"], timeout=timeout)
+                        byte_response = self.__request_download(attachment["download_link"], timeout=timeout)
+                        byte_response = byte_response.get("result")
                         if byte_response.status_code == 200:
                             arquivo["base64"] = __bytes_to_base64(byte_response.content)
                             if download_dir:
@@ -586,13 +661,15 @@ class ServiceNow:
 
             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)
+                response = self.__request_download(url, timeout=timeout)
+                response = response.get("result")
                 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)
+                        byte_response = self.__request_download(attachment["download_link"], timeout=timeout)
+                        byte_response = byte_response.get("result")
                         if byte_response.status_code == 200:
                             arquivo = {
                                 "file_name": campo_data["display_value"],
@@ -609,115 +686,4 @@ class ServiceNow:
 
         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:
-
-        #                         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)
-        #                         return {"success" : True, "result" : anexo_dict, "error": None, "status_code" : byte_response.status_code }
-                        
-        #                 except Exception as e:
-        #                     return {"success" : False, "result" : None, "error" : e, "status_code" : byte_response.status_code}
-                        
-        #         elif response.status_code != 200:
-        #             return {"success" : False , "result" : response.json(), "status_code" : response.status_code, "error" : None}
-            
-        #     except Exception as e:
-        #         return {"success" : False, "result" : None, "error" : e}
-        
-        # # Fazendo download do anexo do campo especificado do ticket
-        # else:
-        
-        #     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 = 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:
-
-        #             for ticket_data in response.json()["result"]:
-
-        #                 if len(ticket_data) >= 1:
-                            
-        #                     try:
-
-        #                         #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)
-
-        #                     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 = 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()}
-                
-        #         # Requisicao não OK (!= 200)
-        #         elif response.status_code != 200:
-        #             return {"success" : False, "status_code" : response.status_code, "error" : e, "result" : response.json()}
-                
-        #     except Exception as e:
-        #         return {"success" : False, "error" : e, "result" : None}
+            return {"success": False, "error": str(e)}