SDK-1458: Add support for multiple documents

Author: MrBurtyyy

yoti_python_sdk/doc_scan/client.py

@@ -15,6 +15,7 @@
 from yoti_python_sdk.http import SignedRequest
 from yoti_python_sdk.utils import YotiEncoder
 from .exception import DocScanException
+from .support import SupportedDocumentsResponse
 
 
 class DocScanClient(object):
@@ -169,3 +170,26 @@ def delete_media_content(self, session_id, media_id):
         response = request.execute()
         if response.status_code < 200 or response.status_code >= 300:
             raise DocScanException("Failed to delete media content", response)
+
+    def get_supported_documents(self):
+        """
+        Retrieves a list of all of the currently supported documents
+
+        :return: the supported documents response
+        :rtype: SupportedDocumentsResponse
+        """
+        request = (
+            SignedRequest.builder()
+            .with_http_method("GET")
+            .with_pem_file(self.__key)
+            .with_base_url(self.__api_url)
+            .with_endpoint(Endpoint.get_supported_documents_path())
+            .build()
+        )
+
+        response = request.execute()
+        if response.status_code < 200 or response.status_code >= 300:
+            raise DocScanException("Failed to retrieve supported documents", response)
+
+        parsed = json.loads(response.text)
+        return SupportedDocumentsResponse(parsed)

yoti_python_sdk/doc_scan/constants.py

@@ -16,6 +16,12 @@
 CHECK_COMPLETION = "CHECK_COMPLETION"
 SESSION_COMPLETION = "SESSION_COMPLETION"
 
+ID_DOCUMENT = "ID_DOCUMENT"
+ORTHOGONAL_RESTRICTIONS = "ORTHOGONAL_RESTRICTIONS"
+DOCUMENT_RESTRICTIONS = "DOCUMENT_RESTRICTIONS"
+INCLUSION_WHITELIST = "WHITELIST"
+INCLUSION_BLACKLIST = "BLACKLIST"
+
 ALWAYS = "ALWAYS"
 FALLBACK = "FALLBACK"
 NEVER = "NEVER"

yoti_python_sdk/doc_scan/endpoint.py

@@ -20,3 +20,7 @@ def get_media_content_path(session_id, media_id):
     @staticmethod
     def delete_media_path(session_id, media_id):
         return Endpoint.get_media_content_path(session_id, media_id)
+
+    @staticmethod
+    def get_supported_documents_path():
+        return "/supported-documents"

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

@@ -0,0 +1,13 @@
+from .document_restrictions_filter import (
+    DocumentRestrictionBuilder,
+    DocumentRestrictionsFilterBuilder,
+)
+from .orthogonal_restrictions_filter import OrthogonalRestrictionsFilterBuilder
+from .required_id_document import RequiredIdDocumentBuilder
+
+__all__ = [
+    DocumentRestrictionsFilterBuilder,
+    DocumentRestrictionBuilder,
+    OrthogonalRestrictionsFilterBuilder,
+    RequiredIdDocumentBuilder,
+]

yoti_python_sdk/doc_scan/session/create/filter/document_filter.py

@@ -0,0 +1,17 @@
+from abc import ABCMeta
+
+from yoti_python_sdk.utils import YotiSerializable
+
+
+class DocumentFilter(YotiSerializable):
+    __metaclass__ = ABCMeta
+
+    def __init__(self, filter_type):
+        self.__filter_type = filter_type
+
+    @property
+    def type(self):
+        return self.__filter_type
+
+    def to_json(self):
+        return {"type": self.type}

yoti_python_sdk/doc_scan/session/create/filter/document_restrictions_filter.py

@@ -0,0 +1,154 @@
+from yoti_python_sdk.doc_scan.constants import (
+    DOCUMENT_RESTRICTIONS,
+    INCLUSION_BLACKLIST,
+    INCLUSION_WHITELIST,
+)
+from yoti_python_sdk.utils import YotiSerializable
+from .document_filter import DocumentFilter
+
+
+class DocumentRestriction(YotiSerializable):
+    def __init__(self, country_codes, document_types):
+        self.__country_codes = country_codes
+        self.__document_types = document_types
+
+    @property
+    def country_codes(self):
+        return self.__country_codes
+
+    @property
+    def document_types(self):
+        return self.__document_types
+
+    def to_json(self):
+        return {
+            "country_codes": self.country_codes,
+            "document_types": self.document_types,
+        }
+
+
+class DocumentRestrictionBuilder(object):
+    def __init__(self):
+        self.__country_codes = None
+        self.__document_types = None
+
+    def with_country_codes(self, country_codes):
+        """
+        Sets the list of country codes on the document restriction
+
+        :param country_codes: the list of country codes
+        :type country_codes: list[str]
+        :return: the builder
+        :rtype: DocumentRestrictionBuilder
+        """
+        self.__country_codes = country_codes
+        return self
+
+    def with_document_types(self, document_types):
+        """
+        Sets the list of document types on the document restriction
+
+        :param document_types: the list of document types
+        :type document_types: list[str]
+        :return: the builder
+        :rtype: DocumentRestrictionBuilder
+        """
+        self.__document_types = document_types
+        return self
+
+    def build(self):
+        """
+        Builds the document restriction using the values supplied to the builder
+
+        :return: the document restriction
+        :rtype: DocumentRestriction
+        """
+        return DocumentRestriction(self.__country_codes, self.__document_types)
+
+
+class DocumentRestrictionsFilter(DocumentFilter):
+    def __init__(self, inclusion, documents):
+        DocumentFilter.__init__(self, DOCUMENT_RESTRICTIONS)
+
+        self.__inclusion = inclusion
+        self.__documents = documents
+
+    @property
+    def inclusion(self):
+        return self.__inclusion
+
+    @property
+    def documents(self):
+        return self.__documents
+
+    def to_json(self):
+        parent = DocumentFilter.to_json(self)
+        parent["inclusion"] = self.inclusion
+        parent["documents"] = self.documents
+        return parent
+
+
+class DocumentRestrictionsFilterBuilder(object):
+    """
+    Builder used to create a document restrictions filter.
+
+    Example::
+
+        document_restriction = (DocumentRestrictionBuilder()
+                                .with_country_codes("GBR", "USA")
+                                .with_document_types("PASSPORT")
+                                .build())
+
+        filter = (DocumentRestrictionsFilterBuilder()
+                  .for_whitelist()
+                  .with_document_restriction(document_restriction)
+                  .build())
+    """
+
+    def __init__(self):
+        self.__inclusion = None
+        self.__documents = None
+
+    def for_whitelist(self):
+        """
+        Sets the inclusion to whitelist the document restrictions
+
+        :return: the builder
+        :rtype: DocumentRestrictionsFilterBuilder
+        """
+        self.__inclusion = INCLUSION_WHITELIST
+        return self
+
+    def for_blacklist(self):
+        """
+        Sets the inclusion to blacklist the document restrictions
+
+        :return: the builder
+        :rtype: DocumentRestrictionsFilterBuilder
+        """
+        self.__inclusion = INCLUSION_BLACKLIST
+        return self
+
+    def with_document_restriction(self, document_restriction):
+        """
+        Adds a document restriction to the filter
+
+        :param document_restriction: the document restriction
+        :type document_restriction: DocumentRestriction
+        :return: the builder
+        :rtype: DocumentRestrictionsFilterBuilder
+        """
+        if self.__documents is None:
+            self.__documents = []
+
+        self.__documents.append(document_restriction)
+        return self
+
+    def build(self):
+        """
+        Builds the document restrictions filter, using the supplied values
+
+        :return: the filter
+        :rtype: DocumentRestrictionsFilter
+        """
+        return DocumentRestrictionsFilter(self.__inclusion, self.__documents)