SDK-1901 adding WATCHLIST_SCREENING check

Author: MichalMilewiczYoti

.gitignore

@@ -105,4 +105,4 @@ examples/yoti_example_django/*.pem
 examples/yoti_example_flask/*.pem
 
 .scannerwork
-.venv/
+.venv/

yoti_python_sdk/doc_scan/constants.py

@@ -36,3 +36,5 @@
 IGNORE = "IGNORE"
 
 PROOF_OF_ADDRESS = "PROOF_OF_ADDRESS"
+
+WATCHLIST_SCREENING_CHECK_TYPE = "WATCHLIST_SCREENING"

yoti_python_sdk/doc_scan/session/create/check/__init__.py

@@ -2,10 +2,13 @@
 from .document_comparison import RequestedIDDocumentComparisonCheckBuilder
 from .face_match import RequestedFaceMatchCheckBuilder
 from .liveness import RequestedLivenessCheckBuilder
+from .watchlist_screen import WatchlistScreeningCheckBuilder
+
 
 __all__ = [
     "RequestedDocumentAuthenticityCheckBuilder",
     "RequestedIDDocumentComparisonCheckBuilder",
     "RequestedFaceMatchCheckBuilder",
     "RequestedLivenessCheckBuilder",
+    "WatchlistScreeningCheckBuilder",
 ]

yoti_python_sdk/doc_scan/session/create/check/watchlist_screen.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from yoti_python_sdk.doc_scan import constants
+from yoti_python_sdk.utils import YotiSerializable, remove_null_values
+from .requested_check import RequestedCheck
+
+
+class WatchlistScreeningCheckConfig(YotiSerializable):
+    """
+    The configuration applied when creating a Watchlist screening check.
+    """
+
+    def __init__(self, manual_check, categories):
+        """
+        :param manual_check: the watchlist screening check manual_check eg. "NEVER"
+        :type type: str
+        :param categories: list of categories for watchlist screening check config
+        :type max_retries: list
+        """
+        self.__categories = categories
+        self.__manual_check = manual_check
+
+    @property
+    def manual_check(self):
+        """
+        Watchlist screening check manual check value
+
+        :return: str
+        """
+        return self.__manual_check
+
+    @property
+    def categories(self):
+        """
+        Watchlist screening check categories
+
+        :return: list
+        """
+        return self.__categories
+
+    def to_json(self):
+        return remove_null_values(
+            {"manual_check": self.manual_check, "categories": self.__categories}
+        )
+
+
+class WatchlistScreeningCheck(RequestedCheck):
+    """
+    Requests creation of a Watchlist screening check
+    """
+
+    def __init__(self, config):
+        """
+        :param config: the Watchlist screening check configuration
+        :type config: WatchlistScreeningCheckConfig
+        """
+        self.__config = config
+
+    @property
+    def type(self):
+        return constants.WATCHLIST_SCREENING_CHECK_TYPE
+
+    @property
+    def config(self):
+        return self.__config
+
+
+class WatchlistScreeningCheckBuilder(object):
+    """
+    Builder to assist creation of :class:`WatchlistScreeningCheck`
+    """
+
+    def __init__(self):
+        self.__categories = None
+        self.__manual_check = None
+
+    def with_categories(self, categories):
+        """
+        Sets the WatchListScreeningCheck categories
+
+        :return: the builder
+        :rtype: WatchlistScreeningCheckBuilder
+        """
+        self.__categories = categories
+
+        return self
+
+    def with_manual_check(self, manual_check):
+        """
+        Sets the WatchListScreeningCheck manual_check
+
+        :param liveness_type: the manual_check
+        :type liveness_type: str
+        :return: the builder
+        :rtype: WatchlistScreeningCheckBuilder
+        """
+        self.__manual_check = manual_check
+
+        return self
+
+    def build(self):
+        config = WatchlistScreeningCheckConfig(self.__manual_check, self.__categories or [])
+        return WatchlistScreeningCheck(config)

yoti_python_sdk/doc_scan/session/retrieve/check_response.py

@@ -184,3 +184,11 @@ class SupplementaryDocumentTextDataCheckResponse(CheckResponse):
     """
 
     pass
+
+
+class WatchlistScreeningCheckResponse(CheckResponse):
+    """
+    Represents a watchlist screening check for a given session
+    """
+
+    pass

yoti_python_sdk/doc_scan/session/retrieve/get_session_result.py

@@ -16,6 +16,7 @@
     LivenessCheckResponse,
     TextDataCheckResponse,
     SupplementaryDocumentTextDataCheckResponse,
+    WatchlistScreeningCheckResponse,
 )
 from .resource_container import ResourceContainer
 
@@ -80,6 +81,7 @@ def __parse_check(check):
             constants.ID_DOCUMENT_FACE_MATCH: FaceMatchCheckResponse,
             constants.ID_DOCUMENT_TEXT_DATA_CHECK: TextDataCheckResponse,
             constants.LIVENESS: LivenessCheckResponse,
+            constants.WATCHLIST_SCREENING_CHECK_TYPE:  WatchlistScreeningCheckResponse,
             constants.ID_DOCUMENT_COMPARISON: IDDocumentComparisonCheckResponse,
             constants.SUPPLEMENTARY_DOCUMENT_TEXT_DATA_CHECK: SupplementaryDocumentTextDataCheckResponse,
         }

yoti_python_sdk/tests/doc_scan/session/create/check/test_wathclist_check.py

@@ -0,0 +1,106 @@
+import json
+import unittest
+
+from yoti_python_sdk.doc_scan import constants
+from yoti_python_sdk.doc_scan.session.create.check import (
+    WatchlistScreeningCheckBuilder,
+)
+from yoti_python_sdk.doc_scan.session.create.check.requested_check import RequestedCheck
+from yoti_python_sdk.doc_scan.session.create.check.watchlist_screen import (
+    WatchlistScreeningCheck,
+    WatchlistScreeningCheckConfig,
+)
+from yoti_python_sdk.utils import YotiEncoder
+from yoti_python_sdk.doc_scan.constants import WATCHLIST_SCREENING_CHECK_TYPE
+
+
+class WatchlistScreeningCheckTest(unittest.TestCase):
+    def test_should_build_correctly_with_manual_check(self):
+        dummy_manual_check = "DUMMY_VALUE"
+
+        result = (
+            WatchlistScreeningCheckBuilder()
+            .with_manual_check(dummy_manual_check)
+            .build()
+        )
+
+        assert isinstance(result, RequestedCheck)
+        assert isinstance(result, WatchlistScreeningCheck)
+
+        assert result.type == constants.WATCHLIST_SCREENING_CHECK_TYPE
+        assert result.config.manual_check == dummy_manual_check
+        assert result.config.categories == []
+
+    def test_should_build_corretly_with_categories(self):
+        dummy_categories = ["FIRST", "SECOND"]
+
+        result = (
+            WatchlistScreeningCheckBuilder()
+            .with_categories(dummy_categories)
+            .build()
+        )
+
+        assert isinstance(result, RequestedCheck)
+        assert isinstance(result, WatchlistScreeningCheck)
+
+        assert result.type == constants.WATCHLIST_SCREENING_CHECK_TYPE
+        assert result.config.categories == dummy_categories
+        assert result.config.manual_check is None
+
+    def test_should_build_correctly_with_manual_check_and_categories(self):
+        dummy_manual_check = "DUMMY_VALUE"
+        dummy_categories = ["FIRST", "SECOND"]
+
+        result = (
+            WatchlistScreeningCheckBuilder()
+            .with_manual_check(dummy_manual_check)
+            .with_categories(dummy_categories)
+            .build()
+        )
+
+        assert isinstance(result, RequestedCheck)
+        assert isinstance(result, WatchlistScreeningCheck)
+
+        assert result.type == constants.WATCHLIST_SCREENING_CHECK_TYPE
+        assert result.config.manual_check == dummy_manual_check
+        assert result.config.categories == dummy_categories
+
+    def test_should_serialize_to_json_without_error(self):
+        another_dummy_manual_check = "DUMMY_VALUE"
+        another_dummy_categories = ["FIRST", "SECOND"]
+
+        result = (
+            WatchlistScreeningCheckBuilder()
+            .with_manual_check(another_dummy_manual_check)
+            .with_categories(another_dummy_categories)
+            .build()
+        )
+
+        s = json.dumps(result, cls=YotiEncoder)
+        assert s is not None and s != ""
+
+        result = (
+            WatchlistScreeningCheckBuilder()
+            .with_categories(another_dummy_categories)
+            .build()
+        )
+
+        s = json.dumps(result, cls=YotiEncoder)
+        assert s is not None and s != ""
+
+        s = json.loads(s)
+        assert s.get("type") == WATCHLIST_SCREENING_CHECK_TYPE
+        assert s.get("config") == {"categories": another_dummy_categories}
+
+        result = (
+            WatchlistScreeningCheckBuilder()
+            .with_manual_check(another_dummy_manual_check)
+            .build()
+        )
+
+        s = json.dumps(result, cls=YotiEncoder)
+        assert s is not None and s != ""
+
+        s = json.loads(s)
+        assert s.get("type") == WATCHLIST_SCREENING_CHECK_TYPE
+        assert s.get("config") == {"manual_check": "DUMMY_VALUE", "categories": []}

yoti_python_sdk/tests/test_anchor.py

@@ -3,6 +3,7 @@
 import pytz
 import time
 from datetime import datetime
+from datetime import timedelta
 
 import yoti_python_sdk
 from yoti_python_sdk import config
@@ -118,11 +119,10 @@ def test_processing_unknown_anchor_data():
         (anchor.value, anchor.anchor_type, anchor.sub_type) for anchor in anchors
     ]
 
-    expected_timestamp = datetime(2019, 3, 5, 10, 45, 11, 840037).replace(tzinfo=None)
-    actual_timestamp = anchors[0].signed_timestamp.astimezone(pytz.utc).replace(tzinfo=None)
+    expected_timestamp = datetime(2019, 3, 5, 10, 45, 11, 840037, tzinfo=pytz.utc)
+    actual_timestamp = anchors[0].signed_timestamp.astimezone(pytz.utc)
 
     assert expected_timestamp == actual_timestamp
-
     assert "document-registration-server" in [
         a.value for a in anchors[0].origin_server_certs.issuer
     ]