Rewards + Bug Fixes

.gitignore

@@ -12,3 +12,5 @@ venv/*
 dist/
 
 .DS_Store
+
+build/

unit/__init__.py

@@ -1,9 +1,15 @@
 from unit.api.application_resource import ApplicationResource
+from unit.api.check_deposit_resource import CheckDepositResource
+from unit.api.batch_release_resource import BatchReleaseResource
+from unit.api.check_payment_resource import CheckPaymentResource
+from unit.api.check_stop_payment_resource import CheckStopPaymentResource
 from unit.api.customer_resource import CustomerResource
 from unit.api.account_resource import AccountResource
 from unit.api.card_resource import CardResource
 from unit.api.transaction_resource import TransactionResource
 from unit.api.payment_resource import PaymentResource
+from unit.api.repayment_resource import RepaymentResource
+from unit.api.ach_resource import AchResource
 from unit.api.statement_resource import StatementResource
 from unit.api.customerToken_resource import CustomerTokenResource
 from unit.api.counterparty_resource import CounterpartyResource
@@ -19,6 +25,7 @@
 from unit.api.authorization_resource import AuthorizationResource
 from unit.api.authorization_request_resource import AuthorizationRequestResource
 from unit.api.account_end_of_day_resource import AccountEndOfDayResource
+from unit.api.reward_resource import RewardResource
 
 __all__ = ["api", "models", "utils"]
 
@@ -31,6 +38,9 @@ def __init__(self, api_url, token):
         self.cards = CardResource(api_url, token)
         self.transactions = TransactionResource(api_url, token)
         self.payments = PaymentResource(api_url, token)
+        self.check_deposits = CheckDepositResource(api_url, token)
+        self.repayments = RepaymentResource(api_url, token)
+        self.ach = AchResource(api_url, token)
         self.statements = StatementResource(api_url, token)
         self.customerTokens = CustomerTokenResource(api_url, token)
         self.counterparty = CounterpartyResource(api_url, token)
@@ -46,3 +56,7 @@ def __init__(self, api_url, token):
         self.authorizations = AuthorizationResource(api_url, token)
         self.authorization_requests = AuthorizationRequestResource(api_url, token)
         self.account_end_of_day = AccountEndOfDayResource(api_url, token)
+        self.rewards = RewardResource(api_url, token)
+        self.batchRelease = BatchReleaseResource(api_url, token)
+        self.check_payments = CheckPaymentResource(api_url, token)
+        self.check_stop_payments = CheckStopPaymentResource(api_url, token)

unit/api/account_resource.py

@@ -7,7 +7,7 @@ def __init__(self, api_url, token):
         super().__init__(api_url, token)
         self.resource = "accounts"
 
-    def create(self, request: CreateDepositAccountRequest) -> Union[UnitResponse[AccountDTO], UnitError]:
+    def create(self, request: CreateAccountRequest) -> Union[UnitResponse[AccountDTO], UnitError]:
         payload = request.to_json_api()
         response = super().post(self.resource, payload)
         if super().is_20x(response.status_code):
@@ -33,6 +33,23 @@ def reopen_account(self, account_id: str, reason: str = "ByCustomer") -> Union[U
         else:
             return UnitError.from_json_api(response.json())
 
+    def freeze_account(self, request: FreezeAccountRequest) -> Union[UnitResponse[AccountDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().post(f"{self.resource}/{request.account_id}/freeze", payload)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[AccountDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())
+
+    def unfreeze_account(self, account_id: str) -> Union[UnitResponse[AccountDTO], UnitError]:
+        response = super().post(f"{self.resource}/{account_id}/unfreeze")
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[AccountDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())
+
     def get(self, account_id: str, include: Optional[str] = "") -> Union[UnitResponse[AccountDTO], UnitError]:
         response = super().get(f"{self.resource}/{account_id}", {"include": include})
         if super().is_20x(response.status_code):
@@ -52,7 +69,7 @@ def list(self, params: ListAccountParams = None) -> Union[UnitResponse[List[Acco
         else:
             return UnitError.from_json_api(response.json())
 
-    def update(self, request: PatchDepositAccountRequest) -> Union[UnitResponse[AccountDTO], UnitError]:
+    def update(self, request: PatchAccountRequest) -> Union[UnitResponse[AccountDTO], UnitError]:
         payload = request.to_json_api()
         response = super().patch(f"{self.resource}/{request.account_id}", payload)
         if super().is_20x(response.status_code):

unit/api/ach_resource.py

@@ -0,0 +1,34 @@
+from unit.api.base_resource import BaseResource
+from unit.models.payment import *
+from unit.models.codecs import DtoDecoder, split_json_api_single_response
+
+
+class AchResource(BaseResource):
+    def __init__(self, api_url, token):
+        super().__init__(api_url, token)
+        self.resource = "ach"
+
+    def simulate_transmit(self, request: SimulateTransmitAchRequest) -> Union[UnitResponse[PaymentDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().post(f"sandbox/{self.resource}/transmit", payload)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            # TODO Fix dto
+            _id, _type, attributes, relationships = split_json_api_single_response(data)
+            print("simulate_transmit")
+            print("data", data)
+            print("_id, _type, attributes, relationships", _id, _type, attributes, relationships)
+            return UnitResponse[SimulateAchPaymentDTO](SimulateAchPaymentDTO.from_json_api(_id, _type, attributes, relationships), None)
+        else:
+            return UnitError.from_json_api(response.json())
+
+    def simulate_clear(self, request: SimulateClearAchRequest) -> Union[UnitResponse[PaymentDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().post(f"sandbox/{self.resource}/clear", payload)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            # TODO Fix dto
+            _id, _type, attributes, relationships = split_json_api_single_response(data)
+            return UnitResponse[SimulateAchPaymentDTO](SimulateAchPaymentDTO.from_json_api(_id, _type, attributes, relationships), None)
+        else:
+            return UnitError.from_json_api(response.json())

unit/api/applicationForm_resource.py

@@ -10,7 +10,10 @@ def __init__(self, api_url, token):
 
     def create(self, request: CreateApplicationFormRequest) -> Union[UnitResponse[ApplicationFormDTO], UnitError]:
         payload = request.to_json_api()
-        response = super().post(self.resource, payload)
+        response = super().post(
+            self.resource,
+            payload
+        )
         if super().is_20x(response.status_code):
             data = response.json().get("data")
             return UnitResponse[ApplicationFormDTO](DtoDecoder.decode(data), None)

unit/api/application_resource.py

@@ -71,3 +71,20 @@ def update(self, request: PatchApplicationRequest) -> Union[UnitResponse[Applica
         else:
             return UnitError.from_json_api(response.json())
 
+    def approve_sb(self, request: ApproveApplicationSBRequest):
+        url = f"sandbox/{self.resource}/{request.application_id}/approve"
+
+        payload = request.to_json_api()
+        response = super().post(url, payload)
+
+        if response.ok:
+            data = response.json().get("data")
+            included = response.json().get("included")
+            return UnitResponse(data, included)
+            # TODO need DTOs for this response
+            # if data["type"] == "individualApplication":
+            #     return UnitResponse[IndividualApplicationDTO](DtoDecoder.decode(data), DtoDecoder.decode(included))
+            # else:
+            #     return UnitResponse[BusinessApplicationDTO](DtoDecoder.decode(data), DtoDecoder.decode(included))
+        else:
+            return UnitError.from_json_api(response.json())

unit/api/authorization_request_resource.py

@@ -44,3 +44,11 @@ def decline(self, request: DeclineAuthorizationRequest) -> Union[UnitResponse[Pu
         else:
             return UnitError.from_json_api(response.json())
 
+    def sandbox_simulate(self, request: SimulateAuthorizationRequest) -> Union[UnitResponse[PurchaseAuthorizationRequestDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().post(f"sandbox/{self.resource}/purchase", payload)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[PurchaseAuthorizationRequestDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())

unit/api/authorization_resource.py

@@ -25,4 +25,4 @@ def list(self, params: ListAuthorizationParams = None) -> Union[UnitResponse[Lis
             data = response.json().get("data")
             return UnitResponse[AuthorizationDTO](DtoDecoder.decode(data), None)
         else:
-            return UnitError.from_json_api(response.json())
+            return UnitError.from_json_api(response.json())

unit/api/base_resource.py

@@ -14,22 +14,22 @@ def __init__(self, api_url, token):
             "user-agent": "unit-python-sdk"
         }
 
-    def get(self, resource: str, params: Dict = None, headers: Optional[Dict[str, str]] = None):
-        return requests.get(f"{self.api_url}/{resource}", params=params, headers=self.__merge_headers(headers))
+    def get(self, resource: str, params: Dict = None, headers: Optional[Dict[str, str]] = None, timeout: float = None):
+        return requests.get(f"{self.api_url}/{resource}", params=params, headers=self.__merge_headers(headers), timeout=timeout)
 
-    def post(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
+    def post(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None, timeout: float = None):
         data = json.dumps(data, cls=UnitEncoder) if data is not None else None
-        return requests.post(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
+        return requests.post(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers), timeout=timeout)
 
-    def patch(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
+    def patch(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None, timeout: float = None):
         data = json.dumps(data, cls=UnitEncoder) if data is not None else None
-        return requests.patch(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
+        return requests.patch(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers), timeout=timeout)
 
-    def delete(self, resource: str, params: Dict = None, headers: Optional[Dict[str, str]] = None):
-        return requests.delete(f"{self.api_url}/{resource}", params=params, headers=self.__merge_headers(headers))
+    def delete(self, resource: str, params: Dict = None, headers: Optional[Dict[str, str]] = None, timeout: float = None):
+        return requests.delete(f"{self.api_url}/{resource}", params=params, headers=self.__merge_headers(headers), timeout=timeout)
 
-    def put(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
-        return requests.put(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
+    def put(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None, timeout: float = None):
+        return requests.put(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers), timeout=timeout)
 
     def __merge_headers(self, headers: Optional[Dict[str, str]] = None):
         if not headers:

unit/api/batch_release_resource.py

@@ -0,0 +1,17 @@
+from unit.api.base_resource import BaseResource
+from unit.models.batch_release import *
+from unit.models.codecs import DtoDecoder
+
+
+class BatchReleaseResource(BaseResource):
+    def __init__(self, api_url, token):
+        super().__init__(api_url, token)
+        self.resource = 'batch-releases'
+
+    def create(self, batch_releases: List[BatchReleaseDTO]) -> Union[UnitResponse[List[BatchReleaseDTO]], UnitError]:
+        response = super().post(self.resource, {"data": batch_releases})
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[List[BatchReleaseDTO]](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())

unit/api/check_deposit_resource.py

@@ -0,0 +1,31 @@
+from unit.api.base_resource import BaseResource
+from unit.models.check_deposit import *
+from unit.models.codecs import DtoDecoder
+from unit.models.transaction import *
+
+
+class CheckDepositResource(BaseResource):
+    def __init__(self, api_url, token):
+        super().__init__(api_url, token)
+        self.resource = "check-deposits"
+
+    def get(self, check_deposit_id: str) -> Union[UnitResponse[CheckDepositDTO], UnitError]:
+        params = {}
+        response = super().get(f"{self.resource}/{check_deposit_id}", params)
+        if response.status_code == 200:
+            data = response.json().get("data")
+            included = response.json().get("included")
+            return UnitResponse[TransactionDTO](DtoDecoder.decode(data), DtoDecoder.decode(included))
+        else:
+            return UnitError.from_json_api(response.json())
+
+    def list(self, params: ListTransactionParams = None) -> Union[UnitResponse[List[CheckDepositDTO]], UnitError]:
+        raise NotImplementedError()
+
+    def get_image(self, check_deposit_id: str, is_back_side: Optional[bool] = False) -> Union[UnitResponse[bytes], UnitError]:
+        params = {}
+        response = super().get(f"{self.resource}/{check_deposit_id}/{'back' if is_back_side else 'front'}", params)
+        if response.status_code == 200:
+            return UnitResponse[bytes](response.content, None)
+        else:
+            return UnitError.from_json_api(response.json())

unit/api/check_payment_resource.py

@@ -0,0 +1,45 @@
+from unit.api.base_resource import BaseResource
+from unit.models.authorization_request import *
+from unit.models.check_payment import ApproveCheckPaymentRequest, CheckPaymentDTO
+from unit.models.codecs import DtoDecoder
+from unit.models.payment import CreateCheckPaymentRequest
+
+
+class CheckPaymentResource(BaseResource):
+    def __init__(self, api_url, token):
+        super().__init__(api_url, token)
+        self.resource = "check-payments"
+
+    def get(self, check_payment_id: str) -> Union[UnitResponse[CheckPaymentDTO], UnitError]:
+        response = super().get(f"{self.resource}/{check_payment_id}")
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[check_payment_id](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())
+
+    def approve(self, request: ApproveCheckPaymentRequest) -> Union[UnitResponse[CheckPaymentDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().post(f"{self.resource}/{request.check_payment_id}/approve", payload)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[CheckPaymentDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())
+
+    def create(self, request: CreateCheckPaymentRequest, timeout: float = None) -> Union[UnitResponse[CheckPaymentDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().post(f"{self.resource}", payload, timeout=timeout)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[CheckPaymentDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())
+
+    def cancel(self, check_payment_id: str) -> Union[UnitResponse[CheckPaymentDTO], UnitError]:
+        response = super().post(f"{self.resource}/{check_payment_id}/cancel")
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[CheckPaymentDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())

unit/api/check_stop_payment_resource.py

@@ -0,0 +1,20 @@
+from unit.api.base_resource import BaseResource
+from unit.models.authorization_request import *
+from unit.models.check_stop_payment import CheckStopPaymentDTO
+from unit.models.codecs import DtoDecoder
+from unit.models.payment import CreateCheckStopPaymentRequest
+
+
+class CheckStopPaymentResource(BaseResource):
+    def __init__(self, api_url, token):
+        super().__init__(api_url, token)
+        self.resource = "stop-payments"
+
+    def create(self, request: CreateCheckStopPaymentRequest) -> Union[UnitResponse[CheckStopPaymentDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().post(f"{self.resource}", payload)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[CheckStopPaymentDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())

unit/api/customer_resource.py

@@ -38,3 +38,12 @@ def list(self, params: ListCustomerParams = None) -> Union[UnitResponse[List[Cus
             return UnitResponse[CustomerDTO](DtoDecoder.decode(data), None)
         else:
             return UnitError.from_json_api(response.json())
+
+    def archive(self, request: ArchiveCustomerRequest) -> Union[UnitResponse[CustomerDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().post(f"{self.resource}/{request.customer_id}/archive", payload)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[CustomerDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())

unit/api/payment_resource.py

@@ -1,16 +1,16 @@
 from unit.api.base_resource import BaseResource
 from unit.models.payment import *
-from unit.models.codecs import DtoDecoder
+from unit.models.codecs import DtoDecoder, split_json_api_single_response
 
 
 class PaymentResource(BaseResource):
     def __init__(self, api_url, token):
         super().__init__(api_url, token)
         self.resource = "payments"
 
-    def create(self, request: CreatePaymentRequest) -> Union[UnitResponse[PaymentDTO], UnitError]:
+    def create(self, request: CreatePaymentRequest, timeout: float = None) -> Union[UnitResponse[PaymentDTO], UnitError]:
         payload = request.to_json_api()
-        response = super().post(self.resource, payload)
+        response = super().post(self.resource, payload, timeout=timeout)
         if super().is_20x(response.status_code):
             data = response.json().get("data")
             return UnitResponse[PaymentDTO](DtoDecoder.decode(data), None)
@@ -45,3 +45,13 @@ def list(self, params: ListPaymentParams = None) -> Union[UnitResponse[List[Paym
         else:
             return UnitError.from_json_api(response.json())
 
+    def simulate_incoming_ach(self, request: SimulateIncomingAchRequest) -> Union[UnitResponse[PaymentDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().post(f"sandbox/{self.resource}", payload)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            # TODO Fix dto
+            _id, _type, attributes, relationships = split_json_api_single_response(data)
+            return UnitResponse[SimulateIncomingAchPaymentDTO](SimulateIncomingAchPaymentDTO.from_json_api(_id, _type, attributes, relationships), None)
+        else:
+            return UnitError.from_json_api(response.json())