Fully working metrics request

Author: benmod

.gitignore

@@ -1,3 +1,4 @@
 *.pyc
 dist
-openpaygo.egg-info
+openpaygo.egg-info
+.DS_store

README.md

@@ -40,7 +40,7 @@ You can install the library by running `pip install openpaygo` or adding `openpa
 
 ## Getting Started - OpenPAYGO Token
 
-### Generating Tokens
+### Generating Tokens (Server Side)
 
 You can use the `generate_token()` function to generate an OpenPAYGOToken Token. The function takes the following parameters, and they should match the configuration in the hardware of the device: 
 
@@ -95,11 +95,11 @@ device.save() # We save the new count that we set for the device
 ```
 
 
-### Decoding Tokens
+### Decoding Tokens (Device Side)
 
 You can use the `decode_token()` function to generate an OpenPAYGOToken Token. The function takes the following parameters, and they should match the configuration in the hardware of the device: 
 
-- `token` (required): The token that was given by the user
+- `token` (required): The token that was given by the user, as a string
 - `secret_key` (required): The secret key of the device
 - `count` (required): The token count of the last valid token. When a device is new, this is 1. 
 - `used_counts` (optional): An array of recently used token counts, as returned by the function itself after the last valid token was decoded. This allows for handling unordered token entry. 
@@ -159,9 +159,23 @@ elif token_type == TokenType.INVALID:
 
 ## Getting Started - OpenPAYGO Metrics
 
+### Generating a Request (Device Side)
 
-You can use the `MetricsHandler` object to process your OpenPAYGO Metrics request from start to finish. It accepts the following initial inputs: 
-- `metrics_payload` (required): The OpenPAYGO Metrics payload, in a JSON string format. 
+You can use the `MetricsRequestHandler` object to create a new OpenPAYGO Metrics request from start to finish. It accepts the following initial inputs: 
+- `serial_number` (required): The serial number of the device
+- `data_format` (optional): The data format, provided as dictionnary matching the data format object specifications. 
+- `secret_key` (optional): The secret key provided as a string containing 32 hexadecimal characters. Required if `auth_method` is defined. 
+- `auth_method` (optional): One of the auth method contained in the `AuthMethod` class. 
+
+It provides the following methods:
+- `set_timestamp(timestamp)`: Used to set the `timestamp` of the request. 
+- `set_request_count(request_count)`: Used to set the `request_count` of the request. 
+
+
+### Handling a Request and Generating a Response (Server Side)
+
+You can use the `MetricsResponseHandler` object to process your OpenPAYGO Metrics request from start to finish. It accepts the following initial inputs: 
+- `metrics_payload` (required): The OpenPAYGO Metrics payload, as a string containing the JSON payload. 
 - `secret_key` (optional): The secret key provided as a string containing 32 hexadecimal characters
 - `data_format` (optional): The data format, provided as dictionnary matching the data format object specifications. 
 
@@ -223,6 +237,9 @@ def device_data():
 
 ## Changelog
 
+### 2023-10-09 - v0.3.0
+- Fix token generation issue
+
 ### 2023-10-03 - v0.2.0
 - First working version published on PyPI
 - Has support for OpenPAYGO Token

openpaygo/__init__.py

@@ -1,6 +1,9 @@
-from .encode_token import OpenPAYGOTokenEncoder
-from .decode_token import OpenPAYGOTokenDecoder
-from .shared import TokenType
+from .token_encode import OpenPAYGOTokenEncoder
+from .token_decode import OpenPAYGOTokenDecoder
+from .token_shared import TokenType
+from .metrics_request import MetricsRequestHandler
+from .metrics_response import MetricsResponseHandler
+from .metrics_shared import AuthMethod
 
 
 def generate_token(**kwargs):

openpaygo/metrics_request.py

@@ -0,0 +1,83 @@
+from .metrics_shared import OpenPAYGOMetricsShared
+import copy
+
+
+class MetricsRequestHandler(object):
+
+    def __init__(self, serial_number, data_format=None, secret_key=None, auth_method=None):
+        self.secret_key = secret_key
+        self.auth_method = auth_method
+        self.request_dict = {
+            'serial_number': serial_number,
+        }
+        self.data_format = data_format
+        if self.data_format:
+            if self.data_format.get('id'):
+                self.request_dict['data_format_id'] = data_format.get('id')
+            else:
+                self.request_dict['data_format'] = data_format
+        self.data = {}
+        self.historical_data = {}
+
+    def set_request_count(self, request_count):
+        self.request_dict['request_count'] = request_count
+
+    def set_timestamp(self, timestamp):
+        self.request_dict['timestamp'] = timestamp
+
+    def set_data(self, data):
+        self.data = data
+
+    def set_historical_data(self, historical_data):
+        if not self.data_format.get('historical_data_interval'):
+            for time_step in historical_data:
+                if not time_step.get('timestamp'):
+                    raise ValueError('Historical Data objects must have a time stamp if no historical_data_interval is defined.')
+        self.historical_data = historical_data
+
+    def get_simple_request_payload(self):
+        payload = self.get_simple_request_dict()
+        return OpenPAYGOMetricsShared.convert_to_metrics_json(payload)
+
+    def get_simple_request_dict(self):
+        simple_request = self.request_dict
+        simple_request['data'] = self.data
+        simple_request['historical_data'] = self.historical_data
+        # We prepare the auth
+        if self.auth_method:
+            simple_request['auth'] = OpenPAYGOMetricsShared.generate_request_signature_from_data(simple_request, self.auth_method, self.secret_key)
+        return simple_request
+
+    def get_condensed_request_payload(self):
+        payload = self.get_condensed_request_dict()
+        return OpenPAYGOMetricsShared.convert_to_metrics_json(payload)
+
+    def get_condensed_request_dict(self):
+        if not self.data_format:
+            raise ValueError('No data format provided for condensed request')
+        condensed_request = self.request_dict
+        condensed_request['data'] = []
+        condensed_request['historical_data'] = []
+        # We add the data
+        data_copy = copy.deepcopy(self.data)
+        for var in self.data_format.get('data_order'):
+            condensed_request['data'].append(data_copy.pop(var) if var in data_copy else None)
+        if len(data_copy) > 0:
+            raise ValueError('Additional variables not present in the data format: '+str(data_copy))
+        condensed_request['data'] = OpenPAYGOMetricsShared.remove_trailing_empty_elements(condensed_request['data'])
+        # We add the historical data
+        historical_data_copy = copy.deepcopy(self.historical_data)
+        for time_step in historical_data_copy:
+            time_step_data = []
+            for var in self.data_format.get('historical_data_order'):
+                time_step_data.append(time_step.pop(var) if var in time_step else None)
+            if len(time_step) > 0:
+                raise ValueError('Additional variables not present in the historical data format: '+str(time_step))
+            time_step_data = OpenPAYGOMetricsShared.remove_trailing_empty_elements(time_step_data)
+            condensed_request['historical_data'].append(time_step_data)
+        # We prepare the auth
+        if self.auth_method:
+            condensed_request['auth'] = OpenPAYGOMetricsShared.generate_request_signature_from_data(condensed_request, self.auth_method, self.secret_key)
+        # We replace the key names by the condensed ones
+        condensed_request = OpenPAYGOMetricsShared.convert_dict_keys_to_condensed(condensed_request)
+        return condensed_request

openpaygo/decode_metrics.py openpaygo/metrics_response.pyopenpaygo/decode_metrics.py renamed to openpaygo/metrics_response.py

@@ -1,7 +1,7 @@
 import json
 
 
-class MetricsHandler(object):
+class MetricsResponseHandler(object):
 
     def __init__(self, received_metrics, data_format=None, secret_key=None):
         self.received_metrics = received_metrics

openpaygo/metrics_shared.py

@@ -0,0 +1,98 @@
+import siphash
+import codecs
+import json
+
+
+class AuthMethod(object):
+    SIMPLE_AUTH = 'sa'
+    TIMESTAMP_AUTH = 'ta'
+    COUNTER_AUTH = 'ca'
+    DATA_AUTH = 'da'
+    RECURSIVE_DATA_AUTH = 'ra'
+
+
+class OpenPAYGOMetricsShared(object):
+
+    CONDENSED_KEY_NAMES = {
+        'serial_number': 'sn',
+        'timestamp': 'ts',
+        'auth': 'a',
+        'request_count': 'rc',
+        'data_collection_timestamp': 'dtc',
+        'data_format_id': 'df',
+        'data_format': 'dfo',
+        'data': 'd',
+        'historical_data': 'hd',
+        'accessories': 'acc'
+    }
+
+    @classmethod
+    def convert_dict_keys_to_condensed(cls, simple_dict):
+        condensed_dict = {}
+        for key in simple_dict:
+            if key in cls.CONDENSED_KEY_NAMES:
+                condensed_dict[cls.CONDENSED_KEY_NAMES[key]] = simple_dict[key]
+            else:
+                condensed_dict[key] = simple_dict[key]
+        return condensed_dict
+    
+    @classmethod
+    def remove_trailing_empty_elements(cls, list_with_empty):
+        while list_with_empty and list_with_empty[-1] is None:
+            list_with_empty.pop()
+        return list_with_empty
+
+    @classmethod
+    def convert_to_metrics_json(cls, data):
+        return json.dumps(data, separators=(',', ':'))
+    
+    @classmethod
+    def generate_request_signature_from_data(cls, data, auth_method, secret_key):
+        if auth_method == AuthMethod.SIMPLE_AUTH:
+            signature = cls.generate_hash_string(data.get('serial_number'), secret_key)
+        elif auth_method == AuthMethod.TIMESTAMP_AUTH:
+            if not data.get('timestamp', None):
+                raise ValueError('Timestamp is required for Timestamp Auth')
+            signature = cls.generate_hash_string(data.get('serial_number') + str(data.get('timestamp')), secret_key)
+        elif auth_method == AuthMethod.COUNTER_AUTH:
+            if not data.get('request_count', None):
+                raise ValueError('Request Count is required for Counter Auth')
+            signature = cls.generate_hash_string(data.get('serial_number') + str(data.get('request_count')), secret_key)
+        elif auth_method == AuthMethod.DATA_AUTH:
+            payload = data.get('serial_number')
+            if data.get('timestamp'):
+                payload += str(data.get('timestamp'))
+            elif data.get('request_count'):
+                payload += str(data.get('request_count'))
+            payload += cls.convert_to_metrics_json(data.get('data', []))
+            payload += cls.convert_to_metrics_json(data.get('historical_data', []))
+            signature = cls.generate_hash_string(payload, secret_key)
+        elif auth_method == AuthMethod.RECURSIVE_DATA_AUTH:
+            payload = data.get('serial_number')
+            payload = cls.generate_hash_string(payload, secret_key)
+            if data.get('timestamp'):
+                payload = cls.generate_hash_string(payload+str(data.get('timestamp')), secret_key)
+            elif data.get('request_count'):
+                payload = cls.generate_hash_string(payload+str(data.get('request_count')), secret_key)
+            payload = cls.generate_hash_string(payload+cls.convert_to_metrics_json(data.get('data', [])), secret_key)
+            for time_step_data in data.get('historical_data', []):
+                payload = cls.generate_hash_string(payload+cls.convert_to_metrics_json(time_step_data), secret_key)
+            signature = payload
+        else:
+            raise ValueError('Invalid Authentication Method')
+        return auth_method+signature
+
+
+    @classmethod
+    def generate_hash_string(cls, input_string, secret_key):
+        key = cls.load_secret_key_from_hex(secret_key)
+        hash = siphash.SipHash_2_4(key, codecs.encode(input_string, 'utf-8')).hash()
+        hash_string = '{:x}'.format(hash)
+        return hash_string
+
+    @classmethod
+    def load_secret_key_from_hex(cls, secret_key):
+        try:
+            return codecs.decode(secret_key, 'hex')
+        except Exception as e:
+            raise ValueError('The secret key provided is not correctly formatted, it should be 32 hexadecimal characters. ')

openpaygo/decode_token.py openpaygo/token_decode.pyopenpaygo/decode_token.py renamed to openpaygo/token_decode.py

@@ -1,5 +1,5 @@
-from .shared import OpenPAYGOTokenShared, TokenType
-from .shared_extended import OpenPAYGOTokenSharedExtended
+from .token_shared import OpenPAYGOTokenShared, TokenType
+from .token_shared_extended import OpenPAYGOTokenSharedExtended
 
 
 class OpenPAYGOTokenDecoder(object):
@@ -27,6 +27,7 @@ def decode_token(cls, token, secret_key, count, used_counts=None, starting_code=
                 extended_token = True
             else:
                 raise ValueError("Token is too long")
+        token = int(token)
         if not extended_token:
             value, token_type, count, updated_counts = cls.get_activation_value_count_and_type_from_token(token, starting_code, secret_key, count, restricted_digit_set, used_counts)
         else:

openpaygo/encode_token.py openpaygo/token_encode.pyopenpaygo/encode_token.py renamed to openpaygo/token_encode.py

@@ -1,5 +1,5 @@
-from .shared import OpenPAYGOTokenShared, TokenType
-from .shared_extended import OpenPAYGOTokenSharedExtended
+from .token_shared import OpenPAYGOTokenShared, TokenType
+from .token_shared_extended import OpenPAYGOTokenSharedExtended
 
 
 class OpenPAYGOTokenEncoder(object):