OCA / product-variant / 562

pending completion

Build # 562

Build Type

Pull #91

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/OCA/product-variant/commit/<a class=hub.com/OCA/product-variant/commit/<a class="double-link" href="https://git"><a class=hub.com/OCA/product-variant/commit/<a class="double-link" href="https://git"><a class=hub.com/OCA/product-variant/commit/<a class="double-link" href="https://git"><a class=hub.com/OCA/product-variant/commit/8d36705c799d75a9267e2ddfd4e352c65c5e9262">8d36705c7">&lt;a href=&quot;https://github.com/OCA/product-variant/commit/</a><a class="double-link" href="https://github.com/OCA/product-variant/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OCA/product-variant/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OCA/product-variant/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OCA/product-variant/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OCA/product-variant/commit/8d36705c799d75a9267e2ddfd4e352c65c5e9262">8d36705c7</a><a href="https://github.com/OCA/product-variant/commit/8d36705c799d75a9267e2ddfd4e352c65c5e9262">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/OCA/product-variant/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/OCA/product-variant/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/OCA/product-variant/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/OCA/product-variant/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/OCA/product-variant/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/OCA/product-variant/commit/8d36705c799d75a9267e2ddfd4e352c65c5e9262&quot;&gt;8d36705c7&lt;/a&gt;&lt;a href=&quot;https://github.com/OCA/product-variant/commit/8d36705c799d75a9267e2ddfd4e352c65c5e9262&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/OCA/product-variant/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/OCA/pro... (continued)

Pull Request Pull Request #91:

Run Details

114 of 114 new or added lines in 2 files covered. (100.0%)

112 of 114 relevant lines covered (98.25%)

1.96 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.18

/product_variant_default_code/models/product.py

# -*- coding: utf-8 -*-
# Copyright 2014 AvancOSC - Alfredo de la Fuente
# Copyright 2014 Tecnativa - Pedro M. Baeza
# Copyright 2014 Shine IT - Tony Gu
# Copyright 2017 Tecnativa - David Vidal
# Copyright 2018 Avanzosc S.L. - Daniel Campos
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).

from odoo import _, api, fields, models
from odoo.exceptions import UserError
import re
from string import Template
from collections import defaultdict


class ReferenceMask(Template):
    pattern = r'''\[(?:
                    (?P<escaped>\[) |
                    (?P<named>[^\]]+?)\] |
                    (?P<braced>[^\]]+?)\] |
                    (?P<invalid>)
                    )'''


def extract_token(s):
    pattern = re.compile(r'\[([^\]]+?)\]')
    return set(pattern.findall(s))


def sanitize_reference_mask(product, mask):
    main_lang = product._guess_main_lang()
    tokens = extract_token(mask)
    attribute_names = set()
    for line in product.attribute_line_ids:
        attribute_names.add(
            line.attribute_id.with_context(lang=main_lang).name)
    if not tokens.issubset(attribute_names):
        raise UserError(_('Found unrecognized attribute name in "Variant '
                          'Reference Mask"'))


def get_rendered_default_code(product, mask):
    product_attrs = defaultdict(str)
    reference_mask = ReferenceMask(mask)
    main_lang = product.product_tmpl_id._guess_main_lang()
    for value in product.attribute_value_ids:
        attr_name = value.attribute_id.with_context(lang=main_lang).name
        if value.attribute_id.code:
            product_attrs[attr_name] += value.attribute_id.code
        if value.code:
            product_attrs[attr_name] += value.code
    all_attrs = extract_token(mask)
    missing_attrs = all_attrs - set(product_attrs.keys())
    missing = dict.fromkeys(
        missing_attrs,
        product.env['ir.config_parameter'].get_param(
            'default_reference_missing_placeholder'))
    product_attrs.update(missing)
    default_code = reference_mask.safe_substitute(product_attrs)
    return default_code


def render_default_code(product, mask):
    product.default_code = get_rendered_default_code(product, mask)


class ProductTemplate(models.Model):
    _inherit = 'product.template'

    code_prefix = fields.Char(
        string='Reference Prefix', oldname='prefix_code',
        help='Add prefix to product variant reference (default code)',
    )
    reference_mask = fields.Char(
        string='Variant reference mask', copy=False,
        help='Reference mask for building internal references of a '
             'variant generated from this template.\n'

             'Example:\n'
             'A product named ABC with 2 attributes: Size and Color:\n'

             'Product: ABC\n'
             'Color: Red(r), Yellow(y), Black(b)  #Red, Yellow, Black are '
             'the attribute value, `r`, `y`, `b` are the corresponding code\n'
             'Size: L (l), XL(x)\n'

             'When setting Variant reference mask to `[Color]-[Size]`, the '
             'default code on the variants will be something like `r-l` '
             '`b-l` `r-x` ...\n'

             'If you like, You can even have the attribute name appear more'
             ' than once in the mask. Such as,'
             '`fancyA/[Size]~[Color]~[Size]`\n'
             ' When saved, the default code on variants will be '
             'something like \n'
             ' `fancyA/l~r~l` (for variant with Color "Red" and Size "L") '
             ' `fancyA/x~y~x` (for variant with Color "Yellow" and Size "XL")'

             '\nNote: make sure characters "[,]" do not appear in your '
             'attribute name')

    def _get_default_mask(self):
        attribute_names = []
        default_reference_separator = self.env[
            'ir.config_parameter'].get_param('default_reference_separator')
        for line in self.attribute_line_ids:
            attribute_names.append(u"[{}]".format(line.attribute_id.name))
        default_mask = ((self.code_prefix or '') +
                        default_reference_separator.join(attribute_names))
        return default_mask

    @api.model
    def create(self, vals):
        product = self.new(vals)
        if (not vals.get('reference_mask') and product.attribute_line_ids or
                not self.user_has_groups(
                    'product_variant_default_code.group_product_default_code'
                )):
            vals['reference_mask'] = product._get_default_mask()
        elif vals.get('reference_mask'):
            sanitize_reference_mask(product, vals['reference_mask'])
        return super(ProductTemplate, self).create(vals)

    def write(self, vals):
        product_obj = self.env['product.product']
        if ('reference_mask' in vals and not vals['reference_mask'] or not
                self.user_has_groups(
                    'product_variant_default_code.group_product_default_code'
                )):
            if self.attribute_line_ids:
                vals['reference_mask'] = self._get_default_mask()
        result = super(ProductTemplate, self).write(vals)
        if vals.get('reference_mask'):
            cond = [('product_tmpl_id', '=', self.id),
                    ('manual_code', '=', False)]
            products = product_obj.search(cond)
            for product in products:
                if product.reference_mask:
                    render_default_code(product, product.reference_mask)
        return result

    @api.model
    def _guess_main_lang(self):
        """ Used by get_rendered_default_code()
        """
        english = self.env.ref('base.lang_en')
        if english.active:
            return english.code
        else:
            # Naive/simple implementation:
            # you may inherit to override it in your custom code
            # to return the language code of your choice
            return self.env['res.lang'].search([], limit=1).code


class ProductProduct(models.Model):
    _inherit = 'product.product'

    manual_code = fields.Boolean(string='Manual Reference')

    @api.model
    def create(self, vals):
        product = super(ProductProduct, self).create(vals)
        if product.reference_mask:
            render_default_code(product, product.reference_mask)
        return product

    @api.onchange('default_code')
    def onchange_default_code(self):
        self.manual_code = bool(self.default_code)


class ProductAttribute(models.Model):
    _inherit = 'product.attribute'

    code = fields.Char(
        string='Attribute Code',
    )

    _sql_constraints = [
        ('number_uniq', 'unique(name)', _('Attribute Name must be unique!'))]

    def write(self, vals):
        if 'code' not in vals:
            return super(ProductAttribute, self).write(vals)
        result = super(ProductAttribute, self).write(vals)
        # Rewrite reference on all product variants affected
        for product in self.mapped(
                'attribute_line_ids.product_tmpl_id.product_variant_ids').\
                filtered(lambda x: x.product_tmpl_id.reference_mask and not
                         x.manual_code):
            render_default_code(product, product.reference_mask)
        return result


class ProductAttributeValue(models.Model):
    _inherit = 'product.attribute.value'

    @api.onchange('name')
    def onchange_name(self):
        if self.name:
            self.code = self.name[0:2]

    code = fields.Char(
        string='Attribute Value Code',
        default=onchange_name,
        oldname='attribute_code',
    )

    @api.model
    def create(self, vals):
        if 'code' not in vals:
            vals['code'] = vals.get('name', '')[0:2]
        return super(ProductAttributeValue, self).create(vals)

    def write(self, vals):
        if 'code' not in vals:
            return super(ProductAttributeValue, self).write(vals)
        result = super(ProductAttributeValue, self).write(vals)
        # Rewrite reference on all product variants affected
        for product in self.mapped('product_ids').filtered(
                lambda x: x.product_tmpl_id.reference_mask and not
                x.manual_code
                ).mapped('product_tmpl_id.product_variant_ids'):
            render_default_code(product, product.reference_mask)
        return result

1	# -- coding: utf-8 --
2	# Copyright 2014 AvancOSC - Alfredo de la Fuente
3	# Copyright 2014 Tecnativa - Pedro M. Baeza
4	# Copyright 2014 Shine IT - Tony Gu
5	# Copyright 2017 Tecnativa - David Vidal
6	# Copyright 2018 Avanzosc S.L. - Daniel Campos
7	# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
8
9	from odoo import _, api, fields, models	2✔
10	from odoo.exceptions import UserError	2✔
11	import re	2✔
12	from string import Template	2✔
13	from collections import defaultdict	2✔
14
15
16	class ReferenceMask(Template):	2✔
17	pattern = r'''\[(?:	2✔
18	(?P<escaped>\[) \|
19	(?P<named>[^\]]+?)\] \|
20	(?P<braced>[^\]]+?)\] \|
21	(?P<invalid>)
22	)'''
23
24
25	def extract_token(s):	2✔
26	pattern = re.compile(r'\[([^\]]+?)\]')	2✔
27	return set(pattern.findall(s))	2✔
28
29
30	def sanitize_reference_mask(product, mask):	2✔
31	main_lang = product._guess_main_lang()	2✔
32	tokens = extract_token(mask)	2✔
33	attribute_names = set()	2✔
34	for line in product.attribute_line_ids:	2✔
35	attribute_names.add(	2✔
36	line.attribute_id.with_context(lang=main_lang).name)
37	if not tokens.issubset(attribute_names):	2✔
38	raise UserError(_('Found unrecognized attribute name in "Variant '	2✔
39	'Reference Mask"'))
40
41
42	def get_rendered_default_code(product, mask):	2✔
43	product_attrs = defaultdict(str)	2✔
44	reference_mask = ReferenceMask(mask)	2✔
45	main_lang = product.product_tmpl_id._guess_main_lang()	2✔
46	for value in product.attribute_value_ids:	2✔
47	attr_name = value.attribute_id.with_context(lang=main_lang).name	2✔
48	if value.attribute_id.code:	2✔
49	product_attrs[attr_name] += value.attribute_id.code	2✔
50	if value.code:	2✔
51	product_attrs[attr_name] += value.code	2✔
52	all_attrs = extract_token(mask)	2✔
53	missing_attrs = all_attrs - set(product_attrs.keys())	2✔
54	missing = dict.fromkeys(	2✔
55	missing_attrs,
56	product.env['ir.config_parameter'].get_param(
57	'default_reference_missing_placeholder'))
58	product_attrs.update(missing)	2✔
59	default_code = reference_mask.safe_substitute(product_attrs)	2✔
60	return default_code	2✔
61
62
63	def render_default_code(product, mask):	2✔
64	product.default_code = get_rendered_default_code(product, mask)	2✔
65
66
67	class ProductTemplate(models.Model):	2✔
68	_inherit = 'product.template'	2✔
69
70	code_prefix = fields.Char(	2✔
71	string='Reference Prefix', oldname='prefix_code',
72	help='Add prefix to product variant reference (default code)',
73	)
74	reference_mask = fields.Char(	2✔
75	string='Variant reference mask', copy=False,
76	help='Reference mask for building internal references of a '
77	'variant generated from this template.\n'
78
79	'Example:\n'
80	'A product named ABC with 2 attributes: Size and Color:\n'
81
82	'Product: ABC\n'
83	'Color: Red(r), Yellow(y), Black(b) #Red, Yellow, Black are '
84	'the attribute value, `r`, `y`, `b` are the corresponding code\n'
85	'Size: L (l), XL(x)\n'
86
87	'When setting Variant reference mask to `[Color]-[Size]`, the '
88	'default code on the variants will be something like `r-l` '
89	'`b-l` `r-x` ...\n'
90
91	'If you like, You can even have the attribute name appear more'
92	' than once in the mask. Such as,'
93	'`fancyA/[Size]~[Color]~[Size]`\n'
94	' When saved, the default code on variants will be '
95	'something like \n'
96	' `fancyA/l~r~l` (for variant with Color "Red" and Size "L") '
97	' `fancyA/x~y~x` (for variant with Color "Yellow" and Size "XL")'
98
99	'\nNote: make sure characters "[,]" do not appear in your '
100	'attribute name')
101
102	def _get_default_mask(self):	2✔
103	attribute_names = []	2✔
104	default_reference_separator = self.env[	2✔
105	'ir.config_parameter'].get_param('default_reference_separator')
106	for line in self.attribute_line_ids:	2✔
107	attribute_names.append(u"[{}]".format(line.attribute_id.name))	2✔
108	default_mask = ((self.code_prefix or '') +	2✔
109	default_reference_separator.join(attribute_names))
110	return default_mask	2✔
111
112	@api.model	2✔
113	def create(self, vals):
114	product = self.new(vals)	2✔
115	if (not vals.get('reference_mask') and product.attribute_line_ids or	2✔
116	not self.user_has_groups(
117	'product_variant_default_code.group_product_default_code'
118	)):
119	vals['reference_mask'] = product._get_default_mask()	2✔
120	elif vals.get('reference_mask'):	2✔
121	sanitize_reference_mask(product, vals['reference_mask'])	2✔
122	return super(ProductTemplate, self).create(vals)	2✔
123
124	def write(self, vals):	2✔
125	product_obj = self.env['product.product']	2✔
126	if ('reference_mask' in vals and not vals['reference_mask'] or not	2✔
127	self.user_has_groups(
128	'product_variant_default_code.group_product_default_code'
129	)):
130	if self.attribute_line_ids:	2✔
131	vals['reference_mask'] = self._get_default_mask()	2✔
132	result = super(ProductTemplate, self).write(vals)	2✔
133	if vals.get('reference_mask'):	2✔
134	cond = [('product_tmpl_id', '=', self.id),	2✔
135	('manual_code', '=', False)]
136	products = product_obj.search(cond)	2✔
137	for product in products:	2✔
138	if product.reference_mask:	2✔
139	render_default_code(product, product.reference_mask)	2✔
140	return result	2✔
141
142	@api.model	2✔
143	def _guess_main_lang(self):
144	""" Used by get_rendered_default_code()
145	"""
146	english = self.env.ref('base.lang_en')	2✔
147	if english.active:	2✔
148	return english.code	2✔
149	else:
150	# Naive/simple implementation:
151	# you may inherit to override it in your custom code
152	# to return the language code of your choice
153	return self.env['res.lang'].search([], limit=1).code	×
154
155
156	class ProductProduct(models.Model):	2✔
157	_inherit = 'product.product'	2✔
158
159	manual_code = fields.Boolean(string='Manual Reference')	2✔
160
161	@api.model	2✔
162	def create(self, vals):
163	product = super(ProductProduct, self).create(vals)	2✔
164	if product.reference_mask:	2✔
165	render_default_code(product, product.reference_mask)	2✔
166	return product	2✔
167
168	@api.onchange('default_code')	2✔
169	def onchange_default_code(self):
170	self.manual_code = bool(self.default_code)	2✔
171
172
173	class ProductAttribute(models.Model):	2✔
174	_inherit = 'product.attribute'	2✔
175
176	code = fields.Char(	2✔
177	string='Attribute Code',
178	)
179
180	_sql_constraints = [	2✔
181	('number_uniq', 'unique(name)', _('Attribute Name must be unique!'))]
182
183	def write(self, vals):	2✔
184	if 'code' not in vals:	2✔
185	return super(ProductAttribute, self).write(vals)	×
186	result = super(ProductAttribute, self).write(vals)	2✔
187	# Rewrite reference on all product variants affected
188	for product in self.mapped(	2✔
189	'attribute_line_ids.product_tmpl_id.product_variant_ids').\
190	filtered(lambda x: x.product_tmpl_id.reference_mask and not
191	x.manual_code):
192	render_default_code(product, product.reference_mask)	2✔
193	return result	2✔
194
195
196	class ProductAttributeValue(models.Model):	2✔
197	_inherit = 'product.attribute.value'	2✔
198
199	@api.onchange('name')	2✔
200	def onchange_name(self):
201	if self.name:	2✔
202	self.code = self.name[0:2]	2✔
203
204	code = fields.Char(	2✔
205	string='Attribute Value Code',
206	default=onchange_name,
207	oldname='attribute_code',
208	)
209
210	@api.model	2✔
211	def create(self, vals):
212	if 'code' not in vals:	2✔
213	vals['code'] = vals.get('name', '')[0:2]	2✔
214	return super(ProductAttributeValue, self).create(vals)	2✔
215
216	def write(self, vals):	2✔
217	if 'code' not in vals:	2✔
218	return super(ProductAttributeValue, self).write(vals)	2✔
219	result = super(ProductAttributeValue, self).write(vals)	2✔
220	# Rewrite reference on all product variants affected
221	for product in self.mapped('product_ids').filtered(	2✔
222	lambda x: x.product_tmpl_id.reference_mask and not
223	x.manual_code
224	).mapped('product_tmpl_id.product_variant_ids'):
225	render_default_code(product, product.reference_mask)	2✔
226	return result	2✔

OCA / product-variant / 562

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous