[MIG] json_export_engine: Migration to 18.0

Author: kobros-tech

eslint.config.cjs

@@ -165,6 +165,9 @@ const config = [{
 
     settings: {
         jsdoc: {
+            allowedTags: [
+                "odoo-module",
+            ],
             tagNamePreference: {
                 arg: "param",
                 argument: "param",

json_export_engine/__manifest__.py

@@ -4,8 +4,10 @@
 
 {
     "name": "JSON Export Engine",
-    "summary": "Universal JSON schema builder, REST API, webhooks and scheduled exports",
-    "version": "16.0.1.0.0",
+    "summary": (
+        "Universal JSON schema builder, REST API, webhooks and" " scheduled exports"
+    ),
+    "version": "18.0.1.0.0",
     "category": "Tools",
     "website": "https://github.com/OCA/server-tools",
     "author": "kobros-tech, Odoo Community Association (OCA)",

json_export_engine/controllers/main.py

@@ -229,7 +229,7 @@ def _fetch_paginated_records(
         model = request.env[schema.model_name].sudo()
         total = model.search_count(domain)
 
-        base_path = "/api/json_export/%s" % path.strip("/")
+        base_path = f"/api/json_export/{path.strip('/')}"
         preserved_qs = self._build_preserved_query_string(params)
 
         if endpoint.paginate:
@@ -251,17 +251,15 @@ def _fetch_paginated_records(
             )
 
             nav = {
-                "first": "%s?page=1%s" % (base_path, preserved_qs),
-                "last": "%s?page=%d%s" % (base_path, total_pages, preserved_qs),
+                "first": f"{base_path}?page=1{preserved_qs}",
+                "last": f"{base_path}?page={total_pages}{preserved_qs}",
                 "next": (
-                    "%s?page=%d%s" % (base_path, page + 1, preserved_qs)
+                    f"{base_path}?page={page + 1}{preserved_qs}"
                     if page < total_pages
                     else None
                 ),
                 "prev": (
-                    "%s?page=%d%s" % (base_path, page - 1, preserved_qs)
-                    if page > 1
-                    else None
+                    f"{base_path}?page={page - 1}{preserved_qs}" if page > 1 else None
                 ),
             }
         else:

json_export_engine/data/ir_cron.xml

@@ -7,8 +7,6 @@
         <field name="code">model.autovacuum()</field>
         <field name="interval_number">1</field>
         <field name="interval_type">days</field>
-        <field name="numbercall">-1</field>
         <field name="active" eval="False" />
-        <field name="doall" eval="False" />
     </record>
 </odoo>

json_export_engine/models/json_export_endpoint.py

@@ -120,8 +120,8 @@ def _compute_full_url(self):
         for rec in self:
             if rec.route_path:
                 path = rec.route_path.strip("/")
-                rec.full_url = "%s/api/json_export/%s" % (base_url, path)
-                rec.schema_url = "%s/api/json_export/%s/schema" % (base_url, path)
+                rec.full_url = f"{base_url}/api/json_export/{path}"
+                rec.schema_url = f"{base_url}/api/json_export/{path}/schema"
             else:
                 rec.full_url = ""
                 rec.schema_url = ""

json_export_engine/models/json_export_schedule.py

@@ -114,18 +114,16 @@ def _create_or_update_cron(self):
         """Create or update the ir.cron record for this schedule."""
         self.ensure_one()
         cron_vals = {
-            "name": "JSON Export: %s" % self.name,
+            "name": f"JSON Export: {self.name}",
             "model_id": self.env["ir.model"]
             .sudo()
             .search([("model", "=", self._name)], limit=1)
             .id,
             "state": "code",
-            "code": "model._cron_run_export(%d)" % self.id,
+            "code": f"model._cron_run_export({self.id})",
             "interval_number": self.interval_number,
             "interval_type": self.interval_type,
-            "numbercall": -1,
             "active": self.active,
-            "doall": False,
         }
         if self.cron_id:
             self.cron_id.sudo().write(cron_vals)
@@ -140,7 +138,7 @@ def _cron_run_export(self, schedule_id):
         if schedule.exists() and schedule.active:
             if schedule.async_export and hasattr(schedule, "with_delay"):
                 schedule.with_delay(
-                    description="Scheduled Export: %s" % schedule.name,
+                    description=f"Scheduled Export: {schedule.name}",
                 )._run_scheduled_export()
             else:
                 schedule._run_scheduled_export()
@@ -176,10 +174,9 @@ def _run_scheduled_export(self):
 
             # Deliver
             if self.destination_type == "attachment":
-                filename = "scheduled_%s_%s.%s" % (
-                    schema.model_name.replace(".", "_"),
-                    fields.Datetime.now().strftime("%Y%m%d_%H%M%S"),
-                    ext,
+                filename = (
+                    f"scheduled_{schema.model_name.replace('.', '_')}_"
+                    f"{fields.Datetime.now().strftime('%Y%m%d_%H%M%S')}.{ext}"
                 )
                 self.env["ir.attachment"].create(
                     {

json_export_engine/models/json_export_schema.py

@@ -28,13 +28,17 @@ class JsonExportSchema(models.Model):
     active = fields.Boolean(default=True)
     model_id = fields.Many2one(
         "ir.model",
-        string="Model",
+        string="Model Reference",
         required=True,
         ondelete="cascade",
         domain=[("transient", "=", False)],
     )
     model_name = fields.Char(
-        related="model_id.model", store=True, readonly=True, index=True
+        string="Model Name",
+        related="model_id.model",
+        store=True,
+        readonly=True,
+        index=True,
     )
     exporter_id = fields.Many2one("ir.exports", string="Field Selector")
     domain = fields.Char(string="Record Filter", default="[]")
@@ -130,11 +134,9 @@ def _compute_json_schema(self):
     def _wrap_api_response_schema(self, record_schema, endpoint=None):
         """Wrap a record-level schema in the full API response envelope."""
         nullable_string = {"anyOf": [{"type": "string"}, {"type": "null"}]}
-        description = (
-            "%s Supports ?page=N to navigate pages "
-            "and ?page=last to jump to the last page."
-            % record_schema.get("description", "")
-        )
+        desc = record_schema.get("description", "")
+        description = f"{desc} Supports ?page=N to navigate pages "
+        description += "and ?page=last to jump to the last page."
         if endpoint:
             if endpoint.allow_filtering:
                 description += (
@@ -152,7 +154,7 @@ def _wrap_api_response_schema(self, record_schema, endpoint=None):
                 )
         return {
             "$schema": "http://json-schema.org/draft-07/schema#",
-            "title": "%s — API Response" % record_schema.get("title", "Export"),
+            "title": f"{record_schema.get('title', 'Export')} — API Response",
             "description": description,
             "type": "object",
             "required": ["success", "data", "pagination", "meta"],
@@ -249,16 +251,15 @@ def _wrap_api_response_schema(self, record_schema, endpoint=None):
         }
 
     def _generate_json_schema(self):
-        """Generate a JSON Schema (draft-07) from the resolved parser and model fields."""
+        """Generate a JSON Schema from the resolved parser and model fields."""
         self.ensure_one()
         parser = self._get_parser()
         model = self.env[self.model_name]
         properties, required = self._parser_to_schema_properties(parser, model)
         return {
             "$schema": "http://json-schema.org/draft-07/schema#",
             "title": self.name,
-            "description": "Auto-generated schema for %s (%s)"
-            % (self.name, self.model_name),
+            "description": f"Auto-generated schema for {self.name} ({self.model_name})",
             "type": "object",
             "properties": properties,
             "required": required,
@@ -383,7 +384,9 @@ def _get_parser(self):
             raise UserError(_("Please select a field selector (exporter) first."))
         # Remove broken export lines (e.g. name=False) before parsing,
         # otherwise jsonifier's get_json_parser() crashes on .split("/")
-        bad_lines = self.exporter_id.export_fields.filtered(lambda l: not l.name)
+        bad_lines = self.exporter_id.export_fields.filtered(
+            lambda field: not field.name
+        )
         if bad_lines:
             bad_lines.unlink()
         raw_parser = self.exporter_id.get_json_parser()
@@ -471,9 +474,9 @@ def _build_filter_domain(self, params, allowed_fields):
             raw_value = params[key]
 
             if field_name not in allowed_fields:
-                raise ValueError("Filtering on field '%s' is not allowed." % field_name)
+                raise ValueError(f"Filtering on field '{field_name}' is not allowed.")
             if operator not in self.FILTER_OPERATORS:
-                raise ValueError("Unknown filter operator '%s'." % operator)
+                raise ValueError(f"Unknown filter operator '{operator}'.")
 
             odoo_op = self.FILTER_OPERATORS[operator]
             value = self._coerce_filter_value(field_name, operator, raw_value)
@@ -507,18 +510,18 @@ def _coerce_single_value(field_type, raw):
             try:
                 return int(raw)
             except (ValueError, TypeError) as err:
-                raise ValueError("Expected integer value, got '%s'." % raw) from err
+                raise ValueError(f"Expected integer value, got '{raw}'.") from err
         elif field_type in ("float", "monetary"):
             try:
                 return float(raw)
             except (ValueError, TypeError) as err:
-                raise ValueError("Expected numeric value, got '%s'." % raw) from err
+                raise ValueError(f"Expected numeric value, got '{raw}'.") from err
         elif field_type == "boolean":
             if raw.lower() in ("true", "1", "yes"):
                 return True
             elif raw.lower() in ("false", "0", "no"):
                 return False
-            raise ValueError("Expected boolean value, got '%s'." % raw)
+            raise ValueError(f"Expected boolean value, got '{raw}'.")
         return raw
 
     def _build_sort_order(self, sort_param, allowed_fields):
@@ -541,8 +544,8 @@ def _build_sort_order(self, sort_param, allowed_fields):
                 field_name = token
                 direction = "asc"
             if field_name not in allowed_fields:
-                raise ValueError("Sorting on field '%s' is not allowed." % field_name)
-            parts.append("%s %s" % (field_name, direction))
+                raise ValueError(f"Sorting on field '{field_name}' is not allowed.")
+            parts.append(f"{field_name} {direction}")
         return ", ".join(parts)
 
     def _filter_parser(self, fields_param):
@@ -558,7 +561,7 @@ def _filter_parser(self, fields_param):
         invalid = requested - allowed
         if invalid:
             raise ValueError(
-                "Field selection on '%s' is not allowed." % "', '".join(sorted(invalid))
+                f"Field selection on '{', '.join(sorted(invalid))}' is not allowed."
             )
         full_parser = self._get_parser()
         filtered = []
@@ -583,9 +586,9 @@ def action_export_json(self):
             records = self._get_records()
             data = self._serialize_records(records)
             content = json.dumps(data, indent=2, ensure_ascii=False)
-            filename = "export_%s_%s.json" % (
-                self.model_name.replace(".", "_"),
-                fields.Datetime.now().strftime("%Y%m%d_%H%M%S"),
+            filename = (
+                f"export_{self.model_name.replace('.', '_')}_"
+                f"{fields.Datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
             )
             attachment = self.env["ir.attachment"].create(
                 {
@@ -601,7 +604,7 @@ def action_export_json(self):
             self._create_log("manual", "success", len(records), duration)
             return {
                 "type": "ir.actions.act_url",
-                "url": "/web/content/%s?download=true" % attachment.id,
+                "url": f"/web/content/{attachment.id}?download=true",
                 "target": "new",
             }
         except Exception as e:
@@ -616,7 +619,7 @@ def action_view_logs(self):
             "type": "ir.actions.act_window",
             "name": _("Export Logs"),
             "res_model": "json.export.log",
-            "view_mode": "tree,form",
+            "view_mode": "list,form",
             "domain": [("schema_id", "=", self.id)],
             "context": {"default_schema_id": self.id},
         }

json_export_engine/models/json_export_webhook.py

@@ -69,7 +69,7 @@ def action_reset_state(self):
     @api.model
     def _fire_for_model(self, model_name, event_type, records):
         """Find matching webhooks and fire them for the given model and event."""
-        event_field = "on_%s" % event_type
+        event_field = f"on_{event_type}"
         webhooks = self.search(
             [
                 ("active", "=", True),
@@ -115,7 +115,7 @@ def _trigger_webhook(self, event_type, records):
             # Async delivery via queue_job when available
             if self.async_delivery and hasattr(self, "with_delay"):
                 self.with_delay(
-                    description="Webhook: %s (%s)" % (self.name, event_type),
+                    description=f"Webhook: {self.name} ({event_type})",
                 )._send_payload(payload, delivery_id=delivery_id)
                 duration = int((time.time() - start_time) * 1000)
                 self.sudo().write(
@@ -168,7 +168,7 @@ def _trigger_webhook(self, event_type, records):
             self.sudo().write(
                 {
                     "last_call_date": fields.Datetime.now(),
-                    "last_call_status": "error: %s" % str(e)[:200],
+                    "last_call_status": f"error: {str(e)[:200]}",
                     "state": "error",
                 }
             )

json_export_engine/static/src/json_export_widget.esm.js

@@ -1,36 +1,28 @@
-/** @odoo-module **/
+/** @odoo-module */
 
 /* Copyright 2026 KOBROS-TECH LTD (https://kobros-tech.com).
  @author Mohamed Alkobrosli <mohamed@kobros-tech.com>
  License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl). */
 
-import {ExportDataDialog} from "@web/views/view_dialogs/export_data_dialog";
-import {Many2OneField} from "@web/views/fields/many2one/many2one_field";
+import {Many2OneField, many2OneField} from "@web/views/fields/many2one/many2one_field";
+import {_t} from "@web/core/l10n/translation";
+import {rpc} from "@web/core/network/rpc";
 import {registry} from "@web/core/registry";
 import {useService} from "@web/core/utils/hooks";
-
-const {onWillDestroy} = owl;
+import {ExportDataDialog} from "@web/views/view_dialogs/export_data_dialog";
 
 class JsonExportDialog extends ExportDataDialog {
     setup() {
         super.setup();
         Object.assign(this.state, {
             showApplyTemplateButton: false,
         });
-        this.title = this.env._t("Select Fields for JSON Export");
-        // Swap the model from props to load the correct export fields
-        // for the schema's target model, not the schema model itself.
-        this.swapResModel = this.props.root.resModel;
-        this.props.root.resModel = this.props.context.resModel;
+        this.title = _t("Select Fields for JSON Export");
         if (this.props.context.exporter_id && this.props.context.exporter_id[0]) {
             this.state.templateId = this.props.context.exporter_id[0];
         } else {
             this.state.templateId = "new_template";
         }
-        // Restore original model when dialog is destroyed
-        onWillDestroy(() => {
-            this.props.root.resModel = this.swapResModel;
-        });
     }
 
     async onChangeExportList(ev) {
@@ -105,7 +97,6 @@ JsonExportDialog.template = "json_export_engine.JsonExportDialog";
 class JsonExportFieldSelector extends Many2OneField {
     setup() {
         super.setup();
-        this.rpc = useService("rpc");
         this.orm = useService("orm");
         this.dialogService = useService("dialog");
         this.quickOverlap = (templ) => {
@@ -121,9 +112,11 @@ class JsonExportFieldSelector extends Many2OneField {
     }
 
     async getExportedFields(model, import_compat, parentParams) {
-        return await this.rpc("/web/export/get_fields", {
+        const domain = [];
+        return await rpc("/web/export/get_fields", {
             ...parentParams,
-            model,
+            model: this.props.record.data.model_name,
+            domain,
             import_compat,
         });
     }
@@ -154,8 +147,10 @@ class JsonExportFieldSelector extends Many2OneField {
 
 JsonExportFieldSelector.template = "json_export_engine.JsonExportFieldSelector";
 JsonExportFieldSelector.supportedTypes = ["many2one"];
-JsonExportFieldSelector.fieldDependencies = {
-    model_name: {type: "char"},
+
+export const jsonExportFieldSelector = {
+    ...many2OneField,
+    component: JsonExportFieldSelector,
 };
 
-registry.category("fields").add("json_export_field_selector", JsonExportFieldSelector);
+registry.category("fields").add("json_export_field_selector", jsonExportFieldSelector);

json_export_engine/tests/test_controller.py

@@ -139,7 +139,7 @@ def setUpClass(cls):
 
     def _get(self, path, headers=None):
         """Helper to perform a GET request."""
-        url = "/api/json_export/%s" % path
+        url = f"/api/json_export/{path}"
         return self.url_open(url, headers=headers or {})
 
     # -- No auth tests --