mangono-addon-export_json 18.0.1.0.4__py3-none-any.whl → 19.0.1.0.1__py3-none-any.whl

odoo/addons/export_json/jsonifier/tests/test_get_parser.py

@@ -0,0 +1,436 @@
+# Copyright 2017 ACSONE SA/NV
+# Copyright 2022 Camptocamp SA (http://www.camptocamp.com)
+# Simone Orsi <simahawk@gmail.com>
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
+
+
+from odoo import tools
+from odoo.exceptions import UserError
+from odoo.tests.common import TransactionCase
+
+from ..models.utils import convert_simple_to_full_parser
+
+
+def jsonify_custom(self, field_name):
+    return "yeah!"
+
+
+class TestParser(TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        # disable tracking test suite wise
+        cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
+        cls.env.user.tz = "Europe/Brussels"
+        cls.partner = cls.env["res.partner"].create(
+            {
+                "name": "Akretion",
+                "country_id": cls.env.ref("base.fr").id,
+                "lang": "en_US",  # default
+                "category_id": [(0, 0, {"name": "Inovator"})],
+                "child_ids": [
+                    (
+                        0,
+                        0,
+                        {
+                            "name": "Sebatien Beau",
+                            "country_id": cls.env.ref("base.fr").id,
+                        },
+                    )
+                ],
+            }
+        )
+        Langs = cls.env["res.lang"].with_context(active_test=False)
+        cls.lang = Langs.search([("code", "=", "fr_FR")])
+        cls.lang.active = True
+        category = cls.env["res.partner.category"].create({"name": "name"})
+        cls.translated_target = f"name_{cls.lang.code}"
+        category.with_context(lang=cls.lang.code).write({"name": cls.translated_target})
+        cls.global_resolver = cls.env["ir.exports.resolver"].create(
+            {"python_code": "value['X'] = 'X'; result = value", "type": "global"}
+        )
+        cls.resolver = cls.env["ir.exports.resolver"].create(
+            {"python_code": "result = value + '_pidgin'", "type": "field"}
+        )
+        cls.category_export = cls.env["ir.exports"].create(
+            {
+                "global_resolver_id": cls.global_resolver.id,
+                "language_agnostic": True,
+                "export_fields": [
+                    (0, 0, {"name": "name"}),
+                    (
+                        0,
+                        0,
+                        {
+                            "name": "name",
+                            "target": f"name:{cls.translated_target}",
+                            "lang_id": cls.lang.id,
+                        },
+                    ),
+                    (
+                        0,
+                        0,
+                        {
+                            "name": "name",
+                            "target": "name:name_resolved",
+                            "resolver_id": cls.resolver.id,
+                        },
+                    ),
+                ],
+            }
+        )
+        cls.category = category.with_context(lang=None)
+        cls.category_lang = category.with_context(lang=cls.lang.code)
+
+    def test_getting_parser(self):
+        expected_parser = [
+            "name",
+            "active",
+            "partner_latitude",
+            "color",
+            ("category_id", ["name"]),
+            ("country_id", ["name", "code"]),
+            (
+                "child_ids",
+                [
+                    "name",
+                    "id",
+                    "email",
+                    ("country_id", ["name", "code"]),
+                    ("child_ids", ["name"]),
+                ],
+            ),
+            "lang",
+            "comment",
+        ]
+
+        exporter = self.env.ref("jsonifier.ir_exp_partner")
+        parser = exporter.get_json_parser()
+        expected_full_parser = convert_simple_to_full_parser(expected_parser)
+        self.assertEqual(parser, expected_full_parser)
+
+        # modify an ir.exports_line to put a target for a field
+        self.env.ref("jsonifier.category_id_name").write({"target": "category_id:category/name"})
+        expected_parser[4] = ("category_id:category", ["name"])
+        parser = exporter.get_json_parser()
+        expected_full_parser = convert_simple_to_full_parser(expected_parser)
+        self.assertEqual(parser, expected_full_parser)
+
+    def test_json_export(self):
+        # will allow to view large dict diff in case of regression
+        self.maxDiff = None
+        # Enforces TZ to validate the serialization result of a Datetime
+        parser = [
+            "lang",
+            "comment",
+            "partner_latitude",
+            "name",
+            "color",
+            (
+                "child_ids:children",
+                [
+                    ("child_ids:children", ["name"]),
+                    "email",
+                    ("country_id:country", ["code", "name"]),
+                    "name",
+                    "id",
+                ],
+            ),
+            ("country_id:country", ["code", "name"]),
+            "active",
+            ("category_id", ["name"]),
+            "create_date",
+        ]
+        # put our own create date to ease tests
+        self.env.cr.execute(
+            "update res_partner set create_date=%s where id=%s",
+            ("2019-10-31 14:39:49", self.partner.id),
+        )
+        expected_json = {
+            "lang": "en_US",
+            "comment": None,
+            "partner_latitude": 0.0,
+            "name": "Akretion",
+            "color": 0,
+            "country": {"code": "FR", "name": "France"},
+            "active": True,
+            "category_id": [{"name": "Inovator"}],
+            "children": [
+                {
+                    "id": self.partner.child_ids.id,
+                    "country": {"code": "FR", "name": "France"},
+                    "children": [],
+                    "name": "Sebatien Beau",
+                    "email": None,
+                }
+            ],
+            "create_date": "2019-10-31T14:39:49",
+        }
+        expected_json_with_fieldname = {
+            "_fieldname_lang": "Language",
+            "lang": "en_US",
+            "_fieldname_comment": "Notes",
+            "comment": None,
+            "partner_latitude": 0.0,
+            "_fieldname_name": "Name",
+            "name": "Akretion",
+            "_fieldname_color": "Color Index",
+            "color": 0,
+            "_fieldname_children": "Contact",
+            "children": [
+                {
+                    "_fieldname_children": "Contact",
+                    "children": [],
+                    "_fieldname_email": "Email",
+                    "email": None,
+                    "_fieldname_country": "Country",
+                    "country": {
+                        "_fieldname_code": "Country Code",
+                        "code": "FR",
+                        "_fieldname_name": "Country Name",
+                        "name": "France",
+                    },
+                    "_fieldname_name": "Name",
+                    "name": "Sebatien Beau",
+                    "_fieldname_id": "ID",
+                    "id": self.partner.child_ids.id,
+                }
+            ],
+            "_fieldname_country": "Country",
+            "country": {
+                "_fieldname_code": "Country Code",
+                "code": "FR",
+                "_fieldname_name": "Country Name",
+                "name": "France",
+            },
+            "_fieldname_active": "Active",
+            "active": True,
+            "_fieldname_category_id": "Tags",
+            "category_id": [{"_fieldname_name": "Name", "name": "Inovator"}],
+            "_fieldname_create_date": "Created on",
+            "_fieldname_partner_latitude": "Geo Latitude",
+            "create_date": "2019-10-31T14:39:49",
+        }
+        expected_json_with_fieldname = {
+            "_fieldname_lang": "Language",
+            "lang": "en_US",
+            "_fieldname_comment": "Notes",
+            "comment": None,
+            "_fieldname_partner_latitude": "Geo Latitude",
+            "_fieldname_name": "Name",
+            "name": "Akretion",
+            "_fieldname_color": "Color Index",
+            "color": 0,
+            "_fieldname_children": "Contact",
+            "children": [
+                {
+                    "_fieldname_children": "Contact",
+                    "children": [],
+                    "_fieldname_email": "Email",
+                    "email": None,
+                    "_fieldname_country": "Country",
+                    "country": {
+                        "_fieldname_code": "Country Code",
+                        "code": "FR",
+                        "_fieldname_name": "Country Name",
+                        "name": "France",
+                    },
+                    "_fieldname_name": "Name",
+                    "name": "Sebatien Beau",
+                    "_fieldname_id": "ID",
+                    "id": self.partner.child_ids.id,
+                }
+            ],
+            "_fieldname_country": "Country",
+            "country": {
+                "_fieldname_code": "Country Code",
+                "code": "FR",
+                "_fieldname_name": "Country Name",
+                "name": "France",
+            },
+            "_fieldname_active": "Active",
+            "active": True,
+            "_fieldname_category_id": "Tags",
+            "category_id": [{"_fieldname_name": "Name", "name": "Inovator"}],
+            "_fieldname_create_date": "Created on",
+            "create_date": "2019-10-31T14:39:49",
+            "partner_latitude": 0.0,
+        }
+        json_partner = self.partner.jsonify(parser)
+        self.assertDictEqual(json_partner[0], expected_json)
+        json_partner_with_fieldname = self.partner.jsonify(parser=parser, with_fieldname=True)
+        self.assertDictEqual(json_partner_with_fieldname[0], expected_json_with_fieldname)
+        # Check that only boolean fields have boolean values into json
+        # By default if a field is not set into Odoo, the value is always False
+        # This value is not the expected one into the json
+        self.partner.write({"child_ids": [(6, 0, [])], "active": False, "lang": False})
+        json_partner = self.partner.jsonify(parser)
+        expected_json["active"] = False
+        expected_json["lang"] = None
+        expected_json["children"] = []
+        self.assertDictEqual(json_partner[0], expected_json)
+
+    def test_one(self):
+        parser = [
+            "name",
+        ]
+        expected_json = {
+            "name": "Akretion",
+        }
+        json_partner = self.partner.jsonify(parser, one=True)
+        self.assertDictEqual(json_partner, expected_json)
+        # cannot call on multiple records
+        with self.assertRaises(ValueError) as err:
+            self.env["res.partner"].search([]).jsonify(parser, one=True)
+        self.assertIn("Expected singleton", str(err.exception))
+
+    def test_json_export_callable_parser(self):
+        self.partner.__class__.jsonify_custom = jsonify_custom
+        parser = [
+            # callable subparser
+            ("name", lambda rec, fname: rec[fname] + " rocks!"),
+            ("name:custom", "jsonify_custom"),
+            ("unknown_field", lambda rec, fname: "yeah again!"),
+        ]
+        expected_json = {
+            "name": "Akretion rocks!",
+            "custom": "yeah!",
+            "unknown_field": "yeah again!",
+        }
+        json_partner = self.partner.jsonify(parser)
+        self.assertDictEqual(json_partner[0], expected_json)
+        del self.partner.__class__.jsonify_custom
+
+    def test_full_parser(self):
+        parser = self.category_export.get_json_parser()
+        json = self.category.jsonify(parser)[0]
+        json_fr = self.category_lang.jsonify(parser)[0]
+
+        self.assertEqual(json, json_fr)  # starting from different languages should not change anything
+        self.assertEqual(json[self.translated_target], self.translated_target)
+        self.assertEqual(json["name_resolved"], "name_pidgin")  # field resolver
+        self.assertEqual(json["X"], "X")  # added by global resolver
+
+    def test_full_parser_resolver_json_key_override(self):
+        self.resolver.write({"python_code": """result = {"_json_key": "foo", "_value": record.id}"""})
+        parser = self.category_export.get_json_parser()
+        json = self.category.jsonify(parser)[0]
+        self.assertNotIn("name_resolved", json)
+        self.assertEqual(json["foo"], self.category.id)  # field resolver
+        self.assertEqual(json["X"], "X")  # added by global resolver
+
+    def test_simple_parser_translations(self):
+        """The simple parser result should depend on the context language."""
+        parser = ["name"]
+        json = self.category.jsonify(parser)[0]
+        json_fr = self.category_lang.jsonify(parser)[0]
+
+        self.assertEqual(json["name"], "name")
+        self.assertEqual(json_fr["name"], self.translated_target)
+
+    def test_simple_star_target_and_field_resolver(self):
+        """The simple parser result should depend on the context language."""
+        code = (
+            "is_number = field_type in ('integer', 'float');"
+            "ftype = 'NUMBER' if is_number else 'TEXT';"
+            "value = value if is_number else str(value);"
+            "result = {'Key': name, 'Value': value, 'Type': ftype, 'IsPublic': True}"
+        )
+        resolver = self.env["ir.exports.resolver"].create({"python_code": code})
+        lang_parser = [
+            {"target": "customTags=list", "name": "name", "resolver": resolver},
+            {"target": "customTags=list", "name": "id", "resolver": resolver},
+        ]
+        parser = {"language_agnostic": True, "langs": {False: lang_parser}}
+        expected_json = {
+            "customTags": [
+                {"Value": "name", "Key": "name", "Type": "TEXT", "IsPublic": True},
+                {
+                    "Value": self.category.id,
+                    "Key": "id",
+                    "Type": "NUMBER",
+                    "IsPublic": True,
+                },
+            ]
+        }
+
+        json = self.category.jsonify(parser)[0]
+        self.assertEqual(json, expected_json)
+
+    def test_simple_export_with_function(self):
+        self.category.__class__.jsonify_custom = jsonify_custom
+        export = self.env["ir.exports"].create(
+            {
+                "export_fields": [
+                    (0, 0, {"name": "name", "instance_method_name": "jsonify_custom"}),
+                ],
+            }
+        )
+
+        json = self.category.jsonify(export.get_json_parser())[0]
+        self.assertEqual(json, {"name": "yeah!"})
+
+    def test_export_relational_display_names(self):
+        """If we export a relational, we get its display_name in the json."""
+        parser = [
+            "state_id",
+            "country_id",
+            "category_id",
+            "user_ids",
+        ]
+        expected_json = {
+            "state_id": None,
+            "country_id": "France",
+            "category_id": ["Inovator"],
+            "user_ids": [],
+        }
+
+        json_partner = self.partner.jsonify(parser, one=True)
+
+        self.assertDictEqual(json_partner, expected_json)
+
+    def test_export_reference_display_names(self):
+        """Reference work the same as relational"""
+        menu = self.env.ref("base.menu_action_res_users")
+
+        json_menu = menu.jsonify(["action"], one=True)
+
+        self.assertDictEqual(json_menu, {"action": "Users"})
+
+    def test_bad_parsers_strict(self):
+        rec = self.category.with_context(jsonify_record_strict=True)
+        bad_field_name = ["Name"]
+        with self.assertRaises(KeyError):
+            rec.jsonify(bad_field_name, one=True)
+
+        bad_function_name = {"fields": [{"name": "name", "function": "notafunction"}]}
+        with self.assertRaises(UserError):
+            rec.jsonify(bad_function_name, one=True)
+
+        bad_subparser = {"fields": [({"name": "name"}, [{"name": "subparser_name"}])]}
+        with self.assertRaises(UserError):
+            rec.jsonify(bad_subparser, one=True)
+
+    def test_bad_parsers_fail_gracefully(self):
+        rec = self.category
+
+        # logging is disabled when testing as it makes too much noise
+        tools.config["test_enable"] = False
+
+        logger_name = "odoo.addons.jsonifier.models.models"
+        bad_field_name = ["Name"]
+        with self.assertLogs(logger=logger_name, level="WARNING") as capt:
+            rec.jsonify(bad_field_name, one=True)
+            self.assertIn("res.partner.category.Name not availabl", capt.output[0])
+
+        bad_function_name = {"fields": [{"name": "name", "function": "notafunction"}]}
+        with self.assertLogs(logger=logger_name, level="WARNING") as capt:
+            rec.jsonify(bad_function_name, one=True)
+            self.assertIn("res.partner.category.notafunction not available", capt.output[0])
+
+        bad_subparser = {"fields": [({"name": "name"}, [{"name": "subparser_name"}])]}
+        with self.assertLogs(logger=logger_name, level="WARNING") as capt:
+            rec.jsonify(bad_subparser, one=True)
+            self.assertIn("res.partner.category.name not relational", capt.output[0])
+
+        tools.config["test_enable"] = True

odoo/addons/export_json/jsonifier/tests/test_helpers.py

@@ -0,0 +1,45 @@
+# Copyright 2021 Camptocamp SA (https://www.camptocamp.com).
+# @author Iván Todorovich <ivan.todorovich@camptocamp.com>
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from odoo.tests.common import TransactionCase
+
+
+class TestJsonifyHelpers(TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
+        cls.partner = cls.env["res.partner"].create(
+            {
+                "name": "My Partner",
+            }
+        )
+        cls.children = cls.env["res.partner"].create(
+            [
+                {"parent_id": cls.partner.id, "name": "Child 1"},
+                {"parent_id": cls.partner.id, "name": "Child 2"},
+            ]
+        )
+
+    def test_helper_m2o_to_id(self):
+        child = self.children[0]
+        self.assertEqual(
+            child._jsonify_m2o_to_id("parent_id"),
+            child.parent_id.id,
+        )
+
+    def test_helper_m2m_to_ids(self):
+        self.assertEqual(
+            self.partner._jsonify_x2m_to_ids("child_ids"),
+            self.partner.child_ids.ids,
+        )
+
+    def test_helper_format_duration(self):
+        # partner_latitude is not intended for this, but it's a float field in core
+        # any float field does the trick here
+        self.partner.partner_latitude = 15.5
+        self.assertEqual(
+            self.partner._jsonify_format_duration("partner_latitude"),
+            "15:30",
+        )

odoo/addons/export_json/jsonifier/tests/test_ir_exports_line.py

@@ -0,0 +1,66 @@
+# Copyright 2017 ACSONE SA/NV
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
+
+from odoo.exceptions import ValidationError
+from odoo.tests.common import TransactionCase
+
+
+class TestIrExportsLine(TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.ir_export = cls.env.ref("jsonifier.ir_exp_partner")
+
+    def test_target_constrains(self):
+        ir_export_lines_model = self.env["ir.exports.line"]
+        with self.assertRaises(ValidationError):
+            # The field into the name must be also into the target
+            ir_export_lines_model.create(
+                {
+                    "export_id": self.ir_export.id,
+                    "name": "name",
+                    "target": "toto:my_target",
+                }
+            )
+        with self.assertRaises(ValidationError):
+            # The hierarchy into the target must be the same as the one into
+            # the name
+            ir_export_lines_model.create(
+                {
+                    "export_id": self.ir_export.id,
+                    "name": "child_ids/child_ids/name",
+                    "target": "child_ids:children/name",
+                }
+            )
+        with self.assertRaises(ValidationError):
+            # The hierarchy into the target must be the same as the one into
+            # the name and must contains the same fields as into the name
+            ir_export_lines_model.create(
+                {
+                    "export_id": self.ir_export.id,
+                    "name": "child_ids/child_ids/name",
+                    "target": "child_ids:children/category_id:category/name",
+                }
+            )
+        line = ir_export_lines_model.create(
+            {
+                "export_id": self.ir_export.id,
+                "name": "child_ids/child_ids/name",
+                "target": "child_ids:children/child_ids:children/name",
+            }
+        )
+        self.assertTrue(line)
+
+    def test_resolver_function_constrains(self):
+        resolver = self.env["ir.exports.resolver"].create({"python_code": "result = value", "type": "field"})
+        ir_export_lines_model = self.env["ir.exports.line"]
+        with self.assertRaises(ValidationError):
+            # the callable should be an existing model function, but it's not checked
+            ir_export_lines_model.create(
+                {
+                    "export_id": self.ir_export.id,
+                    "name": "name",
+                    "resolver_id": resolver.id,
+                    "instance_method_name": "function_name",
+                }
+            )

odoo/addons/export_json/jsonifier/views/ir_exports_resolver_view.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<odoo>
+    <record model="ir.ui.view" id="view_ir_exports_resolver">
+        <field name="model">ir.exports.resolver</field>
+        <field name="priority">50</field>
+        <field name="arch" type="xml">
+            <form>
+                <group>
+                    <field name="name" />
+                    <field name="type" />
+                    <field name="python_code" />
+                </group>
+            </form>
+        </field>
+    </record>
+    <record id="act_ui_exports_resolver_view" model="ir.actions.act_window">
+        <field name="name">Custom Export Resolvers</field>
+        <field name="res_model">ir.exports.resolver</field>
+        <field name="view_mode">list,form</field>
+    </record>
+    <menuitem
+        id="ui_exports_resolvers"
+        action="act_ui_exports_resolver_view"
+        parent="base.next_id_2"
+    />
+</odoo>

odoo/addons/export_json/jsonifier/views/ir_exports_view.xml

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<odoo>
+    <record model="ir.ui.view" id="view_ir_exports">
+        <field name="model">ir.exports</field>
+        <field name="priority">50</field>
+        <field name="arch" type="xml">
+            <form>
+                <sheet>
+                    <group name="se" string="Configuration">
+                        <group colspan="4" col="4" name="se-main">
+                            <field name="name" />
+                            <field name="resource" />
+                            <field name="language_agnostic" />
+                            <field name="global_resolver_id" />
+                        </group>
+                    </group>
+                    <group name="index" string="Index">
+                        <field name="export_fields" nolabel="1" colspan="2">
+                            <list editable="bottom">
+                                <field name="name" />
+                                <field name="target" />
+                                <field name="lang_id" />
+                                <field name="resolver_id" />
+                                <field name="instance_method_name" />
+                            </list>
+                        </field>
+                    </group>
+                </sheet>
+            </form>
+        </field>
+    </record>
+    <record id="act_ui_exports_view" model="ir.actions.act_window">
+        <field name="name">Export Fields</field>
+        <field name="res_model">ir.exports</field>
+        <field name="view_mode">list,form</field>
+    </record>
+    <menuitem id="ui_exports" action="act_ui_exports_view" parent="base.next_id_2" />
+</odoo>

odoo/addons/export_json/models/file_json.py

@@ -4,8 +4,7 @@ from odoo import models
 
 from odoo.addons.base_import import models as model_import
 
-model_import.base_import.FILE_TYPE_DICT["application/json"] = ("json", True, None)
-model_import.base_import.EXTENSIONS[".json"] = True
+model_import.base_import.MIMETYPE_TO_READER["application/json"] = "json"
 
 
 class BaseImportJSON(models.TransientModel):

odoo/addons/export_json/tests/test_export_json.py

@@ -173,23 +173,24 @@ class TestExportJson(common.HttpCase):
     def test_perform_json_export_with_lang(self):
         self.env["res.lang"]._activate_lang("fr_FR")
 
-        self.data_dict["fields"].append({"name": "title/name", "label": "Title"})
+        # category_id is a M2M, not a M2O
+        self.data_dict["fields"].append({"name": "category_id/name", "label": "Tags"})
         self.data_dict["fields"].append({"name": "country_id/name", "label": "Country"})
         fields = [field["name"] for field in self.data_dict["fields"]]
         model = self.env[self.data_dict["model"]]
 
         # Ajouts de traductions
-        title = (
-            self.env["res.partner.title"]
+        category = (
+            self.env["res.partner.category"]
             .with_context(lang="en_US")
             .create(
                 {
-                    "name": "Doctor",
+                    "name": "Customer",
                 }
             )
         )
-        title.with_context(lang="fr_FR").name = "Docteur"
-        self.partner.title = title
+        category.with_context(lang="fr_FR").name = "Client"
+        self.partner.category_id = category
 
         self.env.ref("base.es").with_context(lang="fr_FR").name = "Espagne"
         self.partner.country_id = self.env.ref("base.es")
@@ -209,11 +210,13 @@ class TestExportJson(common.HttpCase):
             "name": "TEST",
             "email": "test@test.fr",
             "type": "contact",
-            "title": {
-                "name": "title/name",
-                "name_FR": "Docteur",
-                "name_US": "Doctor",
-            },
+            "category_id": [
+                {
+                    "name": "category_id/name",
+                    "name_FR": "Client",
+                    "name_US": "Customer",
+                }
+            ],
             "country_id": {
                 "name": "country_id/name",
                 "name_FR": "Espagne",