Transfers deposits (#15)

* transfers and deposits

* created_at only for queryable

* add commissions

* Transfer.destination_uri

* use cuenca-validaions lib. closes #10

* destination_uri in Transfers

* make sure created_at is inherited

* Tests and fixes

* there are resources that are not cacheable

* making Cacheable work creates too many edge cases that we can't properly test yet

* cassette wasn't properly recorded

* fix merge

Co-authored-by: rogelioLpz <rogelio.lpz94@gmail.com>

Author: matin

cuenca/__init__.py

@@ -1,8 +1,24 @@
-__all__ = ['__version__', 'ApiKey', 'Transfer', 'configure']
+__all__ = [
+    '__version__',
+    'ApiKey',
+    'Account',
+    'BalanceEntry',
+    'Deposit',
+    'Transfer',
+    'WhatsappTransfer',
+    'configure',
+]
 
 
 from .http import session
-from .resources import ApiKey, Transfer
+from .resources import (
+    Account,
+    ApiKey,
+    BalanceEntry,
+    Deposit,
+    Transfer,
+    WhatsappTransfer,
+)
 from .version import __version__
 
 configure = session.configure

cuenca/http/client.py

@@ -1,11 +1,16 @@
 import os
 from typing import Optional, Tuple
+from urllib.parse import urljoin
 
 import requests
+from cuenca_validations.typing import (
+    ClientRequestParams,
+    DictStrAny,
+    OptionalDict,
+)
 from requests import Response
 
 from ..exc import CuencaResponseException
-from ..typing import ClientRequestParams, DictStrAny, OptionalDict
 from ..version import API_VERSION, CLIENT_VERSION
 
 API_URL = 'https://api.cuenca.com'
@@ -73,7 +78,7 @@ def request(
     ) -> DictStrAny:
         resp = self.session.request(
             method=method,
-            url=self.base_url + endpoint,
+            url=self.base_url + urljoin('/', endpoint),
             auth=self.auth,
             json=data,
             params=params,

cuenca/resources/__init__.py

@@ -1,4 +1,31 @@
-__all__ = ['ApiKey', 'Transfer']
+__all__ = [
+    'ApiKey',
+    'Account',
+    'BalanceEntry',
+    'Commission',
+    'Deposit',
+    'Transfer',
+    'WhatsappTransfer',
+]
 
+from .accounts import Account
 from .api_keys import ApiKey
+from .balance_entries import BalanceEntry
+from .commissions import Commission
+from .deposits import Deposit
+from .resources import RESOURCES
 from .transfers import Transfer
+from .whatsapp_transfers import WhatsappTransfer
+
+# avoid circular imports
+resource_classes = [
+    ApiKey,
+    Account,
+    BalanceEntry,
+    Commission,
+    Deposit,
+    Transfer,
+    WhatsappTransfer,
+]
+for resource_cls in resource_classes:
+    RESOURCES[resource_cls._resource] = resource_cls  # type: ignore

cuenca/resources/accounts.py

@@ -0,0 +1,14 @@
+from typing import ClassVar
+
+from pydantic.dataclasses import dataclass
+
+from .base import Queryable, Retrievable
+
+
+@dataclass
+class Account(Retrievable, Queryable):
+    _resource: ClassVar = 'accounts'
+
+    name: str  # legal name provided by institution
+    account_number: str
+    institution_name: str

cuenca/resources/api_keys.py

@@ -1,21 +1,19 @@
 import datetime as dt
 from typing import ClassVar, Optional, cast
 
+from cuenca_validations import ApiKeyQuery
 from pydantic.dataclasses import dataclass
 
 from ..http import session
-from ..validators import ApiKeyQuery
 from .base import Creatable, Queryable, Retrievable
 
 
 @dataclass
 class ApiKey(Creatable, Queryable, Retrievable):
-    _endpoint: ClassVar = '/api_keys'
+    _resource: ClassVar = 'api_keys'
     _query_params: ClassVar = ApiKeyQuery
 
-    id: str
     secret: str
-    created_at: dt.datetime
     deactivated_at: Optional[dt.datetime]
 
     @property
@@ -38,6 +36,6 @@ def deactivate(cls, api_key_id: str, minutes: int = 0) -> 'ApiKey':
         locking you out. The deactivated key is returned so that you have the
         exact deactivated_at time.
         """
-        url = cls._endpoint + f'/{api_key_id}'
+        url = cls._resource + f'/{api_key_id}'
         resp = session.delete(url, dict(minutes=minutes))
         return cast('ApiKey', cls._from_dict(resp))

cuenca/resources/balance_entries.py

@@ -0,0 +1,20 @@
+from typing import ClassVar
+
+from pydantic.dataclasses import dataclass
+
+from .base import Queryable, Retrievable
+from .resources import retrieve_uri
+
+
+@dataclass
+class BalanceEntry(Retrievable, Queryable):
+    _resource: ClassVar = 'balance_entries'
+
+    amount: int  # negative in the case of a debit
+    descriptor: str
+    rolling_balance: int
+    transaction_uri: str
+
+    @property  # type: ignore
+    def transaction(self):
+        return retrieve_uri(self.transaction_uri)

cuenca/resources/base.py

@@ -1,18 +1,27 @@
+import datetime as dt
 from dataclasses import asdict, dataclass, fields
 from typing import ClassVar, Dict, Generator, Optional, Union
 from urllib.parse import urlencode
 
+from cuenca_validations import (
+    QueryParams,
+    SantizedDict,
+    Status,
+    TransactionQuery,
+)
+
 from ..exc import MultipleResultsFound, NoResultFound
 from ..http import session
-from ..types import SantizedDict
-from ..validators import QueryParams
 
 
 @dataclass
 class Resource:
-    _endpoint: ClassVar[str]
+    _resource: ClassVar[str]
+
+    id: str
 
-    def __init__(self, **_):  # pragma no cover
+    # purely for MyPy
+    def __init__(self, **_):  # pragma: no cover
         ...
 
     @classmethod
@@ -38,7 +47,7 @@ def to_dict(self):
 class Retrievable(Resource):
     @classmethod
     def retrieve(cls, id: str) -> Resource:
-        resp = session.get(f'{cls._endpoint}/{id}')
+        resp = session.get(f'/{cls._resource}/{id}')
         return cls._from_dict(resp)
 
     def refresh(self):
@@ -50,17 +59,20 @@ def refresh(self):
 class Creatable(Resource):
     @classmethod
     def _create(cls, **data) -> Resource:
-        resp = session.post(cls._endpoint, data)
+        resp = session.post(cls._resource, data)
         return cls._from_dict(resp)
 
 
+@dataclass
 class Queryable(Resource):
     _query_params: ClassVar = QueryParams
 
+    created_at: dt.datetime
+
     @classmethod
     def one(cls, **query_params) -> Resource:
         q = cls._query_params(limit=2, **query_params)
-        resp = session.get(cls._endpoint, q.dict())
+        resp = session.get(cls._resource, q.dict())
         items = resp['items']
         len_items = len(items)
         if not len_items:
@@ -72,7 +84,7 @@ def one(cls, **query_params) -> Resource:
     @classmethod
     def first(cls, **query_params) -> Optional[Resource]:
         q = cls._query_params(limit=1, **query_params)
-        resp = session.get(cls._endpoint, q.dict())
+        resp = session.get(cls._resource, q.dict())
         try:
             item = resp['items'][0]
         except IndexError:
@@ -84,14 +96,23 @@ def first(cls, **query_params) -> Optional[Resource]:
     @classmethod
     def count(cls, **query_params) -> int:
         q = cls._query_params(count=True, **query_params)
-        resp = session.get(cls._endpoint, q.dict())
+        resp = session.get(cls._resource, q.dict())
         return resp['count']
 
     @classmethod
     def all(cls, **query_params) -> Generator[Resource, None, None]:
         q = cls._query_params(**query_params)
-        next_page_url = f'{cls._endpoint}?{urlencode(q.dict())}'
+        next_page_url = f'{cls._resource}?{urlencode(q.dict())}'
         while next_page_url:
             page = session.get(next_page_url)
             yield from (cls._from_dict(item) for item in page['items'])
             next_page_url = page['next_page_url']
+
+
+@dataclass
+class Transaction(Retrievable, Queryable):
+    _query_params: ClassVar = TransactionQuery
+
+    amount: int  # in centavos
+    status: Status
+    descriptor: str  # how it appears for the customer

cuenca/resources/commissions.py

@@ -0,0 +1,12 @@
+from typing import ClassVar, Optional
+
+from pydantic.dataclasses import dataclass
+
+from .base import Transaction
+
+
+@dataclass
+class Commission(Transaction):
+    _resource: ClassVar = 'commissions'
+
+    related_transaction_uri: Optional[str]

cuenca/resources/deposits.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import ClassVar, Optional, cast
+
+from cuenca_validations.types import DepositNetwork
+
+from .accounts import Account
+from .base import Transaction
+from .resources import retrieve_uri
+
+
+@dataclass
+class Deposit(Transaction):
+    _resource: ClassVar = 'deposits'
+
+    network: DepositNetwork
+    source_uri: Optional[str]
+    tracking_key: Optional[str]  # clave rastreo if network is SPEI
+
+    @property  # type: ignore
+    def source(self) -> Optional[Account]:
+        if self.source_uri is None:  # cash deposit
+            acct = None
+        else:
+            acct = cast(Account, retrieve_uri(self.source_uri))
+        return acct

cuenca/resources/resources.py

@@ -0,0 +1,15 @@
+import re
+from typing import Dict, cast
+
+from .base import Retrievable
+
+ENDPOINT_RE = re.compile(r'.*/(?P<resource>[a-z]+)/(?P<id>.+)$')
+RESOURCES: Dict[str, Retrievable] = {}  # set in ./__init__.py after imports
+
+
+def retrieve_uri(uri: str) -> Retrievable:
+    m = ENDPOINT_RE.match(uri)
+    if not m:
+        raise ValueError(f'uri is not a valid format: {uri}')
+    resource, id_ = m.groups()
+    return cast(Retrievable, RESOURCES[resource].retrieve(id_))