diff --git a/addons/account/wizard/account_invoice_send.py b/addons/account/wizard/account_invoice_send.py index 10e491c3291..409227b0d8d 100644 --- a/addons/account/wizard/account_invoice_send.py +++ b/addons/account/wizard/account_invoice_send.py @@ -84,15 +84,18 @@ class AccountInvoiceSend(models.TransientModel): # This should ideally be fixed in mail_compose_message, so when a fix is made there this whole commit should be reverted. # basically self.body (which could be manually edited) extracts self.template_id, # which is then not translated for each customer. - active_ids = self.env.context.get('active_ids', self.res_id) - active_records = self.env[self.model].browse(active_ids) - langs = active_records.mapped('partner_id.lang') - default_lang = self.env.context.get('lang', 'en_US') - for lang in (set(langs) or [default_lang]): - active_ids_lang = active_records.filtered(lambda r: r.partner_id.lang == lang).ids - self_lang = self.with_context(active_ids=active_ids_lang, lang=lang) - self_lang.onchange_template_id() - self_lang._send_email() + if self.composition_mode == 'mass_mail' and self.template_id: + active_ids = self.env.context.get('active_ids', self.res_id) + active_records = self.env[self.model].browse(active_ids) + langs = active_records.mapped('partner_id.lang') + default_lang = self.env.context.get('lang', 'en_US') + for lang in (set(langs) or [default_lang]): + active_ids_lang = active_records.filtered(lambda r: r.partner_id.lang == lang).ids + self_lang = self.with_context(active_ids=active_ids_lang, lang=lang) + self_lang.onchange_template_id() + self_lang._send_email() + else: + self._send_email() if self.is_print: return self._print_document() return {'type': 'ir.actions.act_window_close'} diff --git a/addons/account/wizard/account_invoice_send_views.xml b/addons/account/wizard/account_invoice_send_views.xml index cae3b296b63..eac9adda58e 100644 --- a/addons/account/wizard/account_invoice_send_views.xml +++ b/addons/account/wizard/account_invoice_send_views.xml @@ -14,6 +14,7 @@ +
diff --git a/addons/gamification/models/gamification_karma_rank.py b/addons/gamification/models/gamification_karma_rank.py index 78b8e40ac50..1d930fefa4d 100644 --- a/addons/gamification/models/gamification_karma_rank.py +++ b/addons/gamification/models/gamification_karma_rank.py @@ -47,8 +47,19 @@ class KarmaRank(models.Model): @api.multi def write(self, vals): + if 'karma_min' in vals: + previous_ranks = self.env['gamification.karma.rank'].search([], order="karma_min DESC").ids + low = min(vals['karma_min'], self.karma_min) + high = max(vals['karma_min'], self.karma_min) + tools.image_resize_images(vals) res = super(KarmaRank, self).write(vals) - users = self.env['res.users'].sudo().search([('karma', '>', 0)]) - users._recompute_rank() + + if 'karma_min' in vals: + after_ranks = self.env['gamification.karma.rank'].search([], order="karma_min DESC").ids + if previous_ranks != after_ranks: + users = self.env['res.users'].sudo().search([('karma', '>', 0)]) + else: + users = self.env['res.users'].sudo().search([('karma', '>=', low), ('karma', '<=', high)]) + users._recompute_rank() return res diff --git a/addons/gamification/models/res_users.py b/addons/gamification/models/res_users.py index a0ca65ced45..4f9319a4001 100644 --- a/addons/gamification/models/res_users.py +++ b/addons/gamification/models/res_users.py @@ -7,9 +7,11 @@ import logging _logger = logging.getLogger(__name__) + class Users(models.Model): _inherit = 'res.users' + karma = fields.Integer('Karma', default=0) karma_position = fields.Integer('Karma position', compute="_compute_karma_position", store=False) badge_ids = fields.One2many('gamification.badge.user', 'user_id', string='Badges', copy=False) @@ -69,18 +71,32 @@ class Users(models.Model): return True def _rank_changed(self): - if self.rank_id.karma_min > 0: - template = self.env.ref('gamification.mail_template_data_new_rank_reached', raise_if_not_found=False) - if template: - template.send_mail(self.id, force_send=True, notif_layout='mail.mail_notification_light') + """ + Method that can be called on a batch of users with the same new rank + """ + template = self.env.ref('gamification.mail_template_data_new_rank_reached', raise_if_not_found=False) + if template: + for u in self: + if u.rank_id.karma_min > 0: + template.send_mail(u.id, force_send=len(self) == 1, notif_layout='mail.mail_notification_light') def _recompute_rank(self): """ The caller should filter the users on karma > 0 before calling this method to avoid looping on every single users + + Compute rank of each user by user. + For each user, check the rank of this user """ + ranks = [{'rank': rank, 'karma_min': rank.karma_min} for rank in self.env['gamification.karma.rank'].search([], order="karma_min DESC")] + + # 3 is the number of search/requests used by rank in _recompute_rank_bulk() + if len(self) > len(ranks) * 3: + self._recompute_rank_bulk() + return + for user in self: old_rank = user.rank_id if user.karma == 0 and ranks: @@ -96,6 +112,66 @@ class Users(models.Model): if old_rank != user.rank_id: user._rank_changed() + def _recompute_rank_bulk(self): + """ + Compute rank of each user by rank. + For each rank, check which users need to be ranked + + """ + ranks = [{'rank': rank, 'karma_min': rank.karma_min} for rank in + self.env['gamification.karma.rank'].search([], order="karma_min DESC")] + + users_todo = self + + next_rank_id = False + # wtf, next_rank_id should be a related on rank_id.next_rank_id and life might get easier. + # And we only need to recompute next_rank_id on write with min_karma or in the create on rank model. + for r in ranks: + rank_id = r['rank'].id + dom = [ + ('karma', '>=', r['karma_min']), + ('id', 'in', users_todo.ids), + '|', # noqa + '|', ('rank_id', '!=', rank_id), ('rank_id', '=', False), + '|', ('next_rank_id', '!=', next_rank_id), ('next_rank_id', '=', False if next_rank_id else -1), + ] + users = self.env['res.users'].search(dom) + if users: + users_to_notify = self.env['res.users'].search([ + ('karma', '>=', r['karma_min']), + '|', ('rank_id', '!=', rank_id), ('rank_id', '=', False), + ('id', 'in', users.ids), + ]) + users.write({ + 'rank_id': rank_id, + 'next_rank_id': next_rank_id, + }) + users_to_notify._rank_changed() + users_todo -= users + + nothing_to_do_users = self.env['res.users'].search([ + ('karma', '>=', r['karma_min']), + '|', ('rank_id', '=', rank_id), ('next_rank_id', '=', next_rank_id), + ('id', 'in', users_todo.ids), + ]) + users_todo -= nothing_to_do_users + next_rank_id = r['rank'].id + + if ranks: + lower_rank = ranks[-1]['rank'] + users = self.env['res.users'].search([ + ('karma', '>=', 0), + ('karma', '<', lower_rank.karma_min), + '|', ('rank_id', '!=', False), ('next_rank_id', '!=', lower_rank.id), + ('id', 'in', users_todo.ids), + ]) + if users: + users.write({ + 'rank_id': False, + 'next_rank_id': lower_rank.id, + }) + + def _get_next_rank(self): """ For fresh users with 0 karma that don't have a rank_id and next_rank_id yet this method returns the first karma rank (by karma ascending). This acts as a diff --git a/addons/gamification/tests/__init__.py b/addons/gamification/tests/__init__.py index 0219f6754d0..a6a599bf6c8 100644 --- a/addons/gamification/tests/__init__.py +++ b/addons/gamification/tests/__init__.py @@ -2,3 +2,4 @@ # Part of Odoo. See LICENSE file for full copyright and licensing details. from . import test_challenge +from . import test_recompute_rank diff --git a/addons/gamification/tests/test_recompute_rank.py b/addons/gamification/tests/test_recompute_rank.py new file mode 100644 index 00000000000..c82fb4759fd --- /dev/null +++ b/addons/gamification/tests/test_recompute_rank.py @@ -0,0 +1,128 @@ +# -*- coding: utf-8 -*- +# Part of Odoo. See LICENSE file for full copyright and licensing details. + +from odoo.tests import common +from unittest.mock import patch + + +class TestComputeRankCommon(common.TransactionCase): + + def setUp(self): + super(TestComputeRankCommon, self).setUp() + + def _patched_send_mail(*args, **kwargs): + pass + + self.User = self.env['res.users'].with_context(no_reset_password=True, mail_create_nosubscribe=True) + self.users = self.User + + patch_email = patch('odoo.addons.mail.models.mail_template.MailTemplate.send_mail', _patched_send_mail) + patch_email.start() + for k in range(-5, 1030, 30): + self.users += self.User.create({ + 'name': str(k), + 'login': "test_recompute_rank_%s" % k, + 'karma': k, + }) + + self.env['gamification.karma.rank'].search([]).unlink() + + self.rank_1 = self.env['gamification.karma.rank'].create({ + 'name': 'rank 1', + 'karma_min': 0, + }) + + self.rank_2 = self.env['gamification.karma.rank'].create({ + 'name': 'rank 2', + 'karma_min': 250, + }) + + self.rank_3 = self.env['gamification.karma.rank'].create({ + 'name': 'rank 3', + 'karma_min': 500, + }) + self.rank_4 = self.env['gamification.karma.rank'].create({ + 'name': 'rank 4', + 'karma_min': 1000, + }) + + patch_email.stop() + + +class test_recompute(TestComputeRankCommon): + + def test_00_initial_compute(self): + + self.assertEqual(len(self.users), 35) + + self.assertEqual( + len(self.rank_1.user_ids & self.users), + len([u for u in self.users if u.karma >= self.rank_1.karma_min and u.karma < self.rank_2.karma_min]) + ) + self.assertEqual( + len(self.rank_2.user_ids & self.users), + len([u for u in self.users if u.karma >= self.rank_2.karma_min and u.karma < self.rank_3.karma_min]) + ) + self.assertEqual( + len(self.rank_3.user_ids & self.users), + len([u for u in self.users if u.karma >= self.rank_3.karma_min and u.karma < self.rank_4.karma_min]) + ) + self.assertEqual( + len(self.rank_4.user_ids & self.users), + len([u for u in self.users if u.karma >= self.rank_4.karma_min]) + ) + + def test_01_switch_rank(self): + + self.assertEqual(len(self.users), 35) + + self.rank_3.karma_min = 100 + # rank_1 -> rank_3 -> rank_2 -> rank_4 + + self.assertEqual( + len(self.rank_1.user_ids & self.users), + len([u for u in self.users if u.karma >= self.rank_1.karma_min and u.karma < self.rank_3.karma_min]) + ) + self.assertEqual( + len(self.rank_3.user_ids & self.users), + len([u for u in self.users if u.karma >= self.rank_3.karma_min and u.karma < self.rank_2.karma_min]) + ) + self.assertEqual( + len(self.rank_2.user_ids & self.users), + len([u for u in self.users if u.karma >= self.rank_2.karma_min and u.karma < self.rank_4.karma_min]) + ) + self.assertEqual( + len(self.rank_4.user_ids & self.users), + len([u for u in self.users if u.karma >= self.rank_4.karma_min]) + ) + + def test_02_update_rank_without_switch(self): + number_of_users = False + + def _patched_recompute_rank(_self, *args, **kwargs): + nonlocal number_of_users + number_of_users = len(_self & self.users) + + patch_bulk = patch('odoo.addons.gamification.models.res_users.Users._recompute_rank', _patched_recompute_rank) + patch_bulk.start() + self.rank_3.karma_min = 700 + self.assertEqual(number_of_users, 7, "Should just recompute for the 7 users between 500 and 700") + patch_bulk.stop() + + def test_03_test_bulk_call(self): + self.assertEqual(len(self.users), 35) + + def _patched_check_in_bulk(*args, **kwargs): + raise + + patch_bulk = patch('odoo.addons.gamification.models.res_users.Users._recompute_rank_bulk', _patched_check_in_bulk) + patch_bulk.start() + + # call on 5 users should not trigger the bulk function + self.users[0:5]._recompute_rank() + + # call on 50 users should trigger the bulk function + with self.assertRaises(Exception): + self.users[0:50]._recompute_rank() + + patch_bulk.stop() diff --git a/addons/mail/static/src/js/activity.js b/addons/mail/static/src/js/activity.js index 607f1b8c553..77550f498f3 100644 --- a/addons/mail/static/src/js/activity.js +++ b/addons/mail/static/src/js/activity.js @@ -383,7 +383,7 @@ var BasicActivity = AbstractField.extend({ container: $markDoneBtn, title : _t("Feedback"), html: true, - trigger:'click', + trigger: 'manual', placement: 'right', // FIXME: this should work, maybe a bug in the popper lib content : function () { var $popover = $(QWeb.render('mail.activity_feedback_form', { @@ -400,6 +400,11 @@ var BasicActivity = AbstractField.extend({ $popover.find('#activity_feedback').focus(); self._bindPopoverFocusout($(this)); }).popover('show'); + } else { + var popover = $markDoneBtn.data('bs.popover'); + if ($('#' + popover.tip.id).length === 0) { + popover.show(); + } } }, /** diff --git a/addons/mail/static/tests/chatter_tests.js b/addons/mail/static/tests/chatter_tests.js index 180fddd5e3b..ade3d5d795b 100644 --- a/addons/mail/static/tests/chatter_tests.js +++ b/addons/mail/static/tests/chatter_tests.js @@ -1845,6 +1845,74 @@ QUnit.test('form activity widget: schedule next activity', async function (asser form.destroy(); }); +QUnit.test('form activity widget: do not close activity popover on click', async function (assert) { + assert.expect(3); + this.data.partner.records[0].activity_ids = [1]; + this.data.partner.records[0].activity_state = 'today'; + this.data['mail.activity'].records = [{ + id: 1, + display_name: "An activity", + date_deadline: moment().format("YYYY-MM-DD"), // now + can_write: true, + state: "today", + user_id: 2, + create_user_id: 2, + activity_type_id: 2, + }]; + + const form = await createView({ + View: FormView, + model: 'partner', + data: this.data, + services: this.services, + arch: `
+ + + +
+ + +
+
`, + res_id: 2, + mockRPC(route, args) { + if (route === '/web/dataset/call_kw/mail.activity/action_feedback_schedule_next') { + return Promise.resolve(); + } + return this._super.apply(this, arguments); + }, + intercepts: { + do_action(ev) { + ev.data.options.on_close(); + }, + }, + }); + + //Schedule next activity + await testUtils.dom.click(form.$('.o_mail_activity .o_mark_as_done[data-activity-id=1]')); + + for (let i = 0; i < 2; i++) { + // click twice in feedback area + await testUtils.dom.click(form.$('.o_mail_activity_feedback.popover textarea')); + const $popover = form.$('.o_mail_activity_feedback.popover'); + const $PopoverInDom = form.$(`#${$popover.attr('id')}`); + assert.isVisible( + $PopoverInDom, + "the feedback popover should still be visible on click"); + } + await concurrency.delay(250); // wait for popover transition + const $popover = form.$('.o_mail_activity_feedback.popover'); + if (!$popover) { + throw new Error("popover should be in DOM"); + } + const $PopoverInDom = form.$(`#${$popover.attr('id')}`); + assert.isVisible( + $PopoverInDom, + "the feedback popover should still be visible on click"); + + form.destroy(); +}); + QUnit.test('form activity widget: edit next activity', async function (assert) { assert.expect(3); diff --git a/addons/mail/wizard/mail_compose_message.py b/addons/mail/wizard/mail_compose_message.py index 95ae6372c41..a003f2e42c6 100644 --- a/addons/mail/wizard/mail_compose_message.py +++ b/addons/mail/wizard/mail_compose_message.py @@ -306,6 +306,7 @@ class MailComposer(models.TransientModel): 'attachment_ids': [attach.id for attach in self.attachment_ids], 'author_id': self.author_id.id, 'email_from': self.email_from, + 'reply_to': self.reply_to, 'record_name': self.record_name, 'no_auto_thread': self.no_auto_thread, 'mail_server_id': self.mail_server_id.id, diff --git a/addons/product/models/product_template.py b/addons/product/models/product_template.py index 4236a313c69..4be76675244 100644 --- a/addons/product/models/product_template.py +++ b/addons/product/models/product_template.py @@ -543,10 +543,12 @@ class ProductTemplate(models.Model): # deleted valid_value_ids = tmpl_id.valid_product_attribute_value_wnva_ids valid_attribute_ids = tmpl_id.valid_product_attribute_wnva_ids + seen_attributes = set(p.attribute_value_ids for p in tmpl_id.product_variant_ids if p.active) for product_id in tmpl_id.product_variant_ids: if product_id._has_valid_attributes(valid_attribute_ids, valid_value_ids): - if not product_id.active: + if not product_id.active and product_id.attribute_value_ids not in seen_attributes: variants_to_activate += product_id + seen_attributes.add(product_id.attribute_value_ids) else: variants_to_unlink += product_id diff --git a/addons/product/tests/test_variants.py b/addons/product/tests/test_variants.py index ed7f1f777c5..40d95171449 100644 --- a/addons/product/tests/test_variants.py +++ b/addons/product/tests/test_variants.py @@ -534,3 +534,286 @@ class TestVariantsImages(common.TestProductCommon): self.assertEqual(self.template.image, self.images['red']) self.assertEqual(self.variants[0].image_raw_original, False) self.assertEqual(self.variants[0].image, self.images['red']) + + +class TestVariantsArchive(common.TestProductCommon): + """Once a variant is used on orders/invoices, etc, they can't be unlinked. + As a result, updating attributes on a product template would simply archive the variants instead. + We make sure that at each update, we have the correct number of active and inactive records. + + In these tests, we use the commands sent by the JS framework to the ORM when using the interface + (even though using 3 commands would simplify the code compared to 2 commands). + + Note that: we don't overly test the ids of archived / modified variants. + In some cases _create_product_variants reuse existing variants and in other create new ones, + in a way that is not very predictable (without reading the code). + We do not enshrine the current behaviour in the tests (yet) as it could change with only moderate functional impact. + Consequently, if it is intentional the number of archived variants could change, + in that case update the test; it is there to make sure that a fix is not going to break anything silently. + The most important is to keep correct numbers of active variants. + """ + def setUp(self): + res = super(TestVariantsArchive, self).setUp() + + attribute_values = { + 'color': ['white', 'black'], + 'size': ['s', 'm'], + } + + self.attributes = {} + for attr, attr_values in attribute_values.items(): + attribute = self.env['product.attribute'].create({'name': attr}) + values = [self.env['product.attribute.value'].create({'name': name, 'attribute_id': attribute.id}) + for name in attr_values] + self.attributes.update({attr: {'a': attribute, 'v': values}}) + + attribute_line_ids = [(0, 0, { + 'attribute_id': attr['a'].id, + 'value_ids': [(6, 0, [v.id for v in attr['v']])], + }) for attr in self.attributes.values()] + + self.template = self.env['product.template'].create({ + 'name': 'consume product', + 'attribute_line_ids': attribute_line_ids, + }) + + return res + + def test_update_variant_unlink(self): + """Variants are not used anywhere, so removing an attribute line would + unlink the variants and create new ones. Nothing too fancy here. + """ + lines = self.template.attribute_line_ids + self.assertEqual(len(self.template.product_variant_ids), 4) + # we keep lines[0], remove and copy lines[1] + line_copy_command = {'attribute_id': lines[1].attribute_id.id, 'value_ids': [(6, False, lines[1].value_ids.mapped('id'))]} + self.template.write({'attribute_line_ids': [(4, lines[0].id), (2, lines[1].id)]}) + self.assertEqual(len(self.template.product_variant_ids), len(lines[0].value_ids), + "Since we only kept line[0], we should have as many variants as it has values") + archived_products = self.env['product.product'].search( + [('active', '=', False), ('product_tmpl_id', '=', self.template.id)]) + self.assertFalse(archived_products, + "Since they are used nowhere, there should not be any archived variant.") + # we re-add the line we just removed, so we should get new variants + self.template.write({ + 'attribute_line_ids': [ + (4, lines[0].id), + (0, 'virtual', line_copy_command), + ]}) + self.assertEqual(len(self.template.product_variant_ids), 4) + + def test_update_variant_archive_1_value(self): + """We do the same operations on the template as in test_update_variant_unlink, + except we simulate that the variants can't be unlinked. + It follows that variants should be archived instead, so the results should all be different from previous test. + In this test we have a line that have only one possible value: + this is handled differently than the case where we have more than one, + since in principle it does not add new variants. + """ + # we create a new template with a line with only one attribute. + # Since this does not create any additional variants, the behaviour is a little bit different: + # it tries to add the new attribute to existing variants if possible + attribute_line_ids = [(0, 0, { + 'attribute_id': attr['a'].id, + 'value_ids': [(6, 0, [v.id for v in (attr['v'] if attr['a'].display_name == 'color' else attr['v'][:1])])], + }) for attr in self.attributes.values()] + + template = self.env['product.template'].create({ + 'name': 'consume product', + 'attribute_line_ids': attribute_line_ids, + }) + + # create a patch to make as if one variant was undeletable + # (e.g. present in a field with ondelete=restrict) + Product = self.env['product.product'] + no_remove = template.product_variant_ids[0].id + def unlink(self): + if self.id == no_remove: + raise Exception('just') + else: + return super(Product.__class__, self).unlink() + Product._patch_method('unlink', unlink) + + variants_ids_history = [] + + self.assertEqual(len(template.product_variant_ids), 2) + variants_ids_history.append(template.product_variant_ids.ids) + + lines = template.attribute_line_ids + # we keep lines[0], remove and copy lines[1], which is the one with only one possible value + line_copy_command = {'attribute_id': lines[1].attribute_id.id, + 'value_ids': [(6, False, lines[1].value_ids.mapped('id'))]} + template.write({'attribute_line_ids': [(4, lines[0].id), (2, lines[1].id)]}) + self.assertEqual(len(lines[0].value_ids), 2) + self.assertEqual(len(template.product_variant_ids), len(lines[0].value_ids), + "Since we only kept line[0], we should have as many variants as it has values") + variants_ids_history.append(template.product_variant_ids.ids) + + archived_products_1 = self.env['product.product'].search( + [('active', '=', False), ('product_tmpl_id', '=', template.id)]) + self.assertEqual(len(archived_products_1), 1, + "One variant should have been unlinked, not the other.") + # we re-add the line we just removed, so we should get new variants + template.write({ + 'attribute_line_ids': [ + (4, lines[0].id), + (0, 'virtual', line_copy_command), + ]}) + self.assertEqual(len(template.product_variant_ids), 2) + variants_ids_history.append(template.product_variant_ids.ids) + + archived_products_2 = self.env['product.product'].search( + [('active', '=', False), ('product_tmpl_id', '=', template.id)]) + self.assertEqual(len(archived_products_2), 1, + "We did not reactivate this variant.") + + # tests on ids, see the doc_string + self.assertEqual(archived_products_1, archived_products_2) + self.assertEqual(len(set(variants_ids_history[0] + variants_ids_history[1])), 4, + "After the first update, we have new active variants.") + self.assertEqual(len(set(variants_ids_history[1] + variants_ids_history[2])), 2, + "After the second update, we kept the same active variants.") + + Product._revert_method('unlink') + + def test_update_variant_archive_2_value(self): + """We do the same operations on the template as in test_update_variant_unlink, + except we simulate that the variants can't be unlinked. + It follows that variants should be archived instead, so the results should all be different from previous test. + """ + Product = self.env['product.product'] + def unlink(slef): + raise Exception('just') + Product._patch_method('unlink', unlink) + variants_ids_history = [] + + self.assertEqual(len(self.template.product_variant_ids), 4) + variants_ids_history.append(self.template.product_variant_ids.ids) + + lines = self.template.attribute_line_ids + # we keep lines[0], remove and copy lines[1] + line_copy_command = {'attribute_id': lines[1].attribute_id.id, + 'value_ids': [(6, False, lines[1].value_ids.mapped('id'))]} + line_second_copy_command = {'attribute_id': lines[1].attribute_id.id, + 'value_ids': [(6, False, lines[1].value_ids[:1].mapped('id'))]} + self.template.write({'attribute_line_ids': [(4, lines[0].id), (2, lines[1].id)]}) + self.assertEqual(len(self.template.product_variant_ids), len(lines[0].value_ids), + "Since we only kept line[0], we should have as many variants as it has values") + variants_ids_history.append(self.template.product_variant_ids.ids) + + archived_products = [] + archived_products.append(self.env['product.product'].search( + [('active', '=', False), ('product_tmpl_id', '=', self.template.id)])) + self.assertEqual(len(archived_products[0]), 4, + "Since they can't be unlinked, all variants should be archived.") + # we re-add the line we just removed, so we should get new variants + self.template.write({ + 'attribute_line_ids': [ + (4, lines[0].id), + (0, 'virtual', line_copy_command), + ]}) + self.assertEqual(len(self.template.product_variant_ids), 4) + variants_ids_history.append(self.template.product_variant_ids.ids) + + archived_products.append(self.env['product.product'].search( + [('active', '=', False), ('product_tmpl_id', '=', self.template.id)])) + self.assertEqual(len(archived_products[1]), 2, + "Since they can't be unlinked, all previous variants should be archived.") + + # we redo the whole remove/readd to check + lines = self.template.attribute_line_ids + self.template.write({'attribute_line_ids': [(4, lines[0].id), (2, lines[1].id)]}) + self.assertEqual(len(self.template.product_variant_ids), 2) + variants_ids_history.append(self.template.product_variant_ids.ids) + archived_products.append(self.env['product.product'].search( + [('active', '=', False), ('product_tmpl_id', '=', self.template.id)])) + self.template.write({ + 'attribute_line_ids': [ + (4, lines[0].id), + (0, 'virtual', line_copy_command), + ]}) + self.assertEqual(len(self.template.product_variant_ids), 4) + variants_ids_history.append(self.template.product_variant_ids.ids) + archived_products.append(self.env['product.product'].search( + [('active', '=', False), ('product_tmpl_id', '=', self.template.id)])) + self.assertEqual(len(archived_products[3]), 2) + + # now we test when we try to add the value back on existing products + lines = self.template.attribute_line_ids + self.template.write({'attribute_line_ids': [(4, lines[0].id), (2, lines[1].id)]}) + self.assertEqual(len(self.template.product_variant_ids), 2) + variants_ids_history.append(self.template.product_variant_ids.ids) + archived_products.append(self.env['product.product'].search( + [('active', '=', False), ('product_tmpl_id', '=', self.template.id)])) + self.assertEqual(len(archived_products[4]), 4) + # this time we only add one of the two attributes we've been removing + self.template.write({ + 'attribute_line_ids': [ + (4, lines[0].id), + (0, 'virtual', line_second_copy_command), + ]}) + self.assertEqual(len(self.template.product_variant_ids), 2) + variants_ids_history.append(self.template.product_variant_ids.ids) + archived_products.append(self.env['product.product'].search( + [('active', '=', False), ('product_tmpl_id', '=', self.template.id)])) + self.assertEqual(len(archived_products[5]), 4) + + Product._revert_method('unlink') + + def test_update_variant_archive_3_value(self): + """In this one, we have unique values for one lines, and one line with two values. + We first remove the unique line to populate archived variants, then remove the two values line. + Finally, we re-add athe two lines, bringing us back to the first situation: + we should not have any more than two variants (rest should be archived) + """ + attribute_line_ids = [(0, 0, { + 'attribute_id': attr['a'].id, + 'value_ids': [(6, 0, [v.id for v in (attr['v'] if attr['a'].display_name == 'color' else attr['v'][:1])])], + }) for attr in self.attributes.values()] + + template = self.env['product.template'].create({ + 'name': 'consume product', + 'attribute_line_ids': attribute_line_ids, + }) + + Product = self.env['product.product'] + def unlink(slef): + raise Exception('just') + Product._patch_method('unlink', unlink) + + variants_ids_history = [] + self.assertEqual(len(template.product_variant_ids), 2) + variants_ids_history.append(template.product_variant_ids.ids) + + lines = template.attribute_line_ids + + template.write({'attribute_line_ids': [(4, lines[0].id), (2, lines[1].id)]}) + self.assertEqual(len(template.product_variant_ids), len(lines[0].value_ids), + "Since we only kept line[0], we should have as many variants as it has values") + variants_ids_history.append(template.product_variant_ids.ids) + + archived_products = [] + archived_products.append(self.env['product.product'].search( + [('active', '=', False), ('product_tmpl_id', '=', template.id)])) + self.assertEqual(len(archived_products[0]), 2, + "Since they can't be unlinked, all variants should be archived.") + + template.write({'attribute_line_ids': [(2, lines[0].id)]}) + self.assertEqual(len(template.product_variant_ids), 1) + variants_ids_history.append(template.product_variant_ids.ids) + + archived_products.append(self.env['product.product'].search( + [('active', '=', False), ('product_tmpl_id', '=', template.id)])) + self.assertEqual(len(archived_products[1]), 4, + "Since they can't be unlinked, all previous variants should be archived.") + + # we re-add everything: + template.write({'attribute_line_ids': attribute_line_ids}) + + archived_products.append(self.env['product.product'].search( + [('active', '=', False), ('product_tmpl_id', '=', template.id)])) + self.assertEqual(len(template.product_variant_ids), 2) + self.assertEqual(len(archived_products[2]), 3, + "We should have re-activated one variant only.") + + Product._revert_method('unlink') diff --git a/addons/purchase/views/purchase_views.xml b/addons/purchase/views/purchase_views.xml index 77b3cc83152..c651637bc89 100644 --- a/addons/purchase/views/purchase_views.xml +++ b/addons/purchase/views/purchase_views.xml @@ -172,7 +172,7 @@ placeholder="Name, TIN, Email, or Reference" /> - + diff --git a/addons/sale_management/models/sale_order.py b/addons/sale_management/models/sale_order.py index 6a95dfeaeeb..1b8562b1c54 100644 --- a/addons/sale_management/models/sale_order.py +++ b/addons/sale_management/models/sale_order.py @@ -72,7 +72,11 @@ class SaleOrder(models.Model): price = self.pricelist_id.with_context(uom=line.product_uom_id.id).get_product_price(line.product_id, 1, False) if self.pricelist_id.discount_policy == 'without_discount' and line.price_unit: discount = (line.price_unit - price) / line.price_unit * 100 - price = line.price_unit + # negative discounts (= surcharge) are included in the display price + if discount < 0: + discount = 0 + else: + price = line.price_unit else: price = line.price_unit diff --git a/addons/sale_management/views/sale_order_template_views.xml b/addons/sale_management/views/sale_order_template_views.xml index d049e2925ba..7f93a97091a 100644 --- a/addons/sale_management/views/sale_order_template_views.xml +++ b/addons/sale_management/views/sale_order_template_views.xml @@ -53,7 +53,7 @@
- +