[FIX] web: fix various bugs when fetching x2manys in form views

- When an one2many is displayed in a list view, the field data are not fully loaded
since only the number of record is displayed. Then when the related form view
is opened the one2many fields displayed need to be loaded.

- Optimized the fetch of x2manys without doing an useless rpc
if we don't need all the fields but only the relation records ids and adapt
the tests for this optimisation.

- Fix wrong inheritance for kanbanmany2many_tags

3 files changed, 70 insertions, 31 deletions

diff --git a/addons/web/static/src/js/fields/relational_fields.js b/addons/web/static/src/js/fields/relational_fields.js
index 7f4fa24e5c2..2d746a81aa1 100644
--- a/addons/web/static/src/js/fields/relational_fields.js
+++ b/addons/web/static/src/js/fields/relational_fields.js
@@ -1179,7 +1179,7 @@ var FormFieldMany2ManyTags = FieldMany2ManyTags.extend({
     },
 });
 
-var KanbanFieldMany2ManyTags = FieldMany2Many.extend({
+var KanbanFieldMany2ManyTags = FieldMany2ManyTags.extend({
     _render: function () {
         var self = this;
         this.$el.addClass('o_form_field_many2manytags o_kanban_tags');
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 b3777a05efb..4b39025b35d 100644
--- a/addons/web/static/src/js/views/basic/basic_model.js
+++ b/addons/web/static/src/js/views/basic/basic_model.js
@@ -1619,40 +1619,50 @@ var BasicModel = AbstractModel.extend({
         if (!ids.length || fieldInfo.__no_fetch) {
             return $.when();
         }
-
+        var def;
+        var fieldNames = _.keys(fieldInfo.relatedFields);
         // step 2: fetch data from server
-        return this._rpc({
+        // if we want specific fields
+        // if not we return an array of objects with the id
+        // to avoid fetching all the relation fields and an useless rpc
+        if (fieldNames.length) {
+            def = this._rpc({
                 model: field.relation,
                 method: 'read',
-                args: [ids, _.keys(fieldInfo.relatedFields)],
+                args: [ids, fieldNames],
                 context: {}, // FIXME
-            })
-            .then(function (results) {
-                // step 3: assign values to correct datapoints
-                var dataPoints = _.map(results, function (result) {
-                    return self._makeDataPoint({
-                        modelName: field.relation,
-                        data: result,
-                        fields: fields,
-                        fieldsInfo: fieldsInfo,
-                        viewType: viewType,
-                    });
+            });
+        } else {
+            def = $.when(_.map(ids, function (id) {
+                return {id:id};
+            }));
+        }
+        return def.then(function (results) {
+            // step 3: assign values to correct datapoints
+            var dataPoints = _.map(results, function (result) {
+                return self._makeDataPoint({
+                    modelName: field.relation,
+                    data: result,
+                    fields: fields,
+                    fieldsInfo: fieldsInfo,
+                    viewType: viewType,
                 });
+            });
 
-                _.each(list.data, function (dataPoint) {
-                    var record = self.localData[dataPoint];
-                    var m2mList = self.localData[record.data[fieldName]];
+            _.each(list.data, function (dataPoint) {
+                var record = self.localData[dataPoint];
+                var m2mList = self.localData[record.data[fieldName]];
 
-                    m2mList.data = [];
-                    _.each(m2mList.res_ids, function (res_id) {
-                        var dataPoint = _.find(dataPoints, function (d) {
-                            return d.res_id === res_id;
-                        });
-                        m2mList.data.push(dataPoint.id);
-                        m2mList.count++;
+                m2mList.data = [];
+                _.each(m2mList.res_ids, function (res_id) {
+                    var dataPoint = _.find(dataPoints, function (d) {
+                        return d.res_id === res_id;
                     });
+                    m2mList.data.push(dataPoint.id);
+                    m2mList.count++;
                 });
             });
+        });
     },
     /**
      * batch request for x2ms for datapoint of type list
@@ -2444,12 +2454,18 @@ var BasicModel = AbstractModel.extend({
             }
         }
         if (missingIds.length) {
-            def = this._rpc({
-                model: list.model,
-                method: 'read',
-                args: [missingIds, fieldNames],
-                context: {} // FIXME
-            });
+            if (fieldNames.length) {
+                def = this._rpc({
+                    model: list.model,
+                    method: 'read',
+                    args: [missingIds, fieldNames],
+                    context: {} // FIXME
+                });
+            } else {
+                def = $.when(_.map(missingIds, function (id) {
+                    return {id:id};
+                }));
+            }
         } else {
             def = $.when();
         }
diff --git a/addons/web/static/src/js/views/basic/basic_view.js b/addons/web/static/src/js/views/basic/basic_view.js
index 2604dcf0aa1..17dc4b97125 100644
--- a/addons/web/static/src/js/views/basic/basic_view.js
+++ b/addons/web/static/src/js/views/basic/basic_view.js
@@ -66,6 +66,29 @@ var BasicView = AbstractView.extend({
             var viewType = this.viewType;
             var viewFields = Object.keys(record.fieldsInfo[viewType]);
             var fieldNames = _.difference(viewFields, Object.keys(record.data));
+            // Suppose that in a form view, there is an x2many list view with
+            // an x2many field F of the related record, and that F is also
+            // displayed in the x2many form view (e.g. as a list or a kanban).
+            // In this case, F is represented in record.data
+            // (as it is known by the x2many list view), but its related fields
+            // (those displayed in the list or kanban) still need to be fetched.
+            // So when this happens, F is added to the list of fieldNames to fetch.
+            _.each(viewFields, function (name) {
+                if (!_.contains(fieldNames, name)) {
+                    var fieldType = record.fields[name].type;
+                    if ((fieldType === 'one2many' || fieldType === 'many2many')) {
+                        if (!('fieldsInfo' in record.data[name])) {
+                            fieldNames.push(name);
+                        } else {
+                            var recordViewTypes = Object.keys(record.data[name].fieldsInfo);
+                            var fieldViewTypes = Object.keys(record.fieldsInfo[viewType][name].views);
+                            if (_.difference(fieldViewTypes, recordViewTypes).length) {
+                                fieldNames.push(name);
+                            }
+                        }
+                    }
+                }
+            });
             if (fieldNames.length && !this.model.isNew(record.id)) {
                 return this.model.reload(this.recordID, {
                     fieldNames: fieldNames,