VerificationAPI

sinch/core/clients/sinch_client_base.py

@@ -10,7 +10,7 @@
 class ClientBase(ABC):
     """
     Sinch abstract base class for concrete Sinch Client implementations.
-    By default this SDK provides two implementations - sync and async.
+    By default, this SDK provides two implementations - sync and async.
     Feel free to utilize any of them for you custom implementation.
     """
     def __init__(

sinch/core/clients/sinch_client_configuration.py

@@ -19,14 +19,19 @@ def __init__(
         logger=None,
         logger_name: str = None,
         disable_https=False,
-        connection_timeout=10
+        connection_timeout=10,
+        verification_key: str = None,
+        verification_secret: str = None
     ):
         self.key_id = key_id
         self.key_secret = key_secret
         self.project_id = project_id
+        self.verification_key = verification_key
+        self.verification_secret = verification_secret
         self.connection_timeout = connection_timeout
         self.auth_origin = "auth.sinch.com"
         self.numbers_origin = "numbers.api.sinch.com"
+        self.verification_origin = "verification.api.sinch.com"
         self._conversation_region = "eu"
         self._conversation_domain = ".conversation.api.sinch.com"
         self._sms_region = "us"

sinch/core/clients/sinch_client_sync.py

@@ -6,6 +6,7 @@
 from sinch.domains.numbers import Numbers
 from sinch.domains.conversation import Conversation
 from sinch.domains.sms import SMS
+from sinch.domains.verification import Verification
 
 
 class Client(ClientBase):
@@ -20,7 +21,9 @@ def __init__(
         key_secret,
         project_id,
         logger_name=None,
-        logger=None
+        logger=None,
+        verification_key: str = None,
+        verification_secret: str = None
     ):
         super().__init__(
             key_id=key_id,
@@ -36,9 +39,12 @@ def __init__(
             logger_name=logger_name,
             logger=logger,
             transport=HTTPTransportRequests(self),
-            token_manager=TokenManager(self)
+            token_manager=TokenManager(self),
+            verification_key=verification_key,
+            verification_secret=verification_secret
         )
         self.authentication = Authentication(self)
         self.numbers = Numbers(self)
         self.conversation = Conversation(self)
         self.sms = SMS(self)
+        self.verification = Verification(self)

sinch/core/enums.py

@@ -12,3 +12,4 @@ class HTTPMethods(Enum):
 class HTTPAuthentication(Enum):
     BASIC = "BASIC"
     OAUTH = "OAUTH"
+    SIGNED = "SIGNED"

sinch/core/ports/http_transport.py

@@ -26,6 +26,8 @@ def authenticate(self, endpoint, request_data):
                 "Authorization": f"Bearer {token}",
                 "Content-Type": "application/json"
             }
+        elif endpoint.HTTP_AUTHENTICATION == HTTPAuthentication.SIGNED.value:
+            pass
 
         return request_data
 

sinch/core/signature.py

@@ -0,0 +1,45 @@
+import hashlib
+import hmac
+import base64
+from datetime import datetime, timezone
+import json
+
+
+class Signature:
+    def __init__(self, sinch, http_method, request_data, request_uri):
+        self.sinch = sinch
+        self.http_method = http_method
+        self.content_type = 'application/json; charset=UTF-8'
+        self.request_data = request_data
+        self.signature_time = datetime.now(timezone.utc).isoformat()
+        self.request_uri = request_uri
+        self.authorization_signature = None
+
+    def get_http_headers_with_signature(self):
+        return {
+            "Content-Type": self.content_type,
+            "Authorization": (
+                f"Application {self.sinch.configuration.verification_key}:{self.authorization_signature}"
+            ),
+            "x-timestamp": self.signature_time
+        }
+
+    def calculate(self):
+        b64_encoded_application_secret = base64.b64decode(self.sinch.configuration.verification_secret)
+        encoded_verification_request = json.dumps(self.request_data).encode()
+        md5_verification_request = hashlib.md5(encoded_verification_request)
+        encoded_md5_to_base64_verification_request = base64.b64encode(md5_verification_request.digest())
+
+        request_timestamp = "x-timestamp:" + self.signature_time
+
+        string_to_sign = (
+            self.http_method + '\n'
+            + encoded_md5_to_base64_verification_request.decode() + '\n'
+            + self.content_type + '\n'
+            + request_timestamp + '\n'
+            + self.request_uri
+        )
+
+        self.authorization_signature = base64.b64encode(
+            hmac.new(b64_encoded_application_secret, string_to_sign.encode(), hashlib.sha256).digest()
+        ).decode()

sinch/domains/verification/__init__.py

@@ -0,0 +1,46 @@
+from sinch.domains.verification.endpoints.start_verification import StartVerificationEndpoint
+from sinch.domains.verification.models.responses import StartVerificationResponse
+from sinch.domains.verification.models.requests import StartVerificationRequest
+
+
+class Verification:
+    """
+    Documentation for the Verification API: https://developers.sinch.com/docs/verification
+    """
+    def __init__(self, sinch):
+        self._sinch = sinch
+
+    def start(
+        self,
+        identity: dict,
+        method: str,
+        reference: str = None,
+        custom: str = None,
+        flash_call_options: object = None
+    ) -> StartVerificationResponse:
+        return self._sinch.configuration.transport.request(
+            StartVerificationEndpoint(
+                request_data=StartVerificationRequest(
+                    identity=identity,
+                    method=method,
+                    reference=reference,
+                    custom=custom,
+                    flash_call_options=flash_call_options
+                )
+            )
+        )
+
+    def get_by_id(self):
+        pass
+
+    def get_by_identity(self):
+        pass
+
+    def get_by_reference(self):
+        pass
+
+    def report_using_id(self):
+        pass
+
+    def report_using_identity(self):
+        pass

sinch/domains/verification/endpoints/start_verification.py

@@ -0,0 +1,25 @@
+from sinch.core.models.http_response import HTTPResponse
+from sinch.domains.verification.endpoints.verification_endpoint import VerificationEndpoint
+from sinch.core.enums import HTTPAuthentication, HTTPMethods
+# from sinch.domains.conversation.models.contact.responses import CreateConversationContactResponse
+# from sinch.domains.conversation.models.contact.requests import CreateConversationContactRequest
+
+
+class StartVerificationEndpoint(VerificationEndpoint):
+    ENDPOINT_URL = "{origin}/verification/v1/verifications"
+    HTTP_METHOD = HTTPMethods.POST.value
+    HTTP_AUTHENTICATION = HTTPAuthentication.SIGNED.value
+
+    def __init__(self, request_data):
+        self.request_data = request_data
+
+    def build_url(self, sinch):
+        return self.ENDPOINT_URL.format(
+            origin=sinch.configuration.verification_origin,
+        )
+
+    def request_body(self):
+        return self.request_data.as_json()
+
+    def handle_response(self, response: HTTPResponse):
+        pass

sinch/domains/verification/endpoints/verification_endpoint.py

@@ -0,0 +1,13 @@
+from sinch.core.models.http_response import HTTPResponse
+from sinch.core.endpoint import HTTPEndpoint
+from sinch.domains.verification.exceptions import VerificationException
+
+
+class VerificationEndpoint(HTTPEndpoint):
+    def handle_response(self, response: HTTPResponse):
+        if response.status_code >= 400:
+            raise VerificationException(
+                message=response.body["error"].get("message"),
+                response=response,
+                is_from_server=True
+            )

sinch/domains/verification/exceptions.py

@@ -0,0 +1,5 @@
+from sinch.core.exceptions import SinchException
+
+
+class VerificationException(SinchException):
+    pass

sinch/domains/verification/models/requests.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+from sinch.core.models.base_model import SinchRequestBaseModel
+
+
+@dataclass
+class StartVerificationRequest(SinchRequestBaseModel):
+    identity: dict
+    method: str
+    reference: str
+    custom: str
+    flash_call_options: object

sinch/domains/verification/models/responses.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from typing import List
+
+from sinch.core.models.base_model import SinchBaseModel
+from sinch.domains.numbers.models import Number
+
+
+@dataclass
+class StartVerificationResponse(SinchBaseModel):
+    id: str
+    method: str
+    sms: dict
+    _links: list

tests/conftest.py

@@ -120,6 +120,16 @@ def origin_phone_number():
     return os.getenv("ORIGIN_PHONE_NUMBER")
 
 
+@pytest.fixture
+def verification_key():
+    return os.getenv("VERIFICATION_KEY")
+
+
+@pytest.fixture
+def verification_secret():
+    return os.getenv("VERIFICATION_SECRET")
+
+
 @pytest.fixture
 def app_id():
     return os.getenv("APP_ID")

tests/e2e/verification/test_start_verification.py

@@ -0,0 +1,21 @@
+from sinch.domains.verification.models.responses import StartVerificationResponse
+
+
+def test_start_verification(
+    sinch_client_sync,
+    phone_number,
+    verification_key,
+    verification_secret
+):
+    sinch_client_sync.configuration.verification_key = verification_key
+    sinch_client_sync.configuration.verification_secret = verification_secret
+
+    verification_response = sinch_client_sync.verification.start(
+        method="sms",
+        identity={
+            "type": "number",
+            "endpoint": phone_number
+        }
+    )
+
+    assert isinstance(verification_response, StartVerificationResponse)

tests/integration/test_request_signing.py

@@ -0,0 +1,12 @@
+from sinch.core.signature import Signature
+
+
+def test_verification_signature(sinch_client_sync):
+    signature = Signature(
+        sinch_client_sync,
+        http_method="POST",
+        request_data={},
+        request_uri="/verification/v1/verifications"
+    )
+    signature.calculate()
+    assert signature.authorization_signature