glaring 0.2__tar.gz → 0.3__tar.gz

glaring-0.3/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md glaring/version.txt dev.txt glaring/svs/wsdl/**/*
+recursive-exclude * test
+prune test*

{glaring-0.2/glaring.egg-info → glaring-0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glaring
-Version: 0.2
+Version: 0.3
 Summary: glaring
 Home-page: https://github.com/angry-penguins/glaring
 Author: dev

glaring-0.3/glaring/svs/async_rest.py

@@ -0,0 +1,431 @@
+from base64 import b64encode, b64decode
+from datetime import datetime
+from hashlib import sha1
+import json
+import os
+from threading import Lock
+from cryptography.hazmat.primitives import padding as sym_padding
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from deceit.async_api_client import ApiClient
+from raft.tasks import task
+from httpx import Client
+from pytz import utc
+from .rest import CsmCrypto, Stan
+
+
+class AsyncRestApi(ApiClient):
+    def __init__(self, base_url, auth_id, root_key, username, password, merchant_id, store_number=None):
+        super().__init__(base_url=base_url)
+        self.base_url = base_url
+        self.auth_id = auth_id
+        self.root_key = root_key
+        self.username = username
+        self.password = password
+        self.merchant_id = int(merchant_id)
+        self.root_crypto = CsmCrypto(root_key)
+        self.crypto = None
+        self.store_number = store_number
+        self.kyn = None
+        self.active_key = None
+        self.encrypted_auth_message = None
+        self.tvb = None
+        self.session_id = None
+
+    def build_csm(self, **kwargs):
+        csm = (
+            f'CSM(MCL/SMA RCV/Comdata ORG/{self.merchant_id} TVB/{self.tvb} TVA/d9b94d17828b2853 '
+            f'SID/{self.session_id} USR/{self.username} PWD/{self.password})'
+        )
+        return csm
+
+    def headers(self, **kwargs):
+        if not self.session_id:
+            return {}
+        csm = self.build_csm()
+        auth_message = self.crypto.encrypt(csm)
+        # this is stupid but important -- httpx wants header keys
+        # to be all lowercase.  if you set `Content-Type`
+        # and then somewhere else set `content-type`, you will
+        # get duplicated conent-types in your headers:  e.g.,
+        #   content-type: application/json, application/json
+        return {
+            'content-type': 'application/json',
+            'auth-id': self.auth_id,
+            'auth-message': auth_message,
+            'accept': 'application/json',
+        }
+
+    async def authenticate_root(self):
+        # Step 1: Get KEX from SVS
+        route = 'oltp-gift/authenticate/root'
+        headers = {
+            'Auth-Id': self.auth_id,
+            'Name':    'root',
+            'Key':     self.root_key,
+        }
+        response = await self.get(route, headers=headers, raw=True)
+        headers = response.headers
+        auth_message = headers.get('Auth-Message')
+        auth_message = self.root_crypto.decrypt(auth_message)
+        csm = self.parse_csm(auth_message)
+        self.kyn = csm.get('kyn')
+        self.active_key = csm.get('key')
+        self.crypto = CsmCrypto(self.active_key)
+        self.encrypted_auth_message = self.crypto.encrypt(auth_message)
+        return response
+
+    # async def presend(self, request):
+    #     body = request.content.decode()
+    #     if body:
+    #         body = json.loads(body)
+    #         body = json.dumps(body, indent=2)
+    #         self.log.info(f'presend: {request.method} {request.url}')
+    #         self.log.info('body=%s', body)
+    #     headers = request.headers
+    #     headers = json.dumps(dict(headers), indent=2)
+    #     self.log.info('headers=%s', headers)
+
+    async def postsend(self, request, response):
+        headers = response.headers
+        if 'Auth-Message' in headers:
+            if not self.crypto:
+                return
+            auth_message = headers.get('Auth-Message')
+            auth_message = self.crypto.decrypt(auth_message)
+            # print(f'received csm: {auth_message}')
+            csm = self.parse_csm(auth_message)
+            self.tvb = csm.get('tvb')
+
+    async def establish_session(self):
+        """
+        establishes a session with svs
+        """
+        route = f'oltp-gift/authenticate/{self.kyn}'
+        headers = {
+            'Auth-Id': self.auth_id,
+            'Name': self.kyn,
+            'Key': self.active_key,
+            'Auth-Message': self.encrypted_auth_message,
+        }
+        response = await self.get(route, headers=headers, raw=True)
+        headers = response.headers
+        auth_message = headers.get('Auth-Message')
+        auth_message = self.crypto.decrypt(auth_message)
+        # print(auth_message)
+        csm = self.parse_csm(auth_message)
+        self.tvb = csm.get('tvb')
+        self.session_id = csm.get('sid')
+        return response
+
+    async def post_it(self, route, payload, retry=False, retry_403=False):
+        """
+        we do a lot of generic processing for every call -- handle it here
+        instead.
+        """
+        payload = self.base_payload(**payload)
+        stan = payload['stan']
+        headers = None
+        if retry:
+            # only use the retry flag when recovering from a
+            # connect timeout
+            headers = { 'Retry': 'Y', }
+        response = await self.post(route, json_data=payload, headers=headers, raw=True)
+        if response.status_code == 403 and not retry_403:
+            # if we immediately get a 403 response, svs
+            # expects us to retry with the updated tvb
+            response = await self.post_it(route, payload, retry=retry, retry_403=True)
+        result = await self.handle_response(response)
+        if isinstance(result, dict):
+            result['stan'] = stan
+        return result
+
+    async def balance_inquiry(self, data, enhanced=False, retry=False):
+        """
+        performs a balance inquiry request to svs
+        expected payload:
+        {
+            'currency': 'USD',
+            'card_number': '600...2449',
+            'pin': '1234',
+            'invoice_number': '00000000',
+        }
+        """
+        route = 'oltp-gift/v1/balance-inquiry'
+        if enhanced:  # pragma: no cover
+            route = 'oltp-gift/v1/enhanced-balance-inquiry'
+        response = await self.post_it(route, data, retry=retry)
+        return response
+
+    def now(self):
+        return datetime.now(utc)
+
+    @classmethod
+    def lpad(cls, st, n=10):
+        if len(st) < n:
+            l = '0' * (n - len(st))
+            return f'{l}{st}'
+        return st
+
+    def base_payload(
+        self,
+        card_number: str = None,
+        pin:         str = '',
+        currency = 'USD',
+        amount = None,
+        invoice_number: str = '00000000',
+        stan: int = None,
+    ) -> dict:
+        """Builds the standard SVS request payload for card operations."""
+        now = self.now()
+        payload = {
+            'merchantId':    self.merchant_id,
+            'storeNumber':   self.lpad(self.store_number),
+            'invoiceNumber': self.lpad(invoice_number),
+            'stan':          Stan.get(card_number) if not stan else '',
+            'currencyCode':  currency,
+            'posTime':       now.strftime('%H:%M:%S'),
+            'posDate':       now.strftime('%Y-%m-%d'),
+        }
+        if card_number:
+            payload['cardNumber'] = card_number
+        if pin:
+            payload['pin'] = pin
+        if amount is not None:
+            payload['amount'] = amount
+        if stan is not None:
+            payload['stan'] = stan
+        return payload
+
+    @classmethod
+    def parse_csm(cls, csm):
+        """
+        Parses a CSM string into a dictionary.
+
+        Example input:
+            CSM(MCL/SMA RCV/Comdata ORG/10001095 TVB/abc TVA/def SID/xxx USR/u PWD/p)
+
+        Example output:
+            {
+                'MCL': 'SMA',
+                'RCV': 'Comdata',
+                'ORG': '10001095',
+                'TVB': 'abc',
+                'TVA': 'def',
+                'SID': 'xxx',
+                'USR': 'u',
+                'PWD': 'p'
+            }
+        """
+        if not csm.startswith('CSM(') or not csm.endswith(')'):  # pragma: no cover
+            raise ValueError('Invalid CSM format')
+        content = csm[4:-1]  # Strip off 'CSM(' and ')'
+        parts = content.split()
+        result = {}
+        for part in parts:
+            key, value = part.split('/', 1)
+            result[key.lower()] = value
+        return result
+
+    async def reload(self, data, retry=False, **kwargs):
+        """
+        reloads a card with svs
+        expected payload:
+        {
+            'currency': 'USD',
+            'card_number': '600...244',
+            'pin': '1234',
+            'amount': 25,
+            'invoice_number': '00000000',
+        }
+        """
+        route = 'oltp-gift/v1/reload'
+        response = await self.post_it(route, data, retry=retry)
+        return response
+
+    async def issue(self, data, retry=False, **kwargs):
+        """
+        initial activation of a **physical** gift card with a certain balance
+        """
+        route = 'oltp-gift/v1/issue'
+        response = await self.post_it(route, data, retry=retry)
+        return response
+
+    async def preissue(self, data, retry=False, **kwargs):
+        """
+        checks whether a card is eligible to be issued
+        """
+        route = 'oltp-gift/v1/pre-issue'
+        response = await self.post_it(route, data, retry=retry)
+        return response
+
+    async def preactivate(self, data, retry=False, **kwargs):  # pragma: no cover
+        """
+        checks whether a card is eligible to be activated
+        """
+        route = 'oltp-gift/v1/pre-activate'
+        response = await self.post_it(route, data, retry=retry)
+        return response
+
+    async def activate(self, data, retry=False, **kwargs):  # pragma: no cover
+        """
+        activates a fixed value (i.e., a conversion bin) card
+        """
+        route = 'oltp-gift/v1/activate'
+        response = await self.post_it(route, data, retry=retry)
+        return response
+
+    async def issue_virtual(self, data, retry=False, **kwargs):
+        """
+        issues a virtual gift card and pin from a pool allocated on svs
+
+        sample payload:
+        {
+            'invoice_number': '00004321',
+            'stan': 123456,
+            'amount': 12.50,
+        }
+        """
+        route = 'oltp-gift/v1/issue-virtual'
+        response = await self.post_it(route, data, retry=retry)
+        return response
+
+    async def redeem(self, data, retry=False, **kwargs):
+        """
+        This transaction is used when purchasing goods with a gift card.
+
+        sample payload:
+        {
+            'invoice_umber': '00004321',
+            'stan': 123456,
+            'amount': 12.50,
+            'card_number':'6006...123',
+            'pin':'0123',
+        }
+        """
+        route = 'oltp-gift/v1/redeem'
+        response = await self.post_it(route, data, retry=retry)
+        return response
+
+    async def preauth(self, data, retry=False, **kwargs):
+        """
+        Used to place a reserve on funds on a card for a fixed period of time or
+        until a completion message is approved. This message type should
+        always be followed by a Pre-Authorization Completion transaction.
+
+        The amount sent in the REQ should be an amount defined by the
+        client's POS. Amount of funds held is determined by:
+
+        If amount sent in the REQ is greater than the available funds,
+        the available funds on the card are held.
+
+        If the amount sent in the REQ is less than the available balance,
+        the requested amount is held.
+
+        sample payload:
+        {
+            'invoice_number': '00004321',
+            'stan':123456,
+            'amount': 12.50,
+            'card_number':'6006...123',
+            'pin':'0123',
+            'ssc':'0234',
+            'track1':'B6006...123^ ^4912110ABC',
+            'track2':'6006...123=491211012345678',
+            'auxiliaryData':'',
+            'cardType':''
+        }
+        """
+        route = 'oltp-gift/v1/pre-authorization'
+        response = await self.post_it(route, data, retry=retry, **kwargs)
+        return response
+
+    async def completion(self, data, retry=False, **kwargs):
+        """
+        This transaction is used remove the funds and holds placed by
+        the pre-authorization transaction These two transactions must
+        use the same STAN. In some cases, a pre-authorization will expire
+        before the transaction is completed or it will be necessary to
+        cancel out of a pre-authorization transaction. In order to release
+        the funds held by the pre-authorization, send a zero-dollar ($0)
+        Completion transaction.
+        sample payload:
+        {
+            'invoice_number': '00004321',
+            'stan': 123456,
+            'amount': 12.50,
+            'card_number':'6006...123',
+            'pin':'0123',
+        }
+        """
+        route = 'oltp-gift/v1/completion'
+        response = await self.post_it(route, data, retry=retry, **kwargs)
+        return response
+
+    async def cancel(self, data, retry=False, **kwargs):
+        """
+        Used to manually void or post void a previous transaction. It is
+        possible to cancel a transaction until it is
+        reconciled or reversed.
+        Notes:
+
+        * In order to cancel funds held by the pre-authorization,
+          send a zero-dollar ($0) Completion transaction.
+        * A cancellation is NOT a reversal.
+        * Cancel transactions can be sent for any original transaction
+          type except Cancels, Reversals, Balance Inquiry, and Pre-Authorizations.
+        * On a time out, resend the Cancel transaction up to 3 times,
+          with a delay between each attempt, until a response is received
+          to the Cancellation.
+
+        sample payload:
+        {
+            'invoice_number': '00004321',
+            'stan': 123456,
+            'amount': 12.50,
+            'card_number':'6006...123',
+            'pin':'0123',
+        }
+        """
+        route = 'oltp-gift/v1/cancel'
+        response = await self.post_it(route, data, retry=retry, **kwargs)
+        return response
+
+    async def reversal(self, data, retry=False, **kwargs):
+        """
+        Used to resolve situations arising from a POS timeout or
+        network outage. This includes the case when SVS is
+        switching authorizations to a third party and a
+        response code of 98 (timeout) is returned.
+        Notes:
+          * A reversal is not a cancellation.
+          * Reversal transactions can be sent for any original
+            transaction types, excluding Cancels, Reversals,
+            Balance Inquiry, and Pre-Authorizations.
+          * Do not send a Reversal transaction to back
+            out of a Pre-Authorization transaction when the
+            pre-authorization times out or must be cancelled.
+            In order to release the funds held by the pre-authorization,
+            send a zero-dollar ($0) Pre-Authorization Completion
+            transaction instead.
+          * When a response to the reversal transaction is not
+            received, the reversal should be retransmitted. There
+            should be a total of 3 reversal attempts with a delay
+            between each transaction.
+          * Another transaction from the same device should not
+            be sent to SVS until a response is received to the reversal.
+          * An Issue Virtual Card transaction, which has timed out
+            cannot be reversed when the card number is not known.
+            However, a reversal is automatically generated by the
+            client's system when the response was not received.
+        sample payload:
+        {
+            'invoice_number': '00004321',
+            'stan': 123456,
+            'amount': 12.50,
+            'card_number':'6006...123',
+            'pin':'0123',
+        }
+        """
+        route = 'oltp-gift/v1/reversal'
+        response = await self.post_it(route, data, retry=retry, **kwargs)
+        return response

glaring-0.3/glaring/svs/hello.py

@@ -0,0 +1,2 @@
+def hello():
+    return 'hello'

glaring-0.3/glaring/svs/response_codes.py

@@ -0,0 +1,43 @@
+response_code_map = {
+    '01': 'approval',
+    '02': 'inactive card',
+    '03': 'invalid card number',
+    '04': 'invalid transaction code',
+    '05': 'insufficient funds',
+    '06': 'no previous authorizations',
+    '07': 'invalid message',
+    '08': 'no card found',
+    '09': 'insufficient funds due to outstanding pre-authorization.',
+    '10': 'denial - no previous authorization',
+    '11': 'no authorization number',
+    '12': 'invalid authorization number',
+    '13': 'maximum single recharge exceeded',
+    '14': 'maximum working balance exceeded',
+    '15': 'host unavailable',
+    '16': 'invalid card status',
+    '17': 'unknown dealer/store code - special edit',
+    '18': 'maximum number of recharges exceeded',
+    '19': 'invalid card verification value (cvv) or secondary security code (ssc)',
+    '20': 'invalid pin number or pin locked',
+    '21': 'card already issued',
+    '22': 'card not issued',
+    '23': 'card already used',
+    '24': 'manual transaction not allowed',
+    '25': 'mag stripe read not valid',
+    '26': 'transaction type unknown',
+    '27': 'invalid tender type',
+    '28': 'invalid customer type',
+    '29': 'n/a',
+    '30': 'max number of redemption exceeded',
+    '31': 'invalid currency code',
+    '32': 'invalid server id (restaurant only - server id code is invalid)',
+    '33': 'frozen card or unknown',
+    '34': 'invalid amount (transaction amount does not match the pre-valued card dollar amount)',
+    '35': 'n/a',
+    '36': 'transaction rejected - invalid transaction promotion-wide or invalid for originating merchant and store. (dps)',
+    '37': 'transaction rejected - invalid merchant and store combination for promotion. (dps)',
+    '38': 'transaction rejected - exceeded maximum number of promotion cards allowed for a single pos transaction. (dps fraud control)',
+    '42': 'transaction declined - transaction amount less than the required minimum. (dps)',
+    '98': 'timeout/error communicating with third party authorizer',
+    '99': 'failure in retrieving data (enhance balance inquiry only)',
+}