from openerp import SUPERUSER_ID
from openerp import tools
-from openerp.osv import osv, fields
+from openerp.osv import osv, fields, expression
from openerp.tools.translate import _
from openerp.tools import DEFAULT_SERVER_DATETIME_FORMAT
import psycopg2
import openerp.addons.decimal_precision as dp
+from openerp.tools.float_utils import float_round, float_compare
def ean_checksum(eancode):
"""returns the checksum of an ean string of length 13, returns -1 if the string has the wrong length"""
'name': fields.char('Unit of Measure', required=True, translate=True),
'category_id': fields.many2one('product.uom.categ', 'Product Category', required=True, ondelete='cascade',
help="Conversion between Units of Measure can only occur if they belong to the same category. The conversion will be made based on the ratios."),
- 'factor': fields.float('Ratio', required=True,digits=(12, 12),
+ 'factor': fields.float('Ratio', required=True, digits=0, # force NUMERIC with unlimited precision
help='How much bigger or smaller this unit is compared to the reference Unit of Measure for this category:\n'\
'1 * (reference unit) = ratio * (this unit)'),
- 'factor_inv': fields.function(_factor_inv, digits=(12,12),
+ 'factor_inv': fields.function(_factor_inv, digits=0, # force NUMERIC with unlimited precision
fnct_inv=_factor_inv_write,
string='Bigger Ratio',
help='How many times this Unit of Measure is bigger than the reference Unit of Measure in this category:\n'\
'1 * (this unit) = ratio * (reference unit)', required=True),
- 'rounding': fields.float('Rounding Precision', digits_compute=dp.get_precision('Product Unit of Measure'), required=True,
+ 'rounding': fields.float('Rounding Precision', digits=0, required=True,
help="The computed quantity will be a multiple of this value. "\
"Use 1.0 for a Unit of Measure that cannot be further split, such as a piece."),
'active': fields.boolean('Active', help="By unchecking the active field you can disable a unit of measure without deleting it."),
_defaults = {
'active': 1,
'rounding': 0.01,
+ 'factor': 1,
'uom_type': 'reference',
+ 'factor': 1.0,
}
_sql_constraints = [
('factor_gt_zero', 'CHECK (factor!=0)', 'The conversion ratio for a unit of measure cannot be 0!')
]
- def _compute_qty(self, cr, uid, from_uom_id, qty, to_uom_id=False, round=True):
+ def _compute_qty(self, cr, uid, from_uom_id, qty, to_uom_id=False, round=True, rounding_method='UP'):
if not from_uom_id or not qty or not to_uom_id:
return qty
uoms = self.browse(cr, uid, [from_uom_id, to_uom_id])
from_unit, to_unit = uoms[0], uoms[-1]
else:
from_unit, to_unit = uoms[-1], uoms[0]
- return self._compute_qty_obj(cr, uid, from_unit, qty, to_unit, round=round)
+ return self._compute_qty_obj(cr, uid, from_unit, qty, to_unit, round=round, rounding_method=rounding_method)
- def _compute_qty_obj(self, cr, uid, from_unit, qty, to_unit, round=True, context=None):
+ def _compute_qty_obj(self, cr, uid, from_unit, qty, to_unit, round=True, rounding_method='UP', context=None):
if context is None:
context = {}
if from_unit.category_id.id != to_unit.category_id.id:
raise osv.except_osv(_('Error!'), _('Conversion from Product UoM %s to Default UoM %s is not possible as they both belong to different Category!.') % (from_unit.name,to_unit.name,))
else:
return qty
- amount = qty / from_unit.factor
+ amount = qty/from_unit.factor
if to_unit:
amount = amount * to_unit.factor
if round:
- amount = ceiling(amount, to_unit.rounding)
+ amount = float_round(amount, precision_rounding=to_unit.rounding, rounding_method=rounding_method)
return amount
def _compute_price(self, cr, uid, from_uom_id, price, to_uom_id=False):
'price_extra': value,
}, context=context)
+ def name_get(self, cr, uid, ids, context=None):
+ if context and not context.get('show_attribute', True):
+ return super(product_attribute_value, self).name_get(cr, uid, ids, context=context)
+ res = []
+ for value in self.browse(cr, uid, ids, context=context):
+ res.append([value.id, "%s: %s" % (value.attribute_id.name, value.name)])
+ return res
+
_columns = {
'sequence': fields.integer('Sequence', help="Determine the display order"),
'name': fields.char('Value', translate=True, required=True),
_name = "product.template"
_inherit = ['mail.thread']
_description = "Product Template"
+ _order = "name"
def _get_image(self, cr, uid, ids, name, args, context=None):
result = dict.fromkeys(ids, False)
'active': fields.boolean('Active', help="If unchecked, it will allow you to hide the product without removing it."),
'color': fields.integer('Color Index'),
- 'is_product_variant': fields.function( _is_product_variant, type='boolean', string='Only one product variant'),
+ 'is_product_variant': fields.function( _is_product_variant, type='boolean', string='Is product variant'),
'attribute_line_ids': fields.one2many('product.attribute.line', 'product_tmpl_id', 'Product Attributes'),
'product_variant_ids': fields.one2many('product.product', 'product_tmpl_id', 'Products', required=True),
res = {}
product_uom_obj = self.pool.get('product.uom')
for product in products:
- res[product.id] = product[ptype] or 0.0
+ # standard_price field can only be seen by users in base.group_user
+ # Thus, in order to compute the sale price from the cost price for users not in this group
+ # We fetch the standard price as the superuser
+ if ptype != 'standard_price':
+ res[product.id] = product[ptype] or 0.0
+ else:
+ company_id = product.env.user.company_id.id
+ product = product.with_context(force_company=company_id)
+ res[product.id] = res[product.id] = product.sudo()[ptype]
if ptype == 'list_price':
res[product.id] += product._name == "product.product" and product.price_extra or 0.0
if 'uom' in context:
for tmpl_id in tmpl_ids:
# list of values combination
+ variant_alone = []
all_variants = [[]]
for variant_id in tmpl_id.attribute_line_ids:
- if len(variant_id.value_ids) > 1:
- temp_variants = []
+ if len(variant_id.value_ids) == 1:
+ variant_alone.append(variant_id.value_ids[0])
+ temp_variants = []
+ for variant in all_variants:
for value_id in variant_id.value_ids:
- for variant in all_variants:
- temp_variants.append(variant + [int(value_id)])
- all_variants = temp_variants
+ temp_variants.append(variant + [int(value_id)])
+ all_variants = temp_variants
+
+ # adding an attribute with only one value should not recreate product
+ # write this attribute on every product to make sure we don't lose them
+ for variant_id in variant_alone:
+ product_ids = []
+ for product_id in tmpl_id.product_variant_ids:
+ if variant_id.id not in map(int, product_id.attribute_value_ids):
+ product_ids.append(product_id.id)
+ product_obj.write(cr, uid, product_ids, {'attribute_value_ids': [(4, variant_id.id)]}, context=ctx)
# check product
variant_ids_to_active = []
context['uom'], value, uom.id)
value = value - product.price_extra
- return product.write({'list_price': value}, context=context)
+ return product.write({'list_price': value})
def _get_partner_code_name(self, cr, uid, ids, product, partner_id, context=None):
for supinfo in product.seller_ids:
res = self.write(cr, uid, [id], {'image_variant': image}, context=context)
product = self.browse(cr, uid, id, context=context)
if not product.product_tmpl_id.image:
- product.write({'image_variant': None}, context=context)
- product.product_tmpl_id.write({'image': image}, context=context)
+ product.write({'image_variant': None})
+ product.product_tmpl_id.write({'image': image})
return res
def _get_price_extra(self, cr, uid, ids, name, args, context=None):
_columns = {
'price': fields.function(_product_price, type='float', string='Price', digits_compute=dp.get_precision('Product Price')),
- 'price_extra': fields.function(_get_price_extra, type='float', string='Variant Extra Price', help="This is le sum of the extra price of all attributes"),
+ 'price_extra': fields.function(_get_price_extra, type='float', string='Variant Extra Price', help="This is the sum of the extra price of all attributes"),
'lst_price': fields.function(_product_lst_price, fnct_inv=_set_product_lst_price, type='float', string='Public Price', digits_compute=dp.get_precision('Product Price')),
'code': fields.function(_product_code, type='char', string='Internal Reference'),
'partner_ref' : fields.function(_product_partner_ref, type='char', string='Customer ref'),
'product.product': (lambda self, cr, uid, ids, c=None: ids, [], 10),
}, select=True),
'attribute_value_ids': fields.many2many('product.attribute.value', id1='prod_id', id2='att_id', string='Attributes', readonly=True, ondelete='restrict'),
+ 'is_product_variant': fields.function( _is_product_variant_impl, type='boolean', string='Is product variant'),
# image: all image fields are base64 encoded and PIL-supported
'image_variant': fields.binary("Variant Image",
return (d['id'], name)
partner_id = context.get('partner_id', False)
+ if partner_id:
+ partner_ids = [partner_id, self.pool['res.partner'].browse(cr, user, partner_id, context=context).commercial_partner_id.id]
+ else:
+ partner_ids = []
# all user don't have access to seller and partner
# check access and use superuser
variant = ", ".join([v.name for v in product.attribute_value_ids])
name = variant and "%s (%s)" % (product.name, variant) or product.name
sellers = []
- if partner_id:
- sellers = filter(lambda x: x.name.id == partner_id, product.seller_ids)
+ if partner_ids:
+ sellers = filter(lambda x: x.name.id in partner_ids, product.seller_ids)
if sellers:
for s in sellers:
+ seller_variant = s.product_name and "%s (%s)" % (s.product_name, variant) or False
mydict = {
'id': product.id,
- 'name': s.product_name or name,
+ 'name': seller_variant or name,
'default_code': s.product_code or product.default_code,
}
result.append(_name_get(mydict))
if not args:
args = []
if name:
- ids = self.search(cr, user, [('default_code','=',name)]+ args, limit=limit, context=context)
- if not ids:
- ids = self.search(cr, user, [('ean13','=',name)]+ args, limit=limit, context=context)
- if not ids:
+ positive_operators = ['=', 'ilike', '=ilike', 'like', '=like']
+ ids = []
+ if operator in positive_operators:
+ ids = self.search(cr, user, [('default_code','=',name)]+ args, limit=limit, context=context)
+ if not ids:
+ ids = self.search(cr, user, [('ean13','=',name)]+ args, limit=limit, context=context)
+ if not ids and operator not in expression.NEGATIVE_TERM_OPERATORS:
# Do not merge the 2 next lines into one single search, SQL search performance would be abysmal
# on a database with thousands of matching products, due to the huge merge+unique needed for the
# OR operator (and given the fact that the 'name' lookup results come from the ir.translation table
if not limit or len(ids) < limit:
# we may underrun the limit because of dupes in the results, that's fine
limit2 = (limit - len(ids)) if limit else False
- ids.update(self.search(cr, user, args + [('name', operator, name)], limit=limit2, context=context))
+ ids.update(self.search(cr, user, args + [('name', operator, name), ('id', 'not in', list(ids))], limit=limit2, context=context))
ids = list(ids)
- if not ids:
+ elif not ids and operator in expression.NEGATIVE_TERM_OPERATORS:
+ ids = self.search(cr, user, args + ['&', ('default_code', operator, name), ('name', operator, name)], limit=limit, context=context)
+ if not ids and operator in positive_operators:
ptrn = re.compile('(\[(.*?)\])')
res = ptrn.search(name)
if res:
def need_procurement(self, cr, uid, ids, context=None):
return False
+ def _compute_uos_qty(self, cr, uid, ids, uom, qty, uos, context=None):
+ '''
+ Computes product's invoicing quantity in UoS from quantity in UoM.
+ Takes into account the
+ :param uom: Source unit
+ :param qty: Source quantity
+ :param uos: Target UoS unit.
+ '''
+ if not uom or not qty or not uos:
+ return qty
+ uom_obj = self.pool['product.uom']
+ product_id = ids[0] if isinstance(ids, (list, tuple)) else ids
+ product = self.browse(cr, uid, product_id, context=context)
+ if isinstance(uos, (int, long)):
+ uos = uom_obj.browse(cr, uid, uos, context=context)
+ if isinstance(uom, (int, long)):
+ uom = uom_obj.browse(cr, uid, uom, context=context)
+ if product.uos_id: # Product has UoS defined
+ # We cannot convert directly between units even if the units are of the same category
+ # as we need to apply the conversion coefficient which is valid only between quantities
+ # in product's default UoM/UoS
+ qty_default_uom = uom_obj._compute_qty_obj(cr, uid, uom, qty, product.uom_id) # qty in product's default UoM
+ qty_default_uos = qty_default_uom * product.uos_coeff
+ return uom_obj._compute_qty_obj(cr, uid, product.uos_id, qty_default_uos, uos)
+ else:
+ return uom_obj._compute_qty_obj(cr, uid, uom, qty, uos)
+
+
class product_packaging(osv.osv):
_name = "product.packaging"
'delay': 1,
'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'product.supplierinfo', context=c),
}
- def price_get(self, cr, uid, supplier_ids, product_id, product_qty=1, context=None):
- """
- Calculate price from supplier pricelist.
- @param supplier_ids: Ids of res.partner object.
- @param product_id: Id of product.
- @param product_qty: specify quantity to purchase.
- """
- if type(supplier_ids) in (int,long,):
- supplier_ids = [supplier_ids]
- res = {}
- product_pool = self.pool.get('product.product')
- partner_pool = self.pool.get('res.partner')
- pricelist_pool = self.pool.get('product.pricelist')
- currency_pool = self.pool.get('res.currency')
- currency_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id.id
- # Compute price from standard price of product
- product_price = product_pool.price_get(cr, uid, [product_id], 'standard_price', context=context)[product_id]
- product = product_pool.browse(cr, uid, product_id, context=context)
- for supplier in partner_pool.browse(cr, uid, supplier_ids, context=context):
- price = product_price
- # Compute price from Purchase pricelist of supplier
- pricelist_id = supplier.property_product_pricelist_purchase.id
- if pricelist_id:
- price = pricelist_pool.price_get(cr, uid, [pricelist_id], product_id, product_qty, context=context).setdefault(pricelist_id, 0)
- price = currency_pool.compute(cr, uid, pricelist_pool.browse(cr, uid, pricelist_id).currency_id.id, currency_id, price)
-
- # Compute price from supplier pricelist which are in Supplier Information
- supplier_info_ids = self.search(cr, uid, [('name','=',supplier.id),('product_tmpl_id','=',product.product_tmpl_id.id)])
- if supplier_info_ids:
- cr.execute('SELECT * ' \
- 'FROM pricelist_partnerinfo ' \
- 'WHERE suppinfo_id IN %s' \
- 'AND min_quantity <= %s ' \
- 'ORDER BY min_quantity DESC LIMIT 1', (tuple(supplier_info_ids),product_qty,))
- res2 = cr.dictfetchone()
- if res2:
- price = res2['price']
- res[supplier.id] = price
- return res
+
_order = 'sequence'
main_currency = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id
for currency_id in ids:
if currency_id == main_currency.id:
- if main_currency.rounding < 10 ** -digits:
+ if float_compare(main_currency.rounding, 10 ** -digits, precision_digits=6) == -1:
return False
return True
main_currency = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id
for decimal_precision in ids:
if decimal_precision == account_precision_id:
- if main_currency.rounding < 10 ** -digits:
+ if float_compare(main_currency.rounding, 10 ** -digits, precision_digits=6) == -1:
return False
return True