csc-cia-stne 0.0.95__tar.gz → 0.0.97__tar.gz

{csc_cia_stne-0.0.95 → csc_cia_stne-0.0.97}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csc_cia_stne
-Version: 0.0.95
+Version: 0.0.97
 Summary: Biblioteca do time CSC-CIA utilizada no desenvolvimento de RPAs
 License: MIT
 Keywords: karavela,csc,cia,stone,rpa,botcity,stne
@@ -30,7 +30,7 @@ Requires-Dist: email-validator
 Requires-Dist: botcity-maestro-sdk
 Requires-Dist: psutil
 Requires-Dist: cryptography
-Requires-Dist: pyautogui
+Requires-Dist: pycurl
 Dynamic: license-file
 
 Essa biblioteca é desenvolvida e atualizada pelo time **CSC-CIA** da **Stone**

{csc_cia_stne-0.0.95 → csc_cia_stne-0.0.97}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "csc_cia_stne"
-version = "0.0.95"
+version = "0.0.97"
 license = { text = "MIT" }
 description = "Biblioteca do time CSC-CIA utilizada no desenvolvimento de RPAs"
 keywords = ["karavela", "csc", "cia", "stone", "rpa", "botcity", "stne"]
@@ -36,5 +36,5 @@ dependencies = [
     "botcity-maestro-sdk",
     "psutil",
     "cryptography",
-    "pyautogui"
+    "pycurl"
 ]

{csc_cia_stne-0.0.95 → csc_cia_stne-0.0.97}/src/csc_cia_stne/__init__.py

@@ -15,6 +15,7 @@ from .slack import Slack
 from .web import web_screen
 from .wacess import Waccess
 from .gcp_bucket import GCPBucket
+from .ftp import FTP
 
 # Define os itens disponíveis para importação
 __all__ = [
@@ -32,7 +33,8 @@ __all__ = [
     "Slack",
     "web_screen",
     "Waccess",
-    "GCPBucket"
+    "GCPBucket",
+    "FTP"
 ]
 
 _diretorio_inicial = os.getcwd()

csc_cia_stne-0.0.97/src/csc_cia_stne/ftp.py

@@ -0,0 +1,306 @@
+import pycurl
+import socket
+import time
+import os
+from io import BytesIO
+
+from .utilitarios.validations.ftp import InitParamsValidator,UploadDownloadValidator,ListFilesValidator
+
+class FTP():
+
+    def __init__(self, host:str , user:str , password:str , timeout:int=30, port:bool=21, tls:bool=True, ssl:bool=True, verify_ssl:bool=False, verify_host:bool=False, tryouts:int=3):
+
+        self.host = host
+        self.user = user
+        self.password = password
+        self.port = port
+        self.timeout = timeout
+        self.tls = tls
+        self.ssl = ssl
+        self.verify_ssl = verify_ssl
+        self.verify_host = verify_host
+        self.tryouts = tryouts
+
+        try:
+
+            InitParamsValidator(
+                host=self.host,
+                user=self.user,
+                password=self.password,
+                port=self.port,
+                timeout=self.timeout,
+                tls=self.tls,
+                ssl=self.ssl,
+                verify_ssl=self.verify_ssl,
+                verify_host=self.verify_host,
+                tryouts=self.tryouts
+            )
+
+        except Exception as e:
+            
+            raise ValueError(f"Erro na validação dos parâmetros de inicialização: {str(e)}")
+
+
+        self._test_connection()
+
+    def _test_connection(self):
+        """
+        Testa a conexão com o servidor FTP utilizando o host e a porta especificados.
+        Este método tenta estabelecer uma conexão de socket com o servidor FTP
+        usando os parâmetros `host` e `port`. Caso a conexão seja bem-sucedida,
+        retorna `True`. Caso contrário, levanta uma exceção `ConnectionError` com
+        uma mensagem apropriada.
+        Raises:
+            ConnectionError: Se ocorrer um timeout ou se a conexão for recusada.
+            ConnectionError: Se ocorrer um erro desconhecido durante a tentativa de conexão.
+        Returns:
+            bool: `True` se a conexão for bem-sucedida.
+        """
+
+        try:
+
+            with socket.create_connection((self.host, self.port), timeout=self.timeout) as sock:
+
+                sock.close()
+
+                return True
+
+        except (socket.timeout, ConnectionRefusedError) as e:
+
+            raise ConnectionError(f"Erro de timeout ou conexão negada {self.host}:{self.port}. Error: {str(e)}")
+        
+        except Exception as e:
+
+            raise ConnectionError(f"Erro desconhecido ao tentar conexão com {self.host}:{self.port}. Error: {str(e)}")
+        
+    def _login_server(self):
+        """
+        Estabelece uma conexão com o servidor FTP utilizando as credenciais fornecidas e configurações de segurança.
+        Configurações:
+        - `self.user` e `self.password`: Credenciais de autenticação para o servidor FTP.
+        - `self.tls`: Se True, força o uso de TLS para a conexão.
+        - `self.ssl`: Se True, ativa FTPS explícito.
+        - `self.verify_ssl`: Se False, desativa a verificação de certificado SSL.
+        - `self.verify_host`: Se False, desativa a verificação do host SSL.
+        Retorna:
+            pycurl.Curl: Objeto de conexão configurado para o servidor FTP.
+        Exceções:
+            ConnectionError: Lançada quando ocorre um erro ao tentar estabelecer a conexão com o servidor FTP.
+        """
+
+        try:
+
+            connection_ftp = pycurl.Curl()
+
+            connection_ftp.setopt(connection_ftp.USERPWD, f"{self.user}:{self.password}")
+
+            connection_ftp.setopt(connection_ftp.CONNECTTIMEOUT, self.timeout)  # Tempo limite para conexão
+                    
+            connection_ftp.setopt(connection_ftp.TIMEOUT, self.timeout*2)  # Tempo limite para operação
+
+            if self.tls is True:
+
+                connection_ftp.setopt(connection_ftp.USE_SSL, connection_ftp.USESSL_ALL)  # Força uso de TLS
+            
+            if self.ssl is True:
+        
+                connection_ftp.setopt(connection_ftp.FTP_SSL, connection_ftp.FTPSSL_ALL)  # Ativa FTPS explícito
+
+            if self.verify_ssl is False:
+                
+                connection_ftp.setopt(connection_ftp.SSL_VERIFYPEER, 0)  # Desativar verificação SSL (ajuste conforme necessário)
+            
+            if self.verify_host is False:
+
+                connection_ftp.setopt(connection_ftp.SSL_VERIFYHOST, 0)  # Desativar verificação de host SSL
+
+            return connection_ftp
+        
+        except Exception as e:
+        
+            self._test_connection()
+
+            raise ConnectionError(f"Erro ao tentar conexão com o servidor FTP {self.host}:{self.port}. Error: {str(e)}")
+    
+    def upload_or_download_file(self, filename:str, filepathftp:str, method:str="UPLOAD"):
+        """
+        Faz upload ou download de um arquivo para/da um servidor FTP.
+        Args:
+            filename (str): Nome do arquivo local a ser enviado ou recebido.
+            filepathftp (str): Caminho remoto no servidor FTP onde o arquivo será enviado ou recebido.
+            method (str, opcional): Método de operação, "UPLOAD" para enviar arquivo ou "DOWNLOAD" para baixar arquivo. 
+                                    O padrão é "UPLOAD".
+        Returns:
+            dict: Um dicionário contendo:
+                - 'status' (bool): Indica se a operação foi bem-sucedida.
+                - 'status_code' (int): Código de resposta do servidor FTP.
+                - 'message' (str): Mensagem indicando o resultado da operação.
+        Raises:
+            FileNotFoundError: Se o arquivo especificado não for encontrado.
+            PermissionError: Se houver problemas de permissão ao acessar o arquivo.
+            Exception: Para outros erros durante a operação.
+        Nota:
+            O método tenta realizar a operação várias vezes, conforme definido em `self.tryouts`.
+            Em caso de falha, retorna um status indicando o erro.
+        """
+        
+        try:
+
+            UploadDownloadValidator(
+                filename=filename,
+                filepathftp=filepathftp,
+                method=method.upper()
+            )
+
+        except Exception as e:
+
+            raise ValueError(f"Erro na validação dos parâmetros de upload/download: {str(e)}")
+
+        filename = os.path.join(os.getcwd(), filename)
+
+        connection_ftp = self._login_server()
+
+        remote_path = f"{filepathftp}{filename}"
+
+        ftp_url = f"ftp://{self.host}{remote_path}"
+
+        status_upload = True
+
+        methodfile = "rb"
+
+        if method.upper() == "DOWNLOAD":
+
+            methodfile = "wb"
+
+        for try_out in range(self.tryouts):
+
+            time.sleep(5)
+
+            try:
+
+                with open(filename, methodfile) as file:
+
+                    connection_ftp.setopt(connection_ftp.URL, ftp_url)
+
+                    connection_ftp.setopt(connection_ftp.UPLOAD, 1)
+
+                    if method.upper() == "UPLOAD":
+                    
+                        connection_ftp.setopt(connection_ftp.READDATA, file)
+                    
+                    elif method.upper() == "DOWNLOAD":
+                      
+                        connection_ftp.setopt(connection_ftp.WRITEDATA, file)
+
+                    connection_ftp.perform()
+
+                    status_code = connection_ftp.getinfo(connection_ftp.RESPONSE_CODE)
+
+                    break
+                
+            except FileNotFoundError as e:
+
+                raise FileNotFoundError(f"Arquivo '{filename}' não encontrado. Error: {str(e)}")
+            
+            except PermissionError as e:
+
+                raise PermissionError(f"Permissão negada para acessar o arquivo '{filename}'. Error: {str(e)}")
+
+            except Exception as e:
+
+                status_code = None
+                
+                status_upload = False
+
+        if status_code == 226:
+
+            status_upload = True
+
+        else:
+
+            status_upload = False
+        
+        connection_ftp.close()
+
+        return {
+            'status': status_upload,
+            'status_code': status_code
+        }
+    
+    def list_files(self, filepathftp:str):
+        """
+        Lista arquivos em um diretório FTP especificado.
+        Este método conecta-se a um servidor FTP, lista os arquivos disponíveis no diretório especificado
+        e retorna os nomes dos arquivos juntamente com metadados, se disponíveis.
+        Args:
+            filepathftp (str): Caminho do diretório no servidor FTP onde os arquivos serão listados.
+        Returns:
+            dict: Um dicionário contendo:
+                - 'status' (bool): Indica se a operação foi bem-sucedida.
+                - 'status_code' (int ou None): Código de resposta do servidor FTP.
+                - 'message' (str): Mensagem detalhando o resultado da operação.
+                - 'files' (list): Lista de arquivos encontrados no diretório FTP.
+        Raises:
+            ConnectionError: Caso ocorra algum erro ao criar o buffer de memória ou ao definir a URL do FTP.
+        """
+
+        try:
+
+            ListFilesValidator(filepathftp=filepathftp)
+
+        except Exception as e:
+
+            raise ValueError(f"Erro na validação dos parâmetros de listagem de arquivos: {str(e)}")
+
+        try:
+
+            buffer = BytesIO()
+
+        except Exception as e:
+
+            raise ConnectionError(f"Erro ao criar buffer de memória. Error: {str(e)}")
+        
+        connection_ftp = self._login_server()
+
+        ftp_url = f"ftp://{self.host}{filepathftp}"
+
+        for try_out in range(self.tryouts):
+
+            try:
+
+                connection_ftp.setopt(connection_ftp.URL, ftp_url)
+
+                connection_ftp.setopt(connection_ftp.WRITEDATA, buffer)
+
+                connection_ftp.setopt(connection_ftp.VERBOSE, False)
+
+                connection_ftp.setopt(connection_ftp.NOBODY, False)
+
+                connection_ftp.setopt(connection_ftp.DIRLISTONLY, False)  # True = apenas nomes; False = nomes + metadados estilo ls -l
+    
+                connection_ftp.perform()
+
+                conteudo = buffer.getvalue().decode('utf-8')
+
+                lista_arquivos = [linha.strip() for linha in conteudo.splitlines() if linha.strip()]
+
+                connection_ftp.close()
+
+                return {
+                    'status': True,
+                    'status_code': connection_ftp.getinfo(connection_ftp.RESPONSE_CODE),
+                    'message': f"Arquivos listados com sucesso de {self.host}:{self.port}/{filepathftp}.",
+                    'files': lista_arquivos
+                }
+
+            except Exception as e:
+
+                raise ConnectionError(f"Erro ao definir URL do FTP. Error: {str(e)}")
+
+        connection_ftp.close()
+
+        return {
+            'status': False,
+            'status_code': None,
+            'message': f"Falha ao listar arquivos de {self.host}:{self.port}/{filepathftp}."
+        }

{csc_cia_stne-0.0.95 → csc_cia_stne-0.0.97}/src/csc_cia_stne/utilitarios/functions/__init__.py

@@ -4,8 +4,9 @@ from .func_b64 import b64decode, b64encode
 from .func_converters import convert_bquery_result_to_json
 from .func_settings import get_config
 from .func_get_secret import get_secret
-from .func_rdp import obter_ip_conexao_rdp, conectar_rdp
+# from .func_rdp import obter_ip_conexao_rdp, conectar_rdp
 from .func_datetime import now_sp
+
 __all__ = [
     "titulo", 
     "recriar_pasta", 
@@ -14,7 +15,7 @@ __all__ = [
     "convert_bquery_result_to_json",
     "get_config",
     "get_secret",
-    "obter_ip_conexao_rdp",
+    # "obter_ip_conexao_rdp",
     "now_sp",
-    "conectar_rdp"
+    # "conectar_rdp"
     ]

csc_cia_stne-0.0.97/src/csc_cia_stne/utilitarios/functions/func_rdp.py

@@ -0,0 +1,147 @@
+# import platform
+# import subprocess
+# import time
+# import pyautogui
+# import psutil
+# import pygetwindow as gw
+# import logging
+# pyautogui.USE_MOUSEINFO = False
+# log = logging.getLogger('__main__')
+
+# def obter_ip_conexao_rdp():
+#     """Retorna o ip da conexão RDP
+
+#     Returns:
+#         str: ip
+#     """
+    
+#     for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
+    
+#         if proc.info['name'] == 'mstsc.exe' and proc.info['cmdline']:
+    
+#             for arg in proc.info['cmdline']:
+    
+#                 if arg.startswith("/v:"):  # O argumento '/v:' contém o IP
+    
+#                     return arg.replace("/v:", "").strip()
+    
+#     return None
+
+# def verificar_sessao_rdp()->bool:
+#     """Verifica se a sessão RDP está ativa"""
+#     # Verifica se o processo mstsc.exe está rodando
+#     for proc in psutil.process_iter(['name']):
+#         if proc.info['name'] == 'mstsc.exe':
+#             #return True
+    
+#             # Verifica se a janela da Área de Trabalho Remota está aberta
+#             for window in gw.getAllTitles():
+#                 if "Área de Trabalho Remota" in window or "Remote Desktop" in window:
+#                     return True
+    
+#     return False
+
+# def conectar_rdp(host:str, usuario:str, senha:str)->bool:
+#     """Conecta via RDP em uma máquina remota
+    
+#     Args:
+    
+#             host (str): ip/host destino
+#         usuario (str): usuário
+#         senha (str): senha
+    
+#     Returns:
+#         bool: True/False
+#     """
+    
+#     sistema = platform.system()
+
+#     if sistema == "Windows":
+
+#         try:
+            
+#             def criar_arquivo_rdp(host, usuario, caminho_rdp="conexao.rdp")->str:
+#                 """Cria um arquivo .rdp para conexão RDP
+#                 Args:
+#                     host (str): host do computador remoto
+#                     usuario (str): Usuário
+#                     caminho_rdp (str): Caminho do arquivo .rdp
+#                 Returns:
+#                     str: Caminho do arquivo .rdp
+#                 """
+#                 conteudo_rdp = f"""
+#                 screen mode id:i:2
+#                 desktopwidth:i:1920
+#                 desktopheight:i:1080
+#                 session bpp:i:32
+#                 winposstr:s:0,1,0,0,800,600
+#                 full address:s:{host}
+#                 username:s:{usuario}
+#                 """
+#                 with open(caminho_rdp, "w") as arquivo:
+#                     arquivo.write(conteudo_rdp.strip())
+                
+#                 return caminho_rdp
+
+#             caminho_rdp = criar_arquivo_rdp(host, usuario)
+#             subprocess.run(f"start mstsc {caminho_rdp}", shell=True)
+#             # Espera a conexão ser feita e confirma que realmente quer fazer a conexão com o computador remoto de forma insegura (certificado)
+#             time.sleep(10)
+#             pyautogui.press('left')
+#             pyautogui.press('enter')
+#             # Espera 3 segundos para digitar a senha e dar enter
+#             time.sleep(3)
+#             pyautogui.write(senha)
+#             pyautogui.press('enter')
+#             # Espera 5 segundos para aparecer a tela sobre o certificado e aceitar a conexão de forma insegura (certificado)
+#             time.sleep(5)
+#             pyautogui.press('left')
+#             pyautogui.press('enter')
+#             # Aguarda 5 segundos e verifica se a conexão foi feita com sucesso
+#             time.sleep(5)
+#             return verificar_sessao_rdp()
+        
+#         except Exception as e:
+
+#             log.error(f"Erro ao conectar à área de trabalho remota:\n{e}")
+#             return False
+    
+#     elif sistema == "Linux":
+        
+#         # Comando para executar a conexao com o xfreerdp
+#         # Para instalar: sudo apt install freerdp2-x11
+#         comando_rdp = f"""xfreerdp /u:{usuario} /p:{senha} /v:{host} /size:1920x1080"""
+
+#         # Executar o comando e capturar saída
+#         try:
+            
+#             processo_rdp = subprocess.Popen(
+#                 comando_rdp,
+#                 shell=True,
+#                 stdout=subprocess.PIPE,
+#                 stderr=subprocess.PIPE,
+#                 text=True
+#             )
+        
+#         except Exception as e:
+        
+#             raise Exception(f"Falha ao executar o comando de conexão RDP no Linux. Você possui o xfreerdp instalado? (sudo apt install freerdp2-x11)\nErro: {str(e)}")
+        
+#         # Aguarda 10 segundos, para aparecer o banner azul
+#         time.sleep(10)
+
+#         # Se a conexão foi bem-sucedida, retornar True
+#         if processo_rdp.poll() is None:
+            
+#             # Clica no 'enter', no banner azul
+#             pyautogui.press('enter')
+#             return True
+
+#         else:
+
+#             return False
+        
+#     else:
+
+#         raise Exception("Sistema operacional não suportado (Somente 'Windows' ou 'Linux').")
+

csc_cia_stne-0.0.97/src/csc_cia_stne/utilitarios/validations/ftp.py

@@ -0,0 +1,109 @@
+from pydantic import BaseModel, field_validator
+
+class InitParamsValidator(BaseModel):
+    """
+    Classe InitParamsValidator
+    Valida os parâmetros de inicialização para conexão FTP.
+    Atributos:
+        host (str): Endereço do servidor FTP. Deve ser uma string não vazia.
+        user (str): Nome de usuário para autenticação. Deve ser uma string não vazia.
+        password (str): Senha para autenticação. Deve ser uma string não vazia.
+        port (int): Porta do servidor FTP. Deve ser um inteiro positivo.
+        tryouts (int): Número de tentativas de conexão. Deve ser um inteiro positivo.
+        timeout (int): Tempo limite para conexão em segundos. Deve ser um inteiro positivo.
+        tls (bool): Indica se a conexão deve usar TLS. Deve ser um valor booleano.
+        ssl (bool): Indica se a conexão deve usar SSL. Deve ser um valor booleano.
+        verify_ssl (bool): Indica se o certificado SSL deve ser verificado. Deve ser um valor booleano.
+        verify_host (bool): Indica se o host deve ser verificado. Deve ser um valor booleano.
+    Métodos:
+        check_str_input(cls, value, info):
+            Valida se os campos 'host', 'user' e 'password' são strings não vazias.
+            Levanta ValueError caso o valor seja inválido.
+        check_int_input(cls, value, info):
+            Valida se os campos 'port', 'timeout' e 'tryouts' são inteiros positivos.
+            Levanta ValueError caso o valor seja inválido.
+        check_bool_input(cls, value, info):
+            Valida se os campos 'tls', 'ssl', 'verify_ssl' e 'verify_host' são booleanos.
+            Levanta ValueError caso o valor seja inválido.
+    """
+    host:str
+    user:str
+    password:str
+    port:int
+    tryouts:int
+    timeout:int
+    tls:bool
+    ssl:bool
+    verify_ssl:bool
+    verify_host:bool
+
+    @field_validator('host','user','password')
+    def check_str_input(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O parametro '{info.field_name}' deve ser uma string e não um {type(value)} e não vazio")
+        return value
+    
+    @field_validator('port','timeout','tryouts')
+    def check_int_input(cls, value, info):
+        if not isinstance(value, int) or value <= 0:
+            raise ValueError(f"O parametro '{info.field_name}' deve ser um inteiro positivo e não um {type(value)}")
+        return value
+    
+    @field_validator('tls','ssl','verify_ssl','verify_host')
+    def check_bool_input(cls, value, info):
+        if not isinstance(value, bool):
+            raise ValueError(f"O parametro '{info.field_name}' deve ser um booleano e não um {type(value)}")
+        return value
+    
+
+class UploadDownloadValidator(BaseModel):
+    """
+    Classe UploadDownloadValidator
+    Valida os parâmetros fornecidos para operações de upload e download via FTP.
+    Atributos:
+        filename (str): Nome do arquivo. Deve ser uma string não vazia.
+        filepathftp (str): Caminho no FTP onde o arquivo está localizado ou será armazenado. Deve ser uma string não vazia.
+        method (str): Método da operação, deve ser 'upload' ou 'download'.
+    Métodos:
+        check_str_input(cls, value, info):
+            Valida se os campos 'filename' e 'filepathftp' são strings não vazias.
+            Levanta ValueError se o valor não for uma string ou estiver vazio.
+        check_method(cls, value):
+            Valida se o campo 'method' é 'upload' ou 'download'.
+            Levanta ValueError se o valor não for uma das opções válidas.
+    """
+    filename:str
+    filepathftp:str
+    method:str
+
+    @field_validator('filename','filepathftp')
+    def check_str_input(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O parametro '{info.field_name}' deve ser uma string e não um {type(value)} e não vazio")
+        return value
+    
+    @field_validator('method')
+    def check_method(cls, value):
+        if str(value).lower() not in ['upload', 'download']:
+            raise ValueError(f"O parametro 'method' deve ser 'upload' ou 'download', mas foi recebido '{value}'")
+        return value
+    
+
+class ListFilesValidator(BaseModel):
+    """
+    Classe ListFilesValidator
+    Valida os parâmetros relacionados ao caminho de arquivos no FTP.
+    Atributos:
+        filepathftp (str): Representa o caminho do arquivo no FTP. Deve ser uma string não vazia.
+    Métodos:
+        check_str_input(cls, value, info):
+            Valida se o valor fornecido para o campo 'filepathftp' é uma string não vazia.
+            Levanta um ValueError caso o valor não seja uma string ou seja vazio.
+    """
+    filepathftp:str
+
+    @field_validator('filepathftp')
+    def check_str_input(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O parametro '{info.field_name}' deve ser uma string e não um {type(value)} e não vazio")
+        return value

{csc_cia_stne-0.0.95 → csc_cia_stne-0.0.97}/src/csc_cia_stne.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csc_cia_stne
-Version: 0.0.95
+Version: 0.0.97
 Summary: Biblioteca do time CSC-CIA utilizada no desenvolvimento de RPAs
 License: MIT
 Keywords: karavela,csc,cia,stone,rpa,botcity,stne
@@ -30,7 +30,7 @@ Requires-Dist: email-validator
 Requires-Dist: botcity-maestro-sdk
 Requires-Dist: psutil
 Requires-Dist: cryptography
-Requires-Dist: pyautogui
+Requires-Dist: pycurl
 Dynamic: license-file
 
 Essa biblioteca é desenvolvida e atualizada pelo time **CSC-CIA** da **Stone**

{csc_cia_stne-0.0.95 → csc_cia_stne-0.0.97}/src/csc_cia_stne.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/csc_cia_stne/__init__.py
 src/csc_cia_stne/bc_correios.py
 src/csc_cia_stne/bc_sta.py
 src/csc_cia_stne/email.py
+src/csc_cia_stne/ftp.py
 src/csc_cia_stne/gcp_bigquery.py
 src/csc_cia_stne/gcp_bucket.py
 src/csc_cia_stne/google_drive.py
@@ -37,6 +38,7 @@ src/csc_cia_stne/utilitarios/validations/GcpBigQueryValidator.py
 src/csc_cia_stne/utilitarios/validations/GoogleDriveValidator.py
 src/csc_cia_stne/utilitarios/validations/ServiceNowValidator.py
 src/csc_cia_stne/utilitarios/validations/__init__.py
+src/csc_cia_stne/utilitarios/validations/ftp.py
 src/csc_cia_stne/utilitarios/validations/gcp_bucket.py
 src/csc_cia_stne/utilitarios/validations/waccess.py
 src/csc_cia_stne/utilitarios/validations/web_validator.py

{csc_cia_stne-0.0.95 → csc_cia_stne-0.0.97}/src/csc_cia_stne.egg-info/requires.txt

@@ -22,4 +22,4 @@ email-validator
 botcity-maestro-sdk
 psutil
 cryptography
-pyautogui
+pycurl

csc_cia_stne-0.0.95/src/csc_cia_stne/utilitarios/functions/func_rdp.py

@@ -1,147 +0,0 @@
-import platform
-import subprocess
-import time
-import pyautogui
-import psutil
-import pygetwindow as gw
-import logging
-pyautogui.USE_MOUSEINFO = False
-log = logging.getLogger('__main__')
-
-def obter_ip_conexao_rdp():
-    """Retorna o ip da conexão RDP
-
-    Returns:
-        str: ip
-    """
-    
-    for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
-    
-        if proc.info['name'] == 'mstsc.exe' and proc.info['cmdline']:
-    
-            for arg in proc.info['cmdline']:
-    
-                if arg.startswith("/v:"):  # O argumento '/v:' contém o IP
-    
-                    return arg.replace("/v:", "").strip()
-    
-    return None
-
-def verificar_sessao_rdp()->bool:
-    """Verifica se a sessão RDP está ativa"""
-    # Verifica se o processo mstsc.exe está rodando
-    for proc in psutil.process_iter(['name']):
-        if proc.info['name'] == 'mstsc.exe':
-            #return True
-    
-            # Verifica se a janela da Área de Trabalho Remota está aberta
-            for window in gw.getAllTitles():
-                if "Área de Trabalho Remota" in window or "Remote Desktop" in window:
-                    return True
-    
-    return False
-
-def conectar_rdp(host:str, usuario:str, senha:str)->bool:
-    """Conecta via RDP em uma máquina remota
-    
-    Args:
-    
-            host (str): ip/host destino
-        usuario (str): usuário
-        senha (str): senha
-    
-    Returns:
-        bool: True/False
-    """
-    
-    sistema = platform.system()
-
-    if sistema == "Windows":
-
-        try:
-            
-            def criar_arquivo_rdp(host, usuario, caminho_rdp="conexao.rdp")->str:
-                """Cria um arquivo .rdp para conexão RDP
-                Args:
-                    host (str): host do computador remoto
-                    usuario (str): Usuário
-                    caminho_rdp (str): Caminho do arquivo .rdp
-                Returns:
-                    str: Caminho do arquivo .rdp
-                """
-                conteudo_rdp = f"""
-                screen mode id:i:2
-                desktopwidth:i:1920
-                desktopheight:i:1080
-                session bpp:i:32
-                winposstr:s:0,1,0,0,800,600
-                full address:s:{host}
-                username:s:{usuario}
-                """
-                with open(caminho_rdp, "w") as arquivo:
-                    arquivo.write(conteudo_rdp.strip())
-                
-                return caminho_rdp
-
-            caminho_rdp = criar_arquivo_rdp(host, usuario)
-            subprocess.run(f"start mstsc {caminho_rdp}", shell=True)
-            # Espera a conexão ser feita e confirma que realmente quer fazer a conexão com o computador remoto de forma insegura (certificado)
-            time.sleep(10)
-            pyautogui.press('left')
-            pyautogui.press('enter')
-            # Espera 3 segundos para digitar a senha e dar enter
-            time.sleep(3)
-            pyautogui.write(senha)
-            pyautogui.press('enter')
-            # Espera 5 segundos para aparecer a tela sobre o certificado e aceitar a conexão de forma insegura (certificado)
-            time.sleep(5)
-            pyautogui.press('left')
-            pyautogui.press('enter')
-            # Aguarda 5 segundos e verifica se a conexão foi feita com sucesso
-            time.sleep(5)
-            return verificar_sessao_rdp()
-        
-        except Exception as e:
-
-            log.error(f"Erro ao conectar à área de trabalho remota:\n{e}")
-            return False
-    
-    elif sistema == "Linux":
-        
-        # Comando para executar a conexao com o xfreerdp
-        # Para instalar: sudo apt install freerdp2-x11
-        comando_rdp = f"""xfreerdp /u:{usuario} /p:{senha} /v:{host} /size:1920x1080"""
-
-        # Executar o comando e capturar saída
-        try:
-            
-            processo_rdp = subprocess.Popen(
-                comando_rdp,
-                shell=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True
-            )
-        
-        except Exception as e:
-        
-            raise Exception(f"Falha ao executar o comando de conexão RDP no Linux. Você possui o xfreerdp instalado? (sudo apt install freerdp2-x11)\nErro: {str(e)}")
-        
-        # Aguarda 10 segundos, para aparecer o banner azul
-        time.sleep(10)
-
-        # Se a conexão foi bem-sucedida, retornar True
-        if processo_rdp.poll() is None:
-            
-            # Clica no 'enter', no banner azul
-            pyautogui.press('enter')
-            return True
-
-        else:
-
-            return False
-        
-    else:
-
-        raise Exception("Sistema operacional não suportado (Somente 'Windows' ou 'Linux').")
-