[FIX] web: kanban quick create with correct default values

When a kanban view is grouped by a char or a boolean field, and the
quick create option is enabled, the correct default value for the
grouped field (i.e. the value of the column in which the record is
created) should be given (either in the context if that field isn't
in the quick create form view, or as a default value in that form
view otherwise).

Before this rev., it wasn't the case, as it was only working when
grouped by a many2one field.

Task 1878254

addons/web/static/src/js/views/kanban/kanban_column.js

@@ -194,7 +194,7 @@ var KanbanColumn = Widget.extend({
         this.trigger_up('close_quick_create'); // close other quick create widgets
         this.trigger_up('start_quick_create');
         var context = this.data.getContext();
-        context['default_' + this.groupedBy] = this.id;
+        context['default_' + this.groupedBy] = this.grouped_by_m2o ? this.id : this.data.value;
         this.quickCreateWidget = new RecordQuickCreate(this, {
             context: context,
             formViewRef: this.quickCreateView,

addons/web/static/src/js/views/kanban/kanban_controller.js

@@ -388,10 +388,12 @@ var KanbanController = BasicController.extend({
                 var columnState = self.model.get(column.db_id, {raw: true});
                 var context = columnState.getContext();
                 var state = self.model.get(self.handle, {raw: true});
-                context['default_' + state.groupedBy[0]] = columnState.res_id;
+                var groupedBy = state.groupedBy[0];
+                var groupedByM2O = state.fields[groupedBy].type === 'many2one';
+                context['default_' + groupedBy] = groupedByM2O ? columnState.res_id : columnState.value;
                 new view_dialogs.FormViewDialog(self, {
                     res_model: state.model,
-                    context: _.extend({default_name: name}, context),
+                    context: _.extend({default_name: values.name || values.display_name}, context),
                     title: _t("Create"),
                     disable_multiple_selection: true,
                     on_saved: function (record) {

addons/web/static/src/js/views/kanban/kanban_model.js

@@ -105,7 +105,8 @@ var KanbanModel = BasicModel.extend({
         var group = this.localData[groupID];
         var context = this._getContext(group);
         var parent = this.localData[group.parentID];
-        context['default_' + parent.groupedBy[0]] = group.res_id;
+        var groupedByM2O = parent.fields[parent.groupedBy].type === 'many2one';
+        context['default_' + parent.groupedBy[0]] = groupedByM2O ? group.res_id : group.value;
         var def;
         if (Object.keys(values).length === 1 && 'display_name' in values) {
             // only 'display_name is given, perform a 'name_create'

addons/web/static/tests/views/kanban_tests.js

@@ -1110,7 +1110,7 @@ QUnit.module('Views', {
         kanban.destroy();
     });
 
-    QUnit.test('quick create record fail in grouped', function (assert) {
+    QUnit.test('quick create record fail in grouped by many2one', function (assert) {
         assert.expect(7);
 
         var kanban = createView({
@@ -1176,6 +1176,63 @@ QUnit.module('Views', {
         kanban.destroy();
     });
 
+    QUnit.test('quick create record fails in grouped by char', function (assert) {
+        assert.expect(7);
+
+        var kanban = createView({
+            View: KanbanView,
+            model: 'partner',
+            data: this.data,
+            arch: '<kanban class="o_kanban_test" on_create="quick_create">' +
+                    '<templates><t t-name="kanban-box">' +
+                        '<div><field name="foo"/></div>' +
+                    '</t></templates>' +
+                '</kanban>',
+            archs: {
+                'partner,false,form': '<form>' +
+                        '<field name="foo"/>' +
+                    '</form>',
+            },
+            mockRPC: function (route, args) {
+                if (args.method === 'name_create') {
+                    return $.Deferred().reject({
+                        code: 200,
+                        data: {},
+                        message: "Odoo server error",
+                    }, $.Event());
+                }
+                if (args.method === 'create') {
+                    assert.deepEqual(args.args[0], {foo: 'yop'},
+                        "should write the correct value for foo");
+                    assert.deepEqual(args.kwargs.context, {default_foo: 'yop', default_name: 'test'},
+                        "should send the correct default value for foo");
+                }
+                return this._super.apply(this, arguments);
+            },
+            groupBy: ['foo'],
+        });
+
+        assert.strictEqual(kanban.$('.o_kanban_group:first .o_kanban_record').length, 1,
+            "there should be 1 record in first column");
+
+        kanban.$('.o_kanban_header:first .o_kanban_quick_add i').click();
+        kanban.$('.o_kanban_quick_create input').val('test').trigger('input');
+        kanban.$('.o_kanban_add').click();
+
+        assert.strictEqual($('.modal .o_form_view.o_form_editable').length, 1,
+            "a form view dialog should have been opened (in edit)");
+        assert.strictEqual($('.modal .o_field_widget[name=foo]').val(), 'yop',
+            "the correct default value for foo should already be set");
+
+        $('.modal-footer .btn-primary').click();
+
+        assert.strictEqual($('.modal').length, 0, "the modal should be closed");
+        assert.strictEqual(kanban.$('.o_kanban_group:first .o_kanban_record').length, 2,
+            "there should be 2 records in first column");
+
+        kanban.destroy();
+    });
+
     QUnit.test('quick create record in empty grouped kanban', function (assert) {
         assert.expect(3);
 
@@ -1293,6 +1350,170 @@ QUnit.module('Views', {
         kanban.destroy();
     });
 
+    QUnit.test('quick create record in grouped by char field', function (assert) {
+        assert.expect(4);
+
+        var kanban = createView({
+            View: KanbanView,
+            model: 'partner',
+            data: this.data,
+            arch: '<kanban class="o_kanban_test" on_create="quick_create">' +
+                        '<templates><t t-name="kanban-box">' +
+                            '<div><field name="display_name"/></div>' +
+                        '</t></templates>' +
+                    '</kanban>',
+            groupBy: ['foo'],
+            mockRPC: function (route, args) {
+                if (args.method === 'name_create') {
+                    assert.deepEqual(args.kwargs.context, {default_foo: 'yop'},
+                        "should send the correct default value for foo");
+                }
+                return this._super.apply(this, arguments);
+            },
+        });
+
+        assert.strictEqual(kanban.$('.o_kanban_header .o_kanban_quick_add i').length, 3,
+            "quick create should be enabled when grouped on a char field");
+        assert.strictEqual(kanban.$('.o_kanban_group:first .o_kanban_record').length, 1,
+            "first column should contain 1 record");
+
+        kanban.$('.o_kanban_header:first .o_kanban_quick_add i').click();
+        kanban.$('.o_kanban_quick_create input').val('new record').trigger('input');
+        kanban.$('.o_kanban_add').click();
+
+        assert.strictEqual(kanban.$('.o_kanban_group:first .o_kanban_record').length, 2,
+            "first column should now contain 2 records");
+
+        kanban.destroy();
+    });
+
+    QUnit.test('quick create record in grouped by boolean field', function (assert) {
+        assert.expect(4);
+
+        var kanban = createView({
+            View: KanbanView,
+            model: 'partner',
+            data: this.data,
+            arch: '<kanban class="o_kanban_test" on_create="quick_create">' +
+                        '<templates><t t-name="kanban-box">' +
+                            '<div><field name="display_name"/></div>' +
+                        '</t></templates>' +
+                    '</kanban>',
+            groupBy: ['bar'],
+            mockRPC: function (route, args) {
+                if (args.method === 'name_create') {
+                    assert.deepEqual(args.kwargs.context, {default_bar: true},
+                        "should send the correct default value for bar");
+                }
+                return this._super.apply(this, arguments);
+            },
+        });
+
+        assert.strictEqual(kanban.$('.o_kanban_header .o_kanban_quick_add i').length, 2,
+            "quick create should be enabled when grouped on a boolean field");
+        assert.strictEqual(kanban.$('.o_kanban_group:nth(1) .o_kanban_record').length, 3,
+            "second column (true) should contain 3 records");
+
+        kanban.$('.o_kanban_header:nth(1) .o_kanban_quick_add i').click();
+        kanban.$('.o_kanban_quick_create input').val('new record').trigger('input');
+        kanban.$('.o_kanban_add').click();
+
+        assert.strictEqual(kanban.$('.o_kanban_group:nth(1) .o_kanban_record').length, 4,
+            "second column (true) should now contain 4 records");
+
+        kanban.destroy();
+    });
+
+    QUnit.test('quick create record in grouped by char field (within quick_create_view)', function (assert) {
+        assert.expect(6);
+
+        var kanban = createView({
+            View: KanbanView,
+            model: 'partner',
+            data: this.data,
+            arch: '<kanban on_create="quick_create" quick_create_view="some_view_ref">' +
+                        '<templates><t t-name="kanban-box">' +
+                            '<div><field name="foo"/></div>' +
+                        '</t></templates>' +
+                    '</kanban>',
+            archs: {
+                'partner,some_view_ref,form': '<form>' +
+                    '<field name="foo"/>' +
+                '</form>',
+            },
+            groupBy: ['foo'],
+            mockRPC: function (route, args) {
+                if (args.method === 'create') {
+                    assert.deepEqual(args.args[0], {foo: 'yop'},
+                        "should write the correct value for foo");
+                    assert.deepEqual(args.kwargs.context, {default_foo: 'yop'},
+                        "should send the correct default value for foo");
+                }
+                return this._super.apply(this, arguments);
+            },
+        });
+
+        assert.strictEqual(kanban.$('.o_kanban_header .o_kanban_quick_add i').length, 3,
+            "quick create should be enabled when grouped on a char field");
+        assert.strictEqual(kanban.$('.o_kanban_group:first .o_kanban_record').length, 1,
+            "first column should contain 1 record");
+
+        kanban.$('.o_kanban_header:first .o_kanban_quick_add i').click();
+        assert.strictEqual(kanban.$('.o_kanban_quick_create input').val(), 'yop',
+            "should have set the correct foo value by default");
+        kanban.$('.o_kanban_add').click();
+
+        assert.strictEqual(kanban.$('.o_kanban_group:first .o_kanban_record').length, 2,
+            "first column should now contain 2 records");
+
+        kanban.destroy();
+    });
+
+    QUnit.test('quick create record in grouped by boolean field (within quick_create_view)', function (assert) {
+        assert.expect(6);
+
+        var kanban = createView({
+            View: KanbanView,
+            model: 'partner',
+            data: this.data,
+            arch: '<kanban on_create="quick_create" quick_create_view="some_view_ref">' +
+                        '<templates><t t-name="kanban-box">' +
+                            '<div><field name="bar"/></div>' +
+                        '</t></templates>' +
+                    '</kanban>',
+            archs: {
+                'partner,some_view_ref,form': '<form>' +
+                    '<field name="bar"/>' +
+                '</form>',
+            },
+            groupBy: ['bar'],
+            mockRPC: function (route, args) {
+                if (args.method === 'create') {
+                    assert.deepEqual(args.args[0], {bar: true},
+                        "should write the correct value for bar");
+                    assert.deepEqual(args.kwargs.context, {default_bar: true},
+                        "should send the correct default value for bar");
+                }
+                return this._super.apply(this, arguments);
+            },
+        });
+
+        assert.strictEqual(kanban.$('.o_kanban_header .o_kanban_quick_add i').length, 2,
+            "quick create should be enabled when grouped on a boolean field");
+        assert.strictEqual(kanban.$('.o_kanban_group:nth(1) .o_kanban_record').length, 3,
+            "second column (true) should contain 3 records");
+
+        kanban.$('.o_kanban_header:nth(1) .o_kanban_quick_add i').click();
+        assert.ok(kanban.$('.o_kanban_quick_create .o_field_boolean input').is(':checked'),
+            "should have set the correct bar value by default");
+        kanban.$('.o_kanban_add').click();
+
+        assert.strictEqual(kanban.$('.o_kanban_group:nth(1) .o_kanban_record').length, 4,
+            "second column (true) should now contain 4 records");
+
+        kanban.destroy();
+    });
+
     QUnit.test('many2many_tags in kanban views', function (assert) {
         assert.expect(12);