add context functionality, signing string creation from req body for respondent gateway only requests

Author: dy-waltergrantward

dynata_rex/opportunity_registry.py

@@ -21,39 +21,36 @@
 
 class RegistryAPI:
 
+    _BASE_URL = 'https://registry.rex.dynata.com'
+
     def __init__(self,
                  access_key: str,
                  secret_key: str,
-                 base_url: str,
+                 base_url: str = _BASE_URL,
+                 default_ttl: int = 10,
                  shard_count: int = 1,
-                 current_shard: int = 1,
-                 signature_ttl: int = 10):
+                 current_shard: int = 1):
         """
         @access_key: liam access key for REX
         @secret_key: liam secret key for REX
-        @base_url  : url of Opportunity Registry
 
         # Optional
+        @base_url  : url of Opportunity Registry
         @shard_count  : number of total shards consuming Opportunity Registry
         @current_shard: curent shard
-        @signature_ttl: time to live for signature in seconds
+        @default_ttl: time to live for signature in seconds
         """
-        self.signature_ttl = signature_ttl
+        self.default_ttl = default_ttl
         self.make_request = RexRequest(access_key,
                                        secret_key,
-                                       default_ttl=signature_ttl)
-        self.base_url = self._format_base_url(base_url)
+                                       default_ttl=default_ttl)
+        self.base_url = base_url
 
         if current_shard > shard_count:
             raise InvalidShardException
         self.shard_count = shard_count
         self.current_shard = current_shard
 
-    def _format_base_url(self, base_url: str) -> str:
-        if base_url.startswith('http'):
-            return base_url
-        return f'https://{base_url}'
-
     def _get_opportunity(self, opportunity_id: int) -> dict:
         """Raw get opportunity"""
         endpoint = f"{self.base_url}/get-opportunity"

dynata_rex/respondent_gateway.py

@@ -14,7 +14,7 @@
 
 # Local Imports
 from dynata_rex.models import GatewayDispositionsEnum, GatewayStatusEnum
-from .signer import Signer
+from .signer import Signer, RexRequest
 from .exceptions import SignatureExpiredException, SignatureInvalidException
 
 
@@ -23,20 +23,31 @@ class RespondentGateway:
     Respondent Gateway interactions
     """
 
+    _BASE_URL = 'https://respondent.rex.dynata.com'
+
     def __init__(self,
                  access_key: str,
                  secret_key: str,
+                 base_url: str = _BASE_URL,
                  default_ttl: int = 10):
         """
         @access_key: liam access key for REX
         @secret_key: liam secret key for REX
 
         # Optional
+        @base_url: url of Gateway
         @ttl: time to live for signature in seconds
         """
         self.access_key = access_key
         self.secret_key = secret_key
         self.default_ttl = default_ttl
+        self.base_url = base_url
+
+        # MR for API requests
+        self.make_request = RexRequest(access_key,
+                                       secret_key,
+                                       default_ttl=default_ttl)
+        # Signer for signing/verifying URLs
         self.signer = Signer(access_key, secret_key, default_ttl=default_ttl)
 
     def create_respondent_url(self,
@@ -130,6 +141,11 @@ def verify_url(self,
                    secret_key: str = None) -> bool:
         """
         Verify a URL's signature matches for the given access and secret keys
+        @url: URL to verify
+
+        Optional
+        @access_key: liam access key for signing
+        @secret_key: liam secret key for signing
         """
         if access_key is None:
             access_key = self.access_key
@@ -150,6 +166,8 @@ def get_respondent_disposition(
             self, url) -> Union[GatewayDispositionsEnum, None]:
         """
         Get the disposition of a respondent from a URL
+
+        @url: URL to get disposition from
         """
         parsed = urlparse(url)
         query_parameters = dict(parse_qsl(parsed.query))
@@ -163,6 +181,8 @@ def get_respondent_status(
             self, url) -> Union[GatewayStatusEnum, None]:
         """
         Get the status of a respondent from a URL
+
+        @url: URL to get status from
         """
         parsed = urlparse(url)
         query_parameters = dict(parse_qsl(parsed.query))
@@ -174,3 +194,45 @@ def get_respondent_status(
             return GatewayStatusEnum((disposition, status))
         except KeyError:
             return None
+
+    def create_context(self, context_id: str, context_data: dict) -> int:
+        """
+        Create a context with the given context_id and context_data
+
+        @context_id: unique identifier for the context
+        @context_data: dictionary of context data ie:
+            {
+                "ctx": "a987dsglh34t435jkhsdg98u",
+                "gender": "male",
+                "postal_code": "60081",
+                "birth_date": "1959-10-05",
+                "country": "US"
+            }
+        """
+        endpoint = f"{self.base_url}/create-context"
+        data = {
+            "id": context_id,
+            "items": context_data
+        }
+        response = self.make_request.post(endpoint, data)
+        return response['id']
+
+    def expire_context(self, context_id: str) -> None:
+        """
+        Expire a context with the given context_id and account_id
+
+        @context_id: identifier for the context
+        """
+        endpoint = f"{self.base_url}/expire-context"
+        data = {"id": context_id}
+        res = self.make_request.post(endpoint, data)
+        return res if res else None
+
+    def get_context(self, context_id: int) -> dict:
+        """Get specific opportunity from SMOR
+
+        @context_id: identifier for the context
+        """
+        endpoint = f"{self.base_url}/get-context"
+        data = {"id": context_id}
+        return self.make_request.post(endpoint, data)

dynata_rex/signer.py

@@ -99,19 +99,11 @@ def _create_query_params_signing_string(self, parameters: dict) -> str:
         encoded_params = urlencode(sorted_params)
         return hashlib.sha256(encoded_params.encode('utf-8')).hexdigest()
 
-    def sign_rex_request(self,
-                         url: str,
-                         method: str,
-                         ttl: Union[int, None] = None) -> str:
-        if ttl is None:
-            ttl = self.default_ttl
-        expiration_date_str = self.create_expiration_date(ttl)
-        signing_string = self.signing_string
-        signature, _ = self.sign_from_expiration_date(self.access_key,
-                                                      self.secret_key,
-                                                      expiration_date_str,
-                                                      signing_string)
-        return signature
+    def _create_request_body_signing_string(self, request_body: str) -> str:
+        """SHA256 digest of the request body as a hexidecimal string
+        in lowercase
+        """
+        return hashlib.sha256(request_body.encode('utf-8')).hexdigest()
 
     def sign_query_params_from_expiration_date(self,
                                                parameters: dict,
@@ -159,17 +151,26 @@ def __init__(self, access_key, secret_key, default_ttl: int = 10):
         self.signer = Signer(access_key, secret_key)
         self.session = make_session()
 
-    def _signature(self, ttl: int = None) -> str:
+    def _signature(self, ttl: int = None, signing_string: str = None) -> str:
         if ttl is None:
             ttl = self.default_ttl
         return self.signer.sign_from_ttl(
             self.access_key,
             self.secret_key,
-            ttl
+            ttl,
+            signing_string=signing_string
         )
 
-    def _create_auth_headers(self, additional_headers={}):
-        signature, expiration = self._signature()
+    def _create_auth_headers(self, url, additional_headers={}, body=''):
+        signing_string = self.signer._create_request_body_signing_string(body)
+
+        # TODO: Hack alert: Registry doesn't like the sha256 body signing
+        # string yet
+        if 'https://registry' in url:
+            signing_string = ''
+        # END Hack alert
+
+        signature, expiration = self._signature(signing_string=signing_string)
         base = {
             'dynata-expiration': expiration,
             'dynata-access-key': self.access_key,
@@ -179,18 +180,18 @@ def _create_auth_headers(self, additional_headers={}):
 
     def dispatch(self,
                  url,
-                 data=None,
+                 data='',
                  method='GET') -> Union[dict, str]:
 
         additional_headers = {}
         if data:
             additional_headers = {'Content-type': 'application/json'}
             data = json.dumps(data)
 
-        headers = self._create_auth_headers(additional_headers)
+        headers = self._create_auth_headers(url, additional_headers, body=data)
 
         if not hasattr(self.session, method.lower()):
-            raise Exception('Invalid http method provided.')
+            raise AttributeError('Invalid http method provided.')
 
         method = getattr(self.session, method.lower())
 
@@ -201,7 +202,7 @@ def dispatch(self,
             if data:
                 logger.warning(data)
             logger.warning(res.__dict__)
-            raise RexServiceException(res.content)
+            raise RexServiceException(res.content.decode('utf-8'))
         try:
             return res.json()
         except json.decoder.JSONDecodeError as e: