IMP address: allow passing type + email, expose parent_id

shopinvader/services/address.py

@@ -34,8 +34,6 @@ def search(self, **params):
     # pylint: disable=W8106
     def create(self, **params):
         params["parent_id"] = self.partner.id
-        if not params.get("type"):
-            params["type"] = "other"
         partner = self.env["res.partner"].create(self._prepare_params(params))
         self._post_create(partner)
         return self.search()
@@ -70,12 +68,14 @@ def _validator_search(self):
 
     def _validator_create(self):
         res = {
+            "type": {"type": "string", "default": "other"},
             "name": {"type": "string", "required": True},
             "street": {"type": "string", "required": True, "empty": False},
             "street2": {"type": "string", "nullable": True},
             "zip": {"type": "string", "required": True, "empty": False},
             "city": {"type": "string", "required": True, "empty": False},
             "phone": {"type": "string", "nullable": True, "empty": False},
+            "email": {"type": "string", "required": False, "nullable": True},
             "state": {
                 "type": "dict",
                 "schema": {
@@ -145,6 +145,8 @@ def _get_base_search_domain(self):
     def _json_parser(self):
         res = [
             "id",
+            ("parent_id", lambda rec, fname: rec.parent_id.id),
+            "type",
             "display_name",
             "name",
             "ref",
@@ -153,6 +155,7 @@ def _json_parser(self):
             "zip",
             "city",
             "phone",
+            "email",
             "function",
             "opt_in",
             "is_blacklisted:opt_out",

shopinvader/services/customer.py

@@ -45,6 +45,9 @@ def _validator_sign_in(self):
     def _validator_create(self):
         address = self.component(usage="addresses")
         schema = address._validator_create()
+        exclude_keys = ["type"]
+        for key in exclude_keys:
+            schema.pop(key, None)
         schema.update(
             {
                 "email": {"type": "string", "required": True},

shopinvader/tests/test_address.py

@@ -7,6 +7,21 @@
 from .common import CommonCase
 
 
+def _check_partner_data(self, partner, data, skip_keys=None):
+    compare_data = {}
+    skip_keys = skip_keys or ("external_id", "partner_email")
+    for key, value in data.items():
+        odoo_key = key
+        if key in skip_keys:
+            continue
+        elif key in ("country", "state", "title", "industry_id"):
+            value = value["id"]
+        if key in ("country", "state"):
+            odoo_key = key + "_id"
+        compare_data[odoo_key] = value
+    self.assertRecordValues(partner, [compare_data])
+
+
 class CommonAddressCase(CommonCase):
     @classmethod
     def setUpClass(cls):
@@ -28,45 +43,50 @@ def setUp(self, *args, **kwargs):
         with self.work_on_services(partner=self.partner) as work:
             self.address_service = work.component(usage="addresses")
 
-    def check_data(cls, address, data):
-        for key in data:
-            if key == "partner_email":
-                continue
-            elif key == "country":
-                cls.assertEqual(address.country_id.id, data[key]["id"])
-            else:
-                cls.assertEqual(address[key], data[key])
+    def check_data(self, address, data):
+        _check_partner_data(self, address, data)
 
 
 class AddressTestCase(object):
-    def test_add_address(self):
-        address_ids = [
+    def _test_create_address(self, params, expected):
+        existing = [
             address["id"] for address in self.address_service.search()["data"]
         ]
-        address_list = self.address_service.dispatch(
-            "create", params=self.address_params
-        )["data"]
-        for address in address_list:
-            if address["id"] not in address_ids:
-                created_address = address
-        self.assertIsNotNone(created_address)
-        address = self.env["res.partner"].browse(created_address["id"])
-        self.assertEqual(address.parent_id, self.partner)
-        self.check_data(address, self.address_params)
+        address_list = self.address_service.dispatch("create", params=params)[
+            "data"
+        ]
+        created_id = [
+            address["id"]
+            for address in address_list
+            if address["id"] not in existing
+        ][0]
+        address = self.env["res.partner"].browse(created_id)
+        self.check_data(address, expected)
+
+    def test_create_address(self):
+        # no email, verify defaults
+        params = dict(self.address_params, parent_id=self.partner.id)
+        # type defaults to `other`
+        expected = dict(params, type="other")
+        self._test_create_address(params, expected)
+        # pass email and type
+        params = dict(params, email="[email protected]", type="invoice")
+        expected = dict(params)
+        self._test_create_address(params, expected)
+
+    def _test_update_address(self, address_id, params, expected):
+        self.address_service.dispatch("update", address_id, params=params)
+        address = self.env["res.partner"].browse(address_id)
+        self.check_data(address, expected)
 
     def test_update_address(self):
-        params = self.address_params
-        self.address_service.dispatch("update", self.address.id, params=params)
-        self.assertEqual(self.address.parent_id, self.partner)
-        self.check_data(self.address, params)
-
-    # TODO MIGRATE
-    #    def test_update_main_address(self):
-    #        params = self.address_params
-    #        params['id'] = self.partner.id
-    #        self.address_service.update(params)
-    #        self.check_data(self.partner, params)
-    #
+        params = dict(self.address_params, parent_id=self.partner.id)
+        expected = dict(params)
+        self._test_update_address(self.address.id, params, expected)
+        params = dict(params, email="[email protected]", type="contact")
+        # "contact" type get the address from the parent
+        expected = dict(params, street=self.partner.street)
+        self._test_update_address(self.address.id, params, expected)
 
     def test_read_address_profile(self):
         res = self.address_service.dispatch(

shopinvader/tests/test_customer.py

@@ -5,6 +5,7 @@
 import logging
 
 from .common import CommonCase
+from .test_address import _check_partner_data
 
 _logger = logging.getLogger(__name__)
 
@@ -29,13 +30,7 @@ def setUp(self, *args, **kwargs):
             self.address_service = work.component(usage="addresses")
 
     def _test_partner_data(self, partner, data):
-        for key in data:
-            if key == "external_id":
-                continue
-            elif key == "country":
-                self.assertEqual(partner.country_id.id, data[key]["id"])
-            else:
-                self.assertEqual(partner[key], data[key])
+        _check_partner_data(self, partner, data)
 
 
 class TestCustomer(TestCustomerCommon):