csc-cia-stne 0.0.13__py3-none-any.whl

csc_cia_stne/stne_admin.py

@@ -0,0 +1,423 @@
+import requests
+import jwt
+from datetime import datetime, timedelta
+import time
+#import subprocess
+import json
+#from modules.pdf import gerar_pdf_extrato
+#import csv
+#import io
+#import sys
+#import logging
+from pydantic import BaseModel, StrictStr, StrictInt, ValidationError, field_validator, FieldValidationInfo
+from typing import Literal
+
+# Validações dos inputs
+class InitParamsValidator(BaseModel):
+    client_id: str
+    user_agent: str
+    private_key: str
+    ambiente: Literal["prd", "sdx"]  # Aceita apenas "prd" ou "sdx"
+
+    # Validação para garantir que cada parâmetro é uma string não vazia
+    @field_validator('client_id', 'user_agent', 'private_key')
+    def check_non_empty_string(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            
+            raise ValueError(f"O parâmetro '{info.field_name}' deve ser uma string não vazia.")
+        
+        return value
+    
+class DocumentoValidator(BaseModel):
+
+    documento: StrictStr | StrictInt  # Aceita apenas str ou int
+
+    # Valida se 'documento' não é vazio
+    @field_validator('documento')
+    def documento_nao_vazio(cls, value: StrictStr | StrictInt, info: FieldValidationInfo):
+        
+        if isinstance(value, str) and not value.strip():
+        
+            raise ValueError("O parâmetro 'documento' não pode ser uma string vazia.")
+        
+        return value
+
+class AccountIDValidator(BaseModel):
+    
+    account_id: StrictStr # Aceita apenas str
+
+    # Valida se 'client_id' não é vazio
+    @field_validator('account_id')
+    def account_id_nao_vazio(cls, value: StrictStr, info: FieldValidationInfo):
+        
+        if isinstance(value, str) and not value.strip():
+        
+            raise ValueError("O parâmetro 'account_id' não pode ser uma string vazia.")
+        
+        return value
+    
+class ExtratoParamsValidator(BaseModel):
+    
+    account_id: str
+    data_inicio: datetime
+    data_fim: datetime
+    async_mode: bool
+
+    # Valida se 'client_id' não é vazio
+    @field_validator('account_id')
+    def account_id_nao_vazio(cls, value: StrictStr, info: FieldValidationInfo):
+        
+        if isinstance(value, str) and not value.strip():
+        
+            raise ValueError("O parâmetro 'account_id' não pode ser uma string vazia.")
+        
+        return value
+
+    # Valida se 'data_inicio' está no formato datetime
+    @field_validator('data_inicio', 'data_fim')
+    def check_datetime_format(cls, value, info: FieldValidationInfo):
+        
+        if not isinstance(value, datetime):
+        
+            raise ValueError(f"O parâmetro '{info.field_name}' deve estar no formato datetime.")
+        
+        return value
+
+    # Valida se 'data_fim' é posterior a 'data_inicio'
+    @field_validator('data_fim')
+    def check_data_fim_posterior(cls, data_fim, values):
+        data_inicio = values.get('data_inicio')
+        
+        if data_inicio and data_fim and data_fim <= data_inicio:
+        
+            raise ValueError("O parâmetro 'data_fim' deve ser posterior a data_inicio.")
+        
+        return data_fim
+
+    # Valida se 'async_mode' é um valor booleano
+    @field_validator('async_mode')
+    def check_async_mode(cls, async_mode):
+        
+        if not isinstance(async_mode, bool):
+        
+            raise ValueError("O parâmetro 'async_mode' deve ser um valor booleano.")
+        
+        return async_mode
+
+class ReceiptIDValidator(BaseModel):
+    
+    receipt_id: StrictStr # Aceita apenas str
+
+    # Valida se 'receipt_id' não é vazio
+    @field_validator('receipt_id')
+    def receipt_id_nao_vazio(cls, value: StrictStr, info: FieldValidationInfo):
+        
+        if isinstance(value, str) and not value.strip():
+        
+            raise ValueError("O parâmetro 'receipt_id' não pode ser uma string vazia.")
+        
+        return value
+
+class StoneAdmin:
+    
+    def __init__(self, client_id:str, user_agent:str, private_key:str, ambiente:str):
+    
+        try:
+            
+            InitParamsValidator(client_id=client_id, user_agent=user_agent, private_key=private_key, ambiente=ambiente)
+        
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input da inicialização da instância:", e.errors())
+        
+        # Produção
+        if ambiente == 'prd':
+        
+            self.base_url = 'https://api.openbank.stone.com.br/resources/v1'
+            self.base_auth_url = 'https://accounts.openbank.stone.com.br'
+        
+        # Sandbox
+        else:
+        
+            self.base_url = 'https://sandbox-api.openbank.stone.com.br/resources/v1'
+            self.base_auth_url = 'https://sandbox-accounts.openbank.stone.com.br'
+        
+        self.client_id = client_id
+        self.user_agent = user_agent
+        self.private_key = private_key
+        self.token = self.__get_token()
+        self.authenticated_header = {
+            'Authorization' : f"Bearer {self.token}",
+            'User-Agent': self.user_agent,
+            #'Client-ID': self.client_id
+        }
+
+    def __get_token(self):
+        base_url = f'{self.base_auth_url}/auth/realms/stone_bank'
+        auth_url = f'{base_url}/protocol/openid-connect/token'
+        payload = {
+            'exp': int(time.time()) + 3600,
+            'nbf': int(time.time()),
+            'aud': base_url,
+            'realm': 'stone_bank',
+            'sub': self.client_id,
+            'clientId': self.client_id,
+            'jti': str(time.time()),
+            'iat': int(time.time()),
+            'iss': self.client_id
+        }
+
+        token = jwt.encode(payload, self.private_key, algorithm='RS256')
+
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'User-Agent': self.user_agent
+        }
+
+        token_payload = {
+            'client_id': self.client_id,
+            'grant_type': 'client_credentials',
+            'client_assertion': token,
+            'client_assertion_type': 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer'
+        }
+
+        response = requests.post(auth_url, data=token_payload, headers=headers, timeout=60)
+        #print(response.json())
+        return response.json()['access_token']
+
+    def renew_authorization(self):
+        self.token = self.__get_token()
+        self.authenticated_header = {
+            'Authorization' : f"Bearer {self.token}",
+            'User-Agent': self.user_agent,
+            #'Client-ID': self.client_id
+        }
+
+    def verificar_cliente(self,documento:str)->dict:
+        
+        try:
+        
+            DocumentoValidator(documento=documento)
+        
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+        
+        params_conta_ativa = {'owner_document': documento}
+        params_conta_inativa = {'owner_document': documento,'status':'closed'}
+
+        try:
+
+            # Verificando se existe cliente com esse documento, com a conta ativa
+            response = requests.get(f"{self.base_url}/accounts", params=params_conta_ativa, headers=self.authenticated_header, timeout=60)
+            
+            # Retorno esperado pela API Stone Admin - consulta cliente ativo
+            if response.status_code == 200:
+                
+                # Não existe cliente com esse documento e com a conta ativa
+                if len(response.json()) == 0:
+                    
+                    # Verificando se existe cliente com esse documento, com a conta inativa
+                    encontrado = False
+                    response = requests.get(f"{self.base_url}/accounts", params=params_conta_inativa, headers=self.authenticated_header, timeout=60)
+                    
+                    # Retorno esperado pela API Stone Admin - consulta cliente inativo
+                    if response.status_code == 200:
+                        
+                        resposta = response.json()
+                    
+                        # Existe cliente com esse documento, mas com a conta inativa
+                        if len(resposta) != 0:
+                        
+                            encontrado = True
+                    
+                    # Algum erro na API Stone Admin - retorna erro
+                    else:
+                        
+                        return False, ValueError(response.json())
+                
+                # Cliente econtrado e com a conta ativa
+                else:
+
+                    encontrado = True
+                    resposta = response.json()
+                
+                retorno = []
+                
+                # Monta JSON , pode ter mais de uma conta
+                for registro in resposta:
+
+                    retorno_item = {}
+                    account_code = registro["account_code"]
+                    account_id = registro["id"]
+                    owner_id = registro["owner_id"]
+                    closed_at = registro["closed_at"]
+                    created_at = registro["created_at"]
+
+                    # Status atual da conta
+                    if closed_at is None:
+
+                        registro["conta_ativa"] = True
+                    
+                    else:
+                    
+                        registro["conta_ativa"] = False
+                        
+                    retorno.append(registro)
+
+                retorno_json = {
+                    "success":True,
+                    "status_code": response.status_code,
+                    "error": None,
+                    "encontrado": encontrado,
+                    "detalhes": retorno
+                    }
+                return retorno_json
+            
+            # Retorno inesperado pela API Stone Admin - consulta cliente ativo, retorna erro
+            else:
+
+                retorno_json = {
+                    "success":False,
+                    "status_code": response.status_code,
+                    "error": ValueError(response.json())
+                    }
+                return retorno_json
+        
+        # Erro inesperado como a requisição à API Stone Admin - consulta cliente ativo, retorna erro
+        except Exception as e:
+
+            retorno_json = {
+                "success":False,
+                "status_code": response.status_code,
+                "error": e
+                }        
+            return retorno_json
+    
+    def balance_da_conta(self,account_id:str):
+        try:
+        
+            AccountIDValidator(account_id=account_id)
+        
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+        
+        # Captura o balance da conta
+        response = requests.get(f"{self.base_url}/accounts/{account_id}", headers=self.authenticated_header)
+        return response
+
+    def detalhar_titular_cpf(self,documento:str):
+
+        try:
+        
+            DocumentoValidator(documento=documento)
+        
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+
+        # Detalha o titular
+        
+        # Verificar na rota /users (CPF)
+        filtro = {'document': documento}
+        param = {
+            'filter': json.dumps(filtro)  # Transforma o dicionário em uma string JSON
+        }
+        response = requests.get(f"{self.base_url}/users", params=param, headers=self.authenticated_header)
+        return response
+
+    def detalhar_titular_cnpj(self,documento:str):
+
+        try:
+        
+            DocumentoValidator(documento=documento)
+        
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+
+        # Verificar na rota /organizations (CNPJ)
+        filtro = {'document': documento}
+        param = {
+            'filter': json.dumps(filtro)  # Transforma o dicionário em uma string JSON
+        }
+        response = requests.get(f"{self.base_url}/organizations", params=param, headers=self.authenticated_header)
+        return response
+
+    def extrair_extrato(self,account_id:str,data_inicio:datetime,data_fim:datetime,async_mode:bool=False):
+        
+        try:
+        
+            ExtratoParamsValidator(account_id=account_id, data_inicio=data_inicio, data_fim=data_fim, async_mode=async_mode)
+        
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+        
+        # Validação do async_mode
+        if not isinstance(async_mode, bool):
+        
+            raise ValueError("async_mode deve ser um valor booleano.")
+
+
+        data_inicio = data_inicio.strftime('%Y-%m-%d')
+        data_fim = data_fim + timedelta(days=1)
+        data_fim = data_fim.strftime('%Y-%m-%d')
+
+        try:
+            
+            if async_mode:
+            
+                response = requests.get(f"{self.base_url}/exports/accounts/{account_id}/statement?start_date={data_inicio}&end_date={data_fim}&format=pdf&async=true", headers=self.authenticated_header, timeout=60)
+            
+            else:
+            
+                response = requests.get(f"{self.base_url}/exports/accounts/{account_id}/statement?start_date={data_inicio}&end_date={data_fim}&format=pdf&async=false", headers=self.authenticated_header, timeout=120)
+
+            if response.status_code == 200 and not async_mode:
+            
+                return {"success":True, "status_code": response.status_code, "error": None, "pdf_content": response.content}
+        
+            elif response.status_code == 202 and async_mode:
+
+                return {"success":True, "status_code": response.status_code, "error": None, "receipt_id":response.json()["id"]}
+            
+            else:
+            
+                return {"success":False, "status_code": response.status_code, "error": str(response.text), "pdf_content": None}
+    
+        except Exception as e:
+
+            return {"success": False, "status_code": response.status_code, "error": e, "pdf_content": None}
+
+    def download_receipt(self,receipt_id:str):
+        
+        try:
+        
+            ReceiptIDValidator(receipt_id=receipt_id)
+        
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
+
+        try:
+        
+            response = requests.get(f"https://api.openbank.stone.com.br/resources/v1/exports/receipt_requests/download/{receipt_id}", headers=self.authenticated_header, timeout=120)
+        
+            if response.status_code == 200:
+        
+                # Decodificando o conteúdo usando UTF-8
+                #decoded_content = response.content.decode('utf-8')
+                print("header:",response.headers['Content-Type'])
+                print(f"type do content: {type(response.content)}")
+                return {'result':True, 'status_code': response.status_code, 'error': None, 'pdf_content':response.content}
+                #return {'result':True, 'status_code': response.status_code, 'error': None, 'pdf_content':decoded_content}
+        
+            else:
+        
+                return {'result': False, 'status_code': response.status_code, 'error': response.json(), 'pdf_content': None}
+        
+        except Exception as e:
+            
+            return {'result': False, 'status_code': None, 'error': e, 'pdf_content': None}

csc_cia_stne/utilitarios.py

@@ -0,0 +1,72 @@
+import base64
+
+class Util():
+    """Classe Util com necessidades de rotina
+    """
+    
+    def b64decode(self,b64_string:str=None)->str:
+        """Faz o decode de uma string em base64
+
+        Args:
+            b64_string (str): string em base64
+
+        Returns:
+            str: string em texto
+        """
+            
+        if b64_string is None or b64_string == "":
+        
+            raise ValueError("Uma string Base64 precisa ser informada com o parâmetro 'b64_string'")
+        
+        try:
+        
+            b64_decode_output = base64.b64decode(b64_string).decode('utf-8')
+        
+        except:
+        
+            raise TypeError("A string informada não está em formato Base64")
+
+        return b64_decode_output
+
+    def b64encode(self,string_to_convert:str=None)->base64:
+        """Faz o encode de uma string para base64
+
+        Args:
+            string_to_convert (str): string para converter em base64
+
+        Returns:
+            base64: string convertida para base64
+        """
+        
+        if string_to_convert is None or string_to_convert == "":
+        
+            raise ValueError("Uma string precisa ser informada com o parâmetro 'string_to_convert'")
+        
+        try:
+        
+            b64_encode_output = base64.b64encode(str(string_to_convert).encode('utf-8')).decode('utf-8')
+        
+        except Exception as e:
+        
+            raise TypeError(f"Erro ao converter a string para Base64: {e}")
+
+        return b64_encode_output
+    
+    def convert_query_result_to_json(self,query_result:list)->list:
+        """Converte o resultado de uma query do BigQuery em uma lista de dicionários JSON
+
+        Args:
+            query_result (list): resultado da query do BigQuery (query.result)
+
+        Returns:
+            list: lista de dicionários JSON
+        """
+        
+        try:
+        
+            #return [dict(row) for row in query_result]
+            return [dict(row._asdict()) for row in query_result]
+        
+        except Exception as e:
+        
+            raise e

csc_cia_stne-0.0.13.dist-info/LICENCE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 CSC-CIA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

csc_cia_stne-0.0.13.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: csc_cia_stne
+Version: 0.0.13
+Summary: Biblioteca do time CSC-CIA utilizada no desenvolvimento de RPAs
+License: MIT
+Keywords: karavela,csc,cia,stone,rpa
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: python-json-logger
+Requires-Dist: rich
+Requires-Dist: requests
+Requires-Dist: pydantic
+Requires-Dist: zeep
+Requires-Dist: google-cloud-bigquery
+Requires-Dist: google-cloud-storage
+Requires-Dist: google-auth-oauthlib
+Requires-Dist: google-auth-httplib2
+
+Essa biblioteca é desenvolvida e atualizada pelo time **CSC-CIA** da **Stone**
+
+Utilizada no desenvolvimento dos RPAs, possui classes que são utilizadas com frequência
+
+O intuito é não precisar desenvolver, novamente, funcionalidades que são utilizadas com frequência
+
+Contato: **cia@stone.com.br**

csc_cia_stne-0.0.13.dist-info/RECORD

@@ -0,0 +1,15 @@
+csc_cia_stne/__init__.py,sha256=VYD8Lj4LgMqM5d3f2dgS5oqThEo9czi-wIDPaw3b3Ec,261
+csc_cia_stne/bc_correios.py,sha256=ANsvLyL7wdkM0MvjjBHB2Ih4eyTcyWgt5IqiK0Rv89E,23014
+csc_cia_stne/bc_sta.py,sha256=I9N29wjTbd4ZmoM2yIW-xp3X-dMENZdSb0JhapfCegY,10988
+csc_cia_stne/cia_logging.py,sha256=GbxpcjtF_7tiRez2awIKZJXdo5CvM0n_mo1RKpfvAnU,5100
+csc_cia_stne/gcp_bigquery.py,sha256=GBI7BDyranwr4IQGzLbbZRgD2Km6tlkqqVCI3R89-bE,5651
+csc_cia_stne/karavela.py,sha256=Q7MbQXXz_jtrLHM7QeenbSzcro07EpoFk4lKglivJ_I,3564
+csc_cia_stne/logger.py,sha256=cadiXHeOv8OaB4o8byznsks4VDTfR0cCccLIWxn2R48,4612
+csc_cia_stne/servicenow.py,sha256=d7HysnJU1Q22hy0e3cIW90S8_5IsQGETiJndnGOI_i8,23309
+csc_cia_stne/stne_admin.py,sha256=G5ozXt18VjKL2BHtROQk4GnfVY1xM14RXSQ-rra_D54,15487
+csc_cia_stne/utilitarios.py,sha256=LU8YrELiRIW4UxqULjiUPYmgbEx79NGenK5QKRdSh_E,2050
+csc_cia_stne-0.0.13.dist-info/LICENCE,sha256=LPGMtgKki2C3KEZP7hDhA1HBrlq5JCHkIeStUCLEMx4,1073
+csc_cia_stne-0.0.13.dist-info/METADATA,sha256=2_oSdzjh5F7344uGFXIxqRxm2xHmCN-TclJVjeurYOY,816
+csc_cia_stne-0.0.13.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+csc_cia_stne-0.0.13.dist-info/top_level.txt,sha256=ldo7GVv3tQx5KJvwBzdZzzQmjPys2NDVVn1rv0BOF2Q,13
+csc_cia_stne-0.0.13.dist-info/RECORD,,

csc_cia_stne-0.0.13.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

csc_cia_stne-0.0.13.dist-info/top_level.txt

@@ -0,0 +1 @@
+csc_cia_stne