Add MQTT Messaging

agrirouter/auth/auth.py

@@ -12,10 +12,10 @@ class Authorization(EnvironmentalService):
     TOKEN_KEY = "token"
     ERROR_KEY = "error"
 
-    def __init__(self, *args, **kwargs):
-        self._public_key = kwargs.pop("public_key")
-        self._private_key = kwargs.pop("private_key")
-        super(Authorization, self).__init__(*args, **kwargs)
+    def __init__(self, env, public_key, private_key):
+        self._public_key = public_key
+        self._private_key = private_key
+        super(Authorization, self).__init__(env)
 
     def get_auth_request_url(self, parameters: AuthUrlParameter) -> str:
         auth_parameters = parameters.get_parameters()
@@ -34,4 +34,3 @@ def verify_auth_response(self, response, public_key=None):
     def _extract_query_params(query_params: str) -> dict:
         qp_pairs = parse_qs(query_params)
         return {k: v[0] for k, v in qp_pairs.items()}
-

agrirouter/auth/dto.py

@@ -0,0 +1,118 @@
+import json
+from typing import Union
+
+from agrirouter.messaging.exceptions import WrongFieldError
+
+
+class AuthorizationToken:
+    ACCOUNT = 'account'
+    REGISTRATION_CODE = 'regcode'
+    EXPIRES = 'expires'
+
+    def __init__(self,
+                 *,
+                 account: str = None,
+                 regcode: str = None,
+                 expires: str = None
+                 ):
+        self.account = account
+        self.regcode = regcode
+        self.expires = expires
+
+    def json_deserialize(self, data: Union[str, dict]) -> None:
+        data = data if type(data) == dict else json.loads(data)
+        for key, value in data.items():
+            if key == self.ACCOUNT:
+                self.account = value
+            elif key == self.REGISTRATION_CODE:
+                self.regcode = value
+            elif key == self.EXPIRES:
+                self.expires = value
+            else:
+                raise WrongFieldError(f"Unknown field {key} for AuthorizationToken class")
+
+    def get_account(self) -> str:
+        return self.account
+
+    def set_account(self, account: str) -> None:
+        self.account = account
+
+    def get_regcode(self) -> str:
+        return self.regcode
+
+    def set_regcode(self, regcode: str) -> None:
+        self.regcode = regcode
+
+    def get_expires(self) -> str:
+        return self.expires
+
+    def set_expires(self, expires: str) -> None:
+        self.expires = expires
+
+
+class AuthorizationResultUrl:
+    def __init__(self,
+                 *,
+                 state: str = None,
+                 signature: str = None,
+                 token: str = None,
+                 decoded_token: AuthorizationToken = None,
+                 error: str = None
+                 ):
+        self.state = state
+        self.signature = signature
+        self.token = token
+        self.decoded_token = decoded_token
+        self.error = error
+
+    def get_state(self) -> str:
+        return self.state
+
+    def set_state(self, state: str) -> None:
+        self.state = state
+
+    def get_signature(self) -> str:
+        return self.signature
+
+    def set_signature(self, signature: str) -> None:
+        self.signature = signature
+
+    def get_token(self) -> str:
+        return self.token
+
+    def set_token(self, token: str) -> None:
+        self.token = token
+
+    def get_error(self) -> str:
+        return self.error
+
+    def set_error(self, error: str) -> None:
+        self.error = error
+
+    def get_decoded_token(self) -> AuthorizationToken:
+        return self.decoded_token
+
+    def set_decoded_token(self, decoded_token: AuthorizationToken) -> None:
+        self.decoded_token = decoded_token
+
+
+class AuthorizationResult:
+    def __init__(self,
+                 *,
+                 authorization_url: str = None,
+                 state: str = None,
+                 ):
+        self.authorization_url = authorization_url
+        self.state = state
+
+    def get_authorization_url(self) -> str:
+        return self.authorization_url
+
+    def set_authorization_url(self, authorization_url: str) -> None:
+        self.authorization_url = authorization_url
+
+    def get_state(self) -> str:
+        return self.state
+
+    def set_state(self, state: str) -> None:
+        self.state = state

agrirouter/auth/response.py

@@ -5,6 +5,7 @@
 
 from cryptography.exceptions import InvalidSignature
 
+from agrirouter.auth.dto import AuthorizationToken, AuthorizationResultUrl
 from agrirouter.onboarding.signature import verify_signature
 
 
@@ -17,11 +18,11 @@ class AuthResponse:
     CRED_KEY = "credentials"
 
     def __init__(self, query_params):
-        self._state = query_params.get(self.STATE_KEY, None)
-        self._signature = query_params.get(self.SIGNATURE_KEY, None)
-        self._token = query_params.get(self.TOKEN_KEY, None)
-        self._error = query_params.get(self.ERROR_KEY, None)
-        self.is_successful = not bool(self._error)
+        self.state = query_params.get(self.STATE_KEY, None)
+        self.signature = query_params.get(self.SIGNATURE_KEY, None)
+        self.token = query_params.get(self.TOKEN_KEY, None)
+        self.error = query_params.get(self.ERROR_KEY, None)
+        self.is_successful = not bool(self.error)
         self._was_verified = False
         self._is_valid = False
 
@@ -43,33 +44,56 @@ def verify(self, public_key) -> None:
 
         :return:
         """
-        encoded_data = self._state + self._token
-        unquoted_signature = unquote(self._signature)
+        encoded_data = self.state + self.token
+        unquoted_signature = unquote(self.signature)
         encoded_signature = base64.b64decode(unquoted_signature.encode("utf-8"))
-        self._was_verified = True
+
         try:
             verify_signature(encoded_data, encoded_signature, public_key)
         except InvalidSignature:
             print("Response is invalid: invalid signature.")
             self._is_valid = False
+        finally:
+            self._was_verified = True
 
         self._is_valid = True
 
     @staticmethod
-    def decode_token(token: Union[str, bytes]) -> dict:
+    def decode_token(token: Union[str, bytes]) -> AuthorizationToken:
         if type(token) == str:
             token = token.encode("utf-8")
         base_64_decoded_token = base64.b64decode(token)
         decoded_token = base_64_decoded_token.decode("utf-8")
-        return json.loads(decoded_token)
-
-    def get_auth_result(self) -> dict:
-        if not self.is_successful:
-            return {self.ERROR_KEY: self._error}
-        decoded_token = self.decode_token(self._token)
-        return {
-            self.SIGNATURE_KEY: self._signature,
-            self.STATE_KEY: self._state,
-            self.TOKEN_KEY: self._token,
-            self.CRED_KEY: decoded_token
-        }
+
+        auth_token = AuthorizationToken()
+        auth_token.json_deserialize(json.loads(decoded_token))
+        return auth_token
+
+    def get_auth_result(self) -> AuthorizationResultUrl:
+        decoded_token = self.decode_token(self.token)
+
+        return AuthorizationResultUrl(
+            signature=self.signature,
+            state=self.state,
+            token=self.token,
+            decoded_token=decoded_token,
+            error=self.error
+        )
+
+    def get_signature(self):
+        return self.signature
+
+    def set_signature(self, signature):
+        self.signature = signature
+
+    def get_state(self):
+        return self.state
+
+    def set_state(self, state):
+        self.state = state
+
+    def get_token(self):
+        return self.token
+
+    def set_token(self, token):
+        self.token = token

agrirouter/environments/environments.py

@@ -6,7 +6,7 @@ class BaseEnvironment:
     _MQTT_URL_TEMPLATE = "ssl://{host}:{port}"
     _SECURED_ONBOARDING_AUTHORIZATION_LINK_TEMPLATE = \
         "/application/{application_id}/authorize" \
-        "?response_type={response_type}&state={state}&redirect_uri={redirect_uri}"
+        "?response_type={response_type}&state={state}"
 
     _ENV_BASE_URL = ""
     _API_PREFIX = ""
@@ -38,13 +38,13 @@ def get_revoke_url(self) -> str:
     def get_agrirouter_login_url(self) -> str:
         return self.get_base_url() + self._AGRIROUTER_LOGIN_URL
 
-    def get_secured_onboarding_authorization_url(self, application_id, response_type, state, redirect_uri) -> str:
-        return self.get_base_url() + self._SECURED_ONBOARDING_AUTHORIZATION_LINK_TEMPLATE.format(
+    def get_secured_onboarding_authorization_url(self, application_id, response_type, state, redirect_uri=None) -> str:
+        auth_url = self.get_base_url() + self._SECURED_ONBOARDING_AUTHORIZATION_LINK_TEMPLATE.format(
             application_id=application_id,
             response_type=response_type,
-            state=state,
-            redirect_uri=redirect_uri
+            state=state
         )
+        return auth_url + f"&redirect_uri={redirect_uri}" if redirect_uri is not None else auth_url
 
     def get_mqtt_server_url(self, host, port) -> str:
         return self._MQTT_URL_TEMPLATE.format(host=host, port=port)