[FIX] web: advanced use of widget `reference`

The reference widget is also meant to be used on a char field, not only on a
reference field.

The rev. https://github.com/odoo/odoo/commit/a4e30a1b43d0b9acd76508d9e6c466cd1dbdffab removed
the use of `field_utils.format.many2one` and replaced it by `_formatValue` to
support this use case.

The replacement wasn't complete as some occurences was remaining (in reset),
which led to traceback when the widget was reset (impossible to create an
External Identifier anymore).

Also, the reference `_formatValue` wasn't correct as it was displaying the
record `display_name` and not the reference field value ; this only makes sense
for the External Identifier as its display name is the reference field value but
it doesn't make any sense for other reference field.

Last but not least, this commit implements the `onchange` and `default_get` for
the reference field.

1 files changed, 88 insertions, 27 deletions

diff --git a/addons/web/static/src/js/views/basic/basic_model.js b/addons/web/static/src/js/views/basic/basic_model.js
index 3bfab5e3eb6..0d95c292070 100644
--- a/addons/web/static/src/js/views/basic/basic_model.js
+++ b/addons/web/static/src/js/views/basic/basic_model.js
@@ -1146,9 +1146,9 @@ var BasicModel = AbstractModel.extend({
                 record._rawChanges[name] = val;
                 return;
             }
-
-            if (field.type === 'many2one' ) {
-                var id = false;
+            var id;
+            if (field.type === 'many2one') {
+                id = false;
                 // in some case, the value returned by the onchange can
                 // be false (no value), so we need to avoid creating a
                 // local record for that.
@@ -1167,6 +1167,20 @@ var BasicModel = AbstractModel.extend({
                     id = rec.id;
                 }
                 record._changes[name] = id;
+            } else if (field.type === 'reference') {
+                id = false;
+                if (val) {
+                    var ref = val.split(',');
+                    rec = self._makeDataPoint({
+                        context: record.context,
+                        data: {id: parseInt(ref[1])},
+                        modelName: ref[0],
+                        parentID: record.id,
+                    });
+                    defs.push(self._fetchNameGet(rec));
+                    id = rec.id;
+                }
+                record._changes[name] = id;
             } else if (field.type === 'one2many' || field.type === 'many2many') {
                 var listId = record._changes[name] || record.data[name];
                 var list;
@@ -1643,6 +1657,39 @@ var BasicModel = AbstractModel.extend({
             });
     },
     /**
+     * Fetch the `name_get` for a reference field.
+     *
+     * @private
+     * @param {Object} record
+     * @param {string} fieldName
+     * @returns {Deferred}
+     */
+    _fetchReference: function (record, fieldName) {
+        var self = this;
+        var def;
+        var value = record._changes && record._changes[fieldName] || record.data[fieldName];
+        var model = value && value.split(',')[0];
+        var resID = value && parseInt(value.split(',')[1]);
+        if (model && model !== 'False' && resID) {
+            def = self._rpc({
+                model: model,
+                method: 'name_get',
+                args: [resID],
+                context: record.getContext({fieldName: fieldName}),
+            }).then(function (result) {
+                return self._makeDataPoint({
+                    data: {
+                        id: result[0][0],
+                        display_name: result[0][1],
+                    },
+                    modelName: model,
+                    parentID: record.id,
+                });
+            });
+        }
+        return $.when(def);
+    },
+    /**
      * Fetch the extra data (`name_get`) for the reference fields of the record
      * model.
      *
@@ -1657,28 +1704,12 @@ var BasicModel = AbstractModel.extend({
         _.each(fieldNames, function (fieldName) {
             var field = record.fields[fieldName];
             if (field.type === 'reference') {
-                var value = record.data[fieldName];
-                if (value) {
-                    var model = value.split(',')[0];
-                    var resID = parseInt(value.split(',')[1]);
-                    var def = self._rpc({
-                        model: model,
-                        method: 'name_get',
-                        args: [resID],
-                        context: record.getContext({fieldName: fieldName}),
-                    }).then(function (result) {
-                        var referenceDp = self._makeDataPoint({
-                            data: {
-                                id: result[0][0],
-                                display_name: result[0][1],
-                            },
-                            modelName: model,
-                            parentID: record.id,
-                        });
-                        record.data[fieldName] = referenceDp.id;
-                    });
-                    defs.push(def);
-                }
+                var def = self._fetchReference(record, fieldName).then(function (dataPoint) {
+                    if (dataPoint) {
+                        record.data[fieldName] = dataPoint.id;
+                    }
+                });
+                defs.push(def);
             }
         });
         return $.when.apply($, defs);
@@ -1949,6 +1980,25 @@ var BasicModel = AbstractModel.extend({
             });
     },
     /**
+     * Fetches the `name_get` associated to the reference widget if the field is
+     * a `char` (which is a supported case).
+     *
+     * @private
+     * @param {Object} record - an element from the localData
+     * @param {Object} fieldName - the name of the field
+     * @returns {Deferred}
+     */
+    _fetchSpecialReference: function (record, fieldName) {
+        var def;
+        var field = record.fields[fieldName];
+        if (field.type === 'char') {
+            // if the widget reference is set on a char field, the name_get
+            // needs to be fetched a posteriori
+            def = this._fetchReference(record, fieldName);
+        }
+        return $.when(def);
+    },
+    /**
      * Fetches all the m2o records associated to the given fieldName. If the
      * given fieldName is not a m2o field, nothing is done. The difference with
      * _fetchSpecialMany2ones is that the field given by options.fold_field is
@@ -2870,14 +2920,25 @@ var BasicModel = AbstractModel.extend({
                     var field = params.fields[name];
                     data[name] = null;
                     record._changes = record._changes || {};
+                    var dp;
                     if (field.type === 'many2one' && result[name]) {
-                        var rec = self._makeDataPoint({
+                        dp = self._makeDataPoint({
                             context: record.context,
                             data: {id: result[name]},
                             modelName: field.relation,
                             parentID: record.id,
                         });
-                        record._changes[name] = rec.id;
+                        record._changes[name] = dp.id;
+                    } else if (field.type === 'reference' && result[name]) {
+                        var ref = result[name].split(',');
+                        dp = self._makeDataPoint({
+                            context: record.context,
+                            data: {id: parseInt(ref[1])},
+                            modelName: ref[0],
+                            parentID: record.id,
+                        });
+                        defs.push(self._fetchNameGet(dp));
+                        record._changes[name] = dp.id;
                     } else if (field.type === 'one2many' || field.type === 'many2many') {
                         var fieldInfo = record.fieldsInfo[record.viewType][name];
                         var view = fieldInfo.views && fieldInfo.views[fieldInfo.mode];