New fields to Customers (unit-finance#121)

* new fields to Customers
fix to AuthorizedUser from json api

* typo

* jwtSubject added

* added

Author: axshani

e2e_tests/customer_test.py

@@ -2,6 +2,7 @@
 import unittest
 from unit import Unit
 from unit.models.customer import *
+from unit.models.codecs import DtoDecoder
 
 token = os.environ.get('TOKEN')
 client = Unit("https://api.s.unit.sh", token)
@@ -39,3 +40,170 @@ def test_list_customers():
     response = client.customers.list()
     for customer in response.data:
         assert customer.type == "individualCustomer" or customer.type == "businessCustomer"
+
+
+def test_business_customer():
+    business_customer_api_response = {
+          "type": "businessCustomer",
+          "id": "1",
+          "attributes": {
+            "createdAt": "2020-05-10T12:28:37.698Z",
+            "name": "Pied Piper",
+            "address": {
+              "street": "5230 Newell Rd",
+              "street2": None,
+              "city": "Palo Alto",
+              "state": "CA",
+              "postalCode": "94303",
+              "country": "US"
+            },
+            "phone": {
+              "countryCode": "1",
+              "number": "1555555578"
+            },
+            "stateOfIncorporation": "DE",
+            "ein": "123456789",
+            "entityType": "Corporation",
+            "contact": {
+              "fullName": {
+                "first": "Richard",
+                "last": "Hendricks"
+              },
+              "email": "[email protected]",
+              "phone": {
+                "countryCode": "1",
+                "number": "1555555578"
+              }
+            },
+            "authorizedUsers": [
+              {
+                "fullName": {
+                  "first": "Jared",
+                  "last": "Dunn"
+                },
+                "email": "[email protected]",
+                "phone": {
+                  "countryCode": "1",
+                  "number": "1555555590"
+                }
+              },
+                {
+                    "fullName": {
+                        "first": "Jared",
+                        "last": "Dunn"
+                    },
+                    "email": "[email protected]",
+                    "phone": {
+                        "countryCode": "1",
+                        "number": "1555555590"
+                    }
+                },{
+                "fullName": {
+                  "first": "Jared",
+                  "last": "Dunn"
+                },
+                "email": "[email protected]",
+                "phone": {
+                  "countryCode": "1",
+                  "number": "1555555590"
+                }
+              }
+            ],
+            "status": "Active",
+            "tags": {
+              "userId": "106a75e9-de77-4e25-9561-faffe59d7814"
+            }
+          },
+          "relationships": {
+            "org": {
+              "data": {
+                "type": "org",
+                "id": "1"
+              }
+            },
+            "application": {
+              "data": {
+                "type": "businessApplication",
+                "id": "1"
+              }
+            }
+          }
+        }
+
+    id = business_customer_api_response["id"]
+    _type = business_customer_api_response["type"]
+
+    customer = DtoDecoder.decode(business_customer_api_response)
+
+    assert customer.id == id
+    assert customer.type == _type
+    assert customer.attributes["address"].street == "5230 Newell Rd"
+    assert customer.attributes["name"] == "Pied Piper"
+    assert customer.attributes["stateOfIncorporation"] == "DE"
+    assert customer.attributes["contact"].full_name.first == "Richard"
+    assert customer.attributes["authorizedUsers"][0].full_name.first == "Jared"
+    assert customer.attributes["status"] == "Active"
+
+def test_individual_customer():
+    individual_customer_api_response = {
+        "type": "individualCustomer",
+        "id": "8",
+        "attributes": {
+            "createdAt": "2020-05-12T19:41:04.123Z",
+            "fullName": {
+                "first": "Peter",
+                "last": "Parker"
+            },
+            "ssn": "721074426",
+            "address": {
+                "street": "20 Ingram St",
+                "street2": None,
+                "city": "Forest Hills",
+                "state": "NY",
+                "postalCode": "11375",
+                "country": "US"
+            },
+            "dateOfBirth": "2001-08-10",
+            "email": "[email protected]",
+            "phone": {
+                "countryCode": "1",
+                "number": "1555555578"
+            },
+            "authorizedUsers": [],
+            "status": "Active",
+            "tags": {
+                "userId": "106a75e9-de77-4e25-9561-faffe59d7814"
+            }
+        },
+        "relationships": {
+            "org": {
+                "data": {
+                    "type": "org",
+                    "id": "1"
+                }
+            },
+            "application": {
+                "data": {
+                    "type": "individualApplication",
+                    "id": "8"
+                }
+            }
+        }
+    }
+
+
+    id = individual_customer_api_response["id"]
+    _type = individual_customer_api_response["type"]
+
+    customer = DtoDecoder.decode(individual_customer_api_response)
+
+    assert customer.id == id
+    assert customer.type == _type
+    assert customer.attributes["address"].street == "20 Ingram St"
+    assert customer.attributes["fullName"].first == "Peter"
+    assert customer.attributes["fullName"].last == "Parker"
+    assert customer.attributes["email"] == "[email protected]"
+    assert customer.attributes["phone"].number == "1555555578"
+    assert customer.attributes["authorizedUsers"] == []
+    assert customer.attributes["status"] == "Active"
+

unit/models/__init__.py

@@ -178,17 +178,26 @@ def from_json_api(l: List):
 
 
 class AuthorizedUser(object):
-    def __init__(self, full_name: FullName, email: str, phone: Phone):
+    def __init__(self, full_name: FullName, email: str, phone: Phone, jwt_subject: Optional[str]):
         self.full_name = full_name
         self.email = email
         self.phone = phone
+        self.jwt_subject = jwt_subject
 
     @staticmethod
-    def from_json_api(l: List):
-        authorized_users = []
-        for data in l:
-            authorized_users.append(AuthorizedUser(data.get("fullName"), data.get("email"), data.get("phone")))
-        return authorized_users
+    def from_json_api(data):
+        if data is None:
+            return None
+
+        if data is []:
+            return []
+
+        if type(data) is dict:
+            return AuthorizedUser(FullName.from_json_api(data.get("fullName")), data.get("email"),
+                              Phone.from_json_api(data.get("phone")), data.get("jwtSubject"))
+
+        return [AuthorizedUser(FullName.from_json_api(d.get("fullName")), d.get("email"),
+                              Phone.from_json_api(d.get("phone")), d.get("jwtSubject")) for d in data]
 
 class WireCounterparty(object):
     def __init__(self, routing_number: str, account_number: str, name: str, address: Address):

unit/models/customer.py

@@ -4,15 +4,21 @@
 ArchiveReason = Literal["Inactive", "FraudACHActivity", "FraudCardActivity", "FraudCheckActivity",
                         "FraudApplicationHistory", "FraudAccountActivity", "FraudClientIdentified"]
 
+CustomerStatus = Literal["Active", "Archived"]
+
+
 class IndividualCustomerDTO(object):
     def __init__(self, id: str, created_at: datetime, full_name: FullName, date_of_birth: date, address: Address,
                  phone: Phone, email: str, ssn: Optional[str], passport: Optional[str], nationality: Optional[str],
-                 tags: Optional[Dict[str, str]], relationships: Optional[Dict[str, Relationship]]):
+                 tags: Optional[Dict[str, str]], relationships: Optional[Dict[str, Relationship]],
+                 authorized_users: Optional[List[AuthorizedUser]], status: CustomerStatus,
+                 archive_reason: Optional[ArchiveReason]):
         self.id = id
         self.type = 'individualCustomer'
         self.attributes = {"createdAt": created_at, "fullName": full_name, "dateOfBirth": date_of_birth,
                            "address": address, "phone": phone, "email": email, "ssn": ssn, "passport": passport,
-                           "nationality": nationality, "tags": tags}
+                           "status": status, "archiveReason": archive_reason, "nationality": nationality,
+                           "authorizedUsers": authorized_users, "tags": tags}
         self.relationships = relationships
 
     @staticmethod
@@ -22,20 +28,24 @@ def from_json_api(_id, _type, attributes, relationships):
             FullName.from_json_api(attributes["fullName"]), date_utils.to_date(attributes["dateOfBirth"]),
             Address.from_json_api(attributes["address"]), Phone.from_json_api(attributes["phone"]),
             attributes["email"], attributes.get("ssn"), attributes.get("passport"), attributes.get("nationality"),
-            attributes.get("tags"), relationships
+            attributes.get("tags"), relationships,
+            AuthorizedUser.from_json_api(attributes.get("authorizedUsers")), attributes.get("status"),
+            attributes.get("archiveReason")
         )
 
 
 class BusinessCustomerDTO(object):
     def __init__(self, id: str, created_at: datetime, name: str, address: Address, phone: Phone,
                  state_of_incorporation: str, ein: str, entity_type: EntityType, contact: BusinessContact,
-                 authorized_users: [AuthorizedUser], dba: Optional[str], tags: Optional[Dict[str, str]],
-                 relationships: Optional[Dict[str, Relationship]]):
+                 authorized_users: Optional[List[AuthorizedUser]], dba: Optional[str], tags: Optional[Dict[str, str]],
+                 relationships: Optional[Dict[str, Relationship]], status: CustomerStatus,
+                 archive_reason: Optional[ArchiveReason]):
         self.id = id
         self.type = 'businessCustomer'
         self.attributes = {"createdAt": created_at, "name": name, "address": address, "phone": phone,
                            "stateOfIncorporation": state_of_incorporation, "ein": ein, "entityType": entity_type,
-                           "contact": contact, "authorizedUsers": authorized_users, "dba": dba, "tags": tags}
+                           "contact": contact, "authorizedUsers": authorized_users, "dba": dba, "tags": tags,
+                           "status": status, "archiveReason": archive_reason}
         self.relationships = relationships
 
     @staticmethod
@@ -45,21 +55,25 @@ def from_json_api(_id, _type, attributes, relationships):
             Address.from_json_api(attributes["address"]), Phone.from_json_api(attributes["phone"]),
             attributes["stateOfIncorporation"], attributes["ein"], attributes["entityType"],
             BusinessContact.from_json_api(attributes["contact"]),
-            [AuthorizedUser.from_json_api(user) for user in attributes["authorizedUsers"]],
-            attributes.get("dba"), attributes.get("tags"), relationships)
+            AuthorizedUser.from_json_api(attributes.get("authorizedUsers")),
+            attributes.get("dba"), attributes.get("tags"), relationships, attributes.get("status"),
+            attributes.get("archiveReason"))
 
 CustomerDTO = Union[IndividualCustomerDTO, BusinessCustomerDTO]
 
 
 class PatchIndividualCustomerRequest(UnitRequest):
     def __init__(self, customer_id: str, address: Optional[Address] = None, phone: Optional[Phone] = None,
-                 email: Optional[str] = None, dba: Optional[str] = None, tags: Optional[Dict[str, str]] = None):
+                 email: Optional[str] = None, dba: Optional[str] = None, tags: Optional[Dict[str, str]] = None,
+                 jwt_subject: Optional[str] = None, authorized_users: Optional[AuthorizedUser] = None):
         self.customer_id = customer_id
         self.address = address
         self.phone = phone
         self.email = email
         self.dba = dba
         self.tags = tags
+        self.jwt_subject = jwt_subject
+        self.authorized_users = authorized_users
 
     def to_json_api(self) -> Dict:
         payload = {
@@ -84,6 +98,12 @@ def to_json_api(self) -> Dict:
         if self.tags:
             payload["data"]["attributes"]["tags"] = self.tags
 
+        if self.jwt_subject:
+            payload["data"]["attributes"]["jwtSubject"] = self.jwt_subject
+
+        if self.authorized_users:
+            payload["data"]["attributes"]["authorizedUsers"] = self.authorized_users
+
         return payload
 
     def __repr__(self):