rcb-requests 0.1.0__tar.gz

rcb_requests-0.1.0/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: rcb-requests
+Version: 0.1.0
+Summary: Cliente async (Page Object) para automação do portal RCB Santander.
+License: Proprietary
+Keywords: rpa,rcb,santander,aiohttp,automation
+Author: Emanuel Borges Albano
+Author-email: emanuel.albano@goesnicoladelli.com.br
+Requires-Python: >=3.12
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Dist: aiohttp (>=3.9,<4.0)
+Requires-Dist: beautifulsoup4 (>=4.12,<5.0)
+Requires-Dist: utils-rpa (>=0.1.2,<0.2.0)
+Project-URL: Homepage, https://gitlab.com/goesnicoladelli/rcb-requests
+Project-URL: Issues, https://gitlab.com/goesnicoladelli/rcb-requests/-/issues
+Project-URL: Repository, https://gitlab.com/goesnicoladelli/rcb-requests
+Description-Content-Type: text/markdown
+
+# rcb-requests
+
+Cliente Python async para automação do portal **RCB Santander** (`negocios.santander.com.br`), baseado em [aiohttp](https://docs.aiohttp.org/) e Page Object Model.
+
+## Requisitos
+
+- Python 3.12+
+- Acesso ao GitLab Package Registry da empresa (para instalar esta lib e `utils-rpa`)
+
+## Instalação
+
+### Poetry (recomendado)
+
+Configure o registry do grupo no GitLab (onde `utils-rpa` também está publicado):
+
+```bash
+poetry source add --priority=supplemental gitlab-group \
+  "https://gitlab.com/api/v4/groups/SEU_GRUPO_ID/-/packages/pypi/simple"
+poetry config http-basic.gitlab-group SEU_USUARIO SEU_TOKEN
+poetry add rcb-requests
+```
+
+### pip
+
+```bash
+pip install rcb-requests \
+  --index-url https://gitlab.com/api/v4/projects/SEU_PROJECT_ID/packages/pypi/simple \
+  --extra-index-url https://pypi.org/simple
+```
+
+Use um Personal Access Token ou Deploy Token com permissão `read_package_registry`.
+
+## Uso rápido
+
+```python
+import asyncio
+
+import aiohttp
+
+from rcb_requests import Renegociacao
+from rcb_requests.client import Session
+from rcb_requests.pages import LoginPage
+
+
+async def main():
+    async with aiohttp.ClientSession(
+        base_url="https://negocios.santander.com.br",
+        timeout=aiohttp.ClientTimeout(total=30),
+    ) as client:
+        session = Session(client)
+        login_page = LoginPage(session)
+
+        await login_page.access_page()
+
+        response, home = await login_page.login(
+            cnpj="00.000.000/0001-00",
+            username="usuario",
+            password="senha",
+            resolve_captcha=lambda image: "abcd",  # integre seu resolvedor de captcha
+        )
+
+        if not response.success:
+            raise RuntimeError(response.error_message)
+
+        reneg_page = await home.sidebar.click_option(Renegociacao.CONSULTA)
+        result_page = await reneg_page.filtro_pesquisa.submit_filter(contrato="12345678901")
+        rows = result_page.get_rows_filter()
+        print(rows)
+
+
+asyncio.run(main())
+```
+
+## Arquitetura
+
+```
+Session          → transporte HTTP e parsing HTML
+  └── Page       → tela do RCB (login, home, consultas…)
+        └── PageElement → formulários, sidebar, popups
+```
+
+- **`Session`**: mantém a última página (`BeautifulSoup`) e monta payloads JSF/ICEfaces via `create_payload`.
+- **`Page` / `PageElement`**: localizam elementos no DOM e disparam requisições.
+- **`types`**: enums da sidebar, dataclasses de resposta e linhas de tabela.
+
+## Captcha
+
+O login exige um callback `resolve_captcha` que recebe a imagem em base64 (`data:image/jpg;base64,...`) e retorna o texto. Exemplo com `utils-rpa`:
+
+```python
+from utils_rpa.anti_captcha import image_to_text
+
+resolve = lambda image: image_to_text(os.environ["ANTICAPTCHA_TOKEN"], image)
+```
+
+## Debug
+
+Salve o HTML da última resposta para inspecionar a página:
+
+```python
+session.save_last_page_debug("ultima_pagina")
+```
+
+## Exemplos
+
+Scripts completos (com variáveis de ambiente) ficam em `examples/`:
+
+- `examples/login_and_consulta.py`
+- `examples/benchmark_steps.py`
+
+```bash
+export RCB_CNPJ="..."
+export RCB_USERNAME="..."
+export RCB_PASSWORD="..."
+export ANTICAPTCHA_TOKEN="..."
+python examples/login_and_consulta.py
+```
+
+## Desenvolvimento
+
+```bash
+poetry install --with dev
+ruff check src tests
+pytest
+```
+
+## Publicação
+
+1. Atualize a versão em `pyproject.toml` e registre em `CHANGELOG.md`.
+2. Crie uma tag SemVer: `git tag v0.1.0 && git push origin v0.1.0`.
+3. O pipeline `.gitlab-ci.yml` publica no GitLab Package Registry.
+
+Configure a variável `GITLAB_GROUP_ID` no projeto GitLab para o CI resolver dependências internas (`utils-rpa`).
+
+## Licença
+
+Uso interno — proprietário.
+

rcb_requests-0.1.0/README.md

@@ -0,0 +1,137 @@
+# rcb-requests
+
+Cliente Python async para automação do portal **RCB Santander** (`negocios.santander.com.br`), baseado em [aiohttp](https://docs.aiohttp.org/) e Page Object Model.
+
+## Requisitos
+
+- Python 3.12+
+- Acesso ao GitLab Package Registry da empresa (para instalar esta lib e `utils-rpa`)
+
+## Instalação
+
+### Poetry (recomendado)
+
+Configure o registry do grupo no GitLab (onde `utils-rpa` também está publicado):
+
+```bash
+poetry source add --priority=supplemental gitlab-group \
+  "https://gitlab.com/api/v4/groups/SEU_GRUPO_ID/-/packages/pypi/simple"
+poetry config http-basic.gitlab-group SEU_USUARIO SEU_TOKEN
+poetry add rcb-requests
+```
+
+### pip
+
+```bash
+pip install rcb-requests \
+  --index-url https://gitlab.com/api/v4/projects/SEU_PROJECT_ID/packages/pypi/simple \
+  --extra-index-url https://pypi.org/simple
+```
+
+Use um Personal Access Token ou Deploy Token com permissão `read_package_registry`.
+
+## Uso rápido
+
+```python
+import asyncio
+
+import aiohttp
+
+from rcb_requests import Renegociacao
+from rcb_requests.client import Session
+from rcb_requests.pages import LoginPage
+
+
+async def main():
+    async with aiohttp.ClientSession(
+        base_url="https://negocios.santander.com.br",
+        timeout=aiohttp.ClientTimeout(total=30),
+    ) as client:
+        session = Session(client)
+        login_page = LoginPage(session)
+
+        await login_page.access_page()
+
+        response, home = await login_page.login(
+            cnpj="00.000.000/0001-00",
+            username="usuario",
+            password="senha",
+            resolve_captcha=lambda image: "abcd",  # integre seu resolvedor de captcha
+        )
+
+        if not response.success:
+            raise RuntimeError(response.error_message)
+
+        reneg_page = await home.sidebar.click_option(Renegociacao.CONSULTA)
+        result_page = await reneg_page.filtro_pesquisa.submit_filter(contrato="12345678901")
+        rows = result_page.get_rows_filter()
+        print(rows)
+
+
+asyncio.run(main())
+```
+
+## Arquitetura
+
+```
+Session          → transporte HTTP e parsing HTML
+  └── Page       → tela do RCB (login, home, consultas…)
+        └── PageElement → formulários, sidebar, popups
+```
+
+- **`Session`**: mantém a última página (`BeautifulSoup`) e monta payloads JSF/ICEfaces via `create_payload`.
+- **`Page` / `PageElement`**: localizam elementos no DOM e disparam requisições.
+- **`types`**: enums da sidebar, dataclasses de resposta e linhas de tabela.
+
+## Captcha
+
+O login exige um callback `resolve_captcha` que recebe a imagem em base64 (`data:image/jpg;base64,...`) e retorna o texto. Exemplo com `utils-rpa`:
+
+```python
+from utils_rpa.anti_captcha import image_to_text
+
+resolve = lambda image: image_to_text(os.environ["ANTICAPTCHA_TOKEN"], image)
+```
+
+## Debug
+
+Salve o HTML da última resposta para inspecionar a página:
+
+```python
+session.save_last_page_debug("ultima_pagina")
+```
+
+## Exemplos
+
+Scripts completos (com variáveis de ambiente) ficam em `examples/`:
+
+- `examples/login_and_consulta.py`
+- `examples/benchmark_steps.py`
+
+```bash
+export RCB_CNPJ="..."
+export RCB_USERNAME="..."
+export RCB_PASSWORD="..."
+export ANTICAPTCHA_TOKEN="..."
+python examples/login_and_consulta.py
+```
+
+## Desenvolvimento
+
+```bash
+poetry install --with dev
+ruff check src tests
+pytest
+```
+
+## Publicação
+
+1. Atualize a versão em `pyproject.toml` e registre em `CHANGELOG.md`.
+2. Crie uma tag SemVer: `git tag v0.1.0 && git push origin v0.1.0`.
+3. O pipeline `.gitlab-ci.yml` publica no GitLab Package Registry.
+
+Configure a variável `GITLAB_GROUP_ID` no projeto GitLab para o CI resolver dependências internas (`utils-rpa`).
+
+## Licença
+
+Uso interno — proprietário.

rcb_requests-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "rcb-requests"
+version = "0.1.0"
+description = "Cliente async (Page Object) para automação do portal RCB Santander."
+authors = [
+    { name = "Emanuel Borges Albano", email = "emanuel.albano@goesnicoladelli.com.br" },
+]
+readme = "README.md"
+license = { text = "Proprietary" }
+requires-python = ">=3.12"
+keywords = ["rpa", "rcb", "santander", "aiohttp", "automation"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
+]
+dependencies = [
+    "utils-rpa (>=0.1.2,<0.2.0)",
+    "beautifulsoup4 (>=4.12,<5.0)",
+    "aiohttp (>=3.9,<4.0)",
+]
+
+[project.urls]
+Homepage = "https://gitlab.com/goesnicoladelli/rcb-requests"
+Repository = "https://gitlab.com/goesnicoladelli/rcb-requests"
+Issues = "https://gitlab.com/goesnicoladelli/rcb-requests/-/issues"
+
+[tool.poetry]
+packages = [{ include = "rcb_requests", from = "src" }]
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.0"
+pytest-asyncio = "^0.24.0"
+pytest-cov = "^5.0.0"
+ruff = "^0.9.0"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+ignore = ["E501"]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

rcb_requests-0.1.0/src/rcb_requests/__init__.py

@@ -0,0 +1,26 @@
+"""Cliente async (Page Object) para automação do portal RCB Santander."""
+
+from rcb_requests.types import (
+    AcordosFinanciamento,
+    AcordosLeasing,
+    Calculadora,
+    ConsultaGCA,
+    Lamina,
+    Renegociacao,
+    SidebarOption,
+    UsuarioSecundario,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "SidebarOption",
+    "AcordosLeasing",
+    "AcordosFinanciamento",
+    "Calculadora",
+    "ConsultaGCA",
+    "Lamina",
+    "Renegociacao",
+    "UsuarioSecundario",
+]

rcb_requests-0.1.0/src/rcb_requests/client/__init__.py

@@ -0,0 +1,3 @@
+from .session import Session
+
+__all__ = ['Session']

rcb_requests-0.1.0/src/rcb_requests/client/session.py

@@ -0,0 +1,122 @@
+import logging
+
+from aiohttp import ClientSession
+from bs4 import BeautifulSoup
+from utils_rpa import extract_inputs
+
+
+class Session:
+    """Encapsula um ``aiohttp.ClientSession`` e mantém o estado da última página.
+
+    Responsável apenas pelo transporte HTTP e pelo parsing do HTML. As páginas e
+    elementos recebem uma instância desta classe por composição.
+    """
+
+    logger = logging.getLogger(__name__)
+
+    def __init__(self, client: ClientSession):
+        self._client   = client
+        self.last_page : BeautifulSoup | None = None
+
+    async def get(self, url: str, params: dict | None = None) -> BeautifulSoup:
+        self.logger.debug('Fazendo GET request')
+        async with self._client.get(
+            url,
+            params=params,
+            allow_redirects=True,
+        ) as response:
+            self.last_page = self.get_soup(await response.text())
+            return self.last_page
+
+    async def post(
+        self,
+        url: str,
+        json: dict | None = None,
+        data: dict | None = None,
+    ) -> BeautifulSoup:
+        self.logger.debug('Fazendo POST request')
+        async with self._client.post(
+            url,
+            json=json,
+            data=data,
+            allow_redirects=True,
+        ) as response:
+            self.last_page = self.get_soup(await response.text())
+            return self.last_page
+
+    async def close(self):
+        self.logger.debug('Fechando sessão')
+        await self._client.close()
+
+    def extract_inputs(self, soup: BeautifulSoup) -> dict:
+        self.logger.debug('Extraindo inputs')
+        return extract_inputs(soup)
+
+    def create_payload(self, clicked_element: BeautifulSoup) -> tuple[dict[str, str], str]:
+        """Cria o payload ideal para cada requisição no RCB, com base no elemento clicado.
+
+        Args:
+            clicked_element (BeautifulSoup): Elemento em que foi realizado o clique
+
+        Returns:
+            tuple[dict[str, str], str]: payload key:value e url (action do form)
+        """
+        self.logger.debug('Criando payload')
+        element_name = clicked_element.name
+        form         = clicked_element.find_parent('form')
+        if form is None:
+            raise ValueError('Elemento clicado não está dentro de um <form>.')
+
+        data    = self.extract_inputs(form)
+        tag_id  = clicked_element.get('id', '')
+        form_id = form.get('id', '')
+
+        data.update({
+            'ice.event.captured': tag_id,
+            'javax.faces.source': tag_id,
+            form_id: form_id,
+            f'{form_id}_SUBMIT': 1,
+        })
+
+        match element_name:
+            case 'div':
+                self.logger.info('click na div')
+                a_tag = clicked_element.find('a')
+                a_id  = a_tag.get('id', '') if a_tag else ''
+                data.update({
+                    'ice.focus': a_id,
+                    'ice.event.target': a_id,
+                    tag_id: tag_id,
+                })
+            case 'input':
+                self.logger.info('click no input')
+                input_value = clicked_element.get('value', '')
+                data.update({
+                    'ice.focus': tag_id,
+                    'ice.event.target': tag_id,
+                    tag_id: input_value,
+                })
+            case 'select':
+                self.logger.info('click em select')
+                parent_span = clicked_element.find_parent('span', {'id': True})
+                data.update({
+                    'ice.focus': tag_id,
+                    'ice.event.target': tag_id,
+                    'ice.event.captured': parent_span.get('id', '') if parent_span else tag_id,
+                    'javax.faces.source': parent_span.get('id', '') if parent_span else tag_id,
+                })
+            case _:
+                self.logger.info('click no default')
+                data.update({
+                    'ice.focus': tag_id,
+                    'ice.event.target': tag_id,
+                    tag_id: tag_id,
+                })
+        return data, form.attrs.get('action', '')
+
+    def save_last_page_debug(self, filename: str = 'last_page') -> None:
+        with open(f'{filename}.html', 'w', encoding='utf-8') as f:
+            f.write(self.last_page.prettify())
+
+    def get_soup(self, html: str) -> BeautifulSoup:
+        return BeautifulSoup(html, 'html.parser')

rcb_requests-0.1.0/src/rcb_requests/page_elements/__init__.py

@@ -0,0 +1,13 @@
+from .form_login import FormLogin
+from .popup import Popup
+from .reneg_consulta_detalhe import RenegConsultaDetalhe
+from .reneg_filtro_pesquisa import RenegFiltroPesquisa
+from .sidebar import Sidebar
+
+__all__ = [
+    'FormLogin',
+    'Popup',
+    'RenegConsultaDetalhe',
+    'RenegFiltroPesquisa',
+    'Sidebar',
+]

rcb_requests-0.1.0/src/rcb_requests/page_elements/form_login.py

@@ -0,0 +1,43 @@
+
+from rcb_requests.shared import PageElement
+
+
+class FormLogin(PageElement):
+    __locator__ = '#j_id_x'
+
+    # Locators
+    _captcha_locator = '#imgElem1'
+    _button_login    = '[id="j_id_x:__1l"]'
+
+    # Nomes dos campos (chaves do payload)
+    _cnpj     = 'j_id_x:__13_2'
+    _username = 'j_id_x:__16'
+    _password = 'j_id_x:__18'
+    _captcha  = 'j_id_x:__1j_input'
+
+    @property
+    def captcha_image(self) -> str | None:
+        img = self.element.select_one(self._captcha_locator)
+        return img.get('src').split(",")[1].strip() if img else None
+
+    async def login(self, cnpj: str, username: str, password: str, captcha: str):
+        """Realiza o login no sistema.
+        
+        Args:
+            cnpj: CNPJ do usuário.
+            username: Nome de usuário do usuário.
+            password: Senha do usuário.
+            captcha: Texto da imagem de captcha.
+        """
+        button = self.element.select_one(self._button_login)
+        if button is None:
+            raise ValueError(f'Botão de login não encontrado ({self._button_login}).')
+
+        payload, url = self.session.create_payload(button)
+        payload.update({
+            self._cnpj: cnpj,
+            self._username: username,
+            self._password: password,
+            self._captcha: captcha,
+        })
+        await self.session.post(url, data=payload)

rcb_requests-0.1.0/src/rcb_requests/page_elements/popup.py

@@ -0,0 +1,75 @@
+
+from rcb_requests.shared import PageElement
+
+
+class Popup(PageElement):
+    """Diálogo (ICEfaces ace:dialog) atualmente visível na página.
+
+    Os ids externos (ex.: ``j_id_84_main``) são gerados dinamicamente e mudam a
+    cada view, então não servem de locator. O que identifica um popup *visível*
+    é a AUSÊNCIA da classe ``ace-dialog-hidden``. Cada popup traz o próprio
+    ``<form>`` (com ViewState) e botões, então reaproveitamos
+    ``session.create_payload`` para interagir.
+    """
+
+    # O :not(...) já descarta os diálogos ocultos (classe ``ace-dialog-hidden``),
+    # sobrando apenas o popup efetivamente visível.
+    __locator__ = 'div[id$="_main"][class*="dialog"]:not([class*="ace-dialog-hidden"])'
+
+    _title_locator   = '.pop-titulo'
+    _message_locator = '.pop-msg'
+    _button_locator  = 'input[type="submit"], .botao'
+
+    @property
+    def is_open(self) -> bool:
+        return self.element is not None
+
+    @property
+    def title(self) -> str | None:
+        el = self.element
+        node = el.select_one(self._title_locator) if el else None
+        return node.get_text(strip=True) if node else None
+
+    @property
+    def message(self) -> str | None:
+        el = self.element
+        node = el.select_one(self._message_locator) if el else None
+        return node.get_text(strip=True) if node else None
+
+    @property
+    def buttons(self) -> list[str]:
+        el = self.element
+        if el is None:
+            return []
+        return [b.get('value', '').strip() for b in el.select(self._button_locator)]
+
+    async def click_button(self, value: str|None=None):
+        """Clica no botão do popup cujo ``value`` corresponda (case-insensitive).
+        Se ``value`` for ``None``, clica no ultimo botão.
+        """
+        el = self.element
+        if el is None:
+            raise RuntimeError('Nenhum popup aberto para interagir.')
+        buttons = el.select(self._button_locator)
+        if value is None:
+            button = buttons[-1]
+        else:
+            button = next(
+            (
+                b for b in el.select(self._button_locator)
+                if b.get('value', '').strip().casefold() == value.casefold()
+            ),
+            None,
+        )
+        if button is None:
+            raise ValueError(
+                f'Botão {value!r} não encontrado. Disponíveis: {self.buttons}'
+            )
+        payload, url = self.session.create_payload(button)
+        await self.session.post(url, data=payload)
+
+    async def confirm(self):
+        await self.click_button('Confirmar')
+
+    async def cancel(self):
+        await self.click_button('Voltar')