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"""
check = int(10 - math.ceil(total % 10.0)) %10
return check
-def check_ean(eancode):
- """returns True if eancode is a valid ean13 string, or null"""
- if not eancode:
- return True
- if len(eancode) != 13:
- return False
- try:
- int(eancode)
- except:
- return False
- return ean_checksum(eancode) == int(eancode[-1])
-
def sanitize_ean13(ean13):
"""Creates and returns a valid ean13 from an invalid one"""
if not ean13:
'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)
_columns = {
'name': fields.char('Name', required=True, translate=True, select=True),
+ 'sequence': fields.integer('Sequence', help='Gives the sequence order when displaying a product list'),
'product_manager': fields.many2one('res.users','Product Manager'),
'description': fields.text('Description',translate=True,
help="A precise description of the Product, used only for internal information purposes."),
'warranty': fields.float('Warranty'),
'sale_ok': fields.boolean('Can be Sold', help="Specify if the product can be selected in a sales order line."),
'pricelist_id': fields.dummy(string='Pricelist', relation='product.pricelist', type='many2one'),
- 'state': fields.selection([('',''),
- ('draft', 'In Development'),
+ 'state': fields.selection([('draft', 'In Development'),
('sellable','Normal'),
('end','End of Lifecycle'),
('obsolete','Obsolete')], 'Status'),
'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),
'product_variant_count': fields.function( _get_product_variant_count, type='integer', string='# of Product Variants'),
# related to display product product information if is_product_variant
- 'ean13': fields.related('product_variant_ids', 'ean13', type='char', string='EAN13 Barcode'),
+ 'barcode': fields.related('product_variant_ids', 'barcode', type='char', string='Barcode', oldname='ean13'),
'default_code': fields.related('product_variant_ids', 'default_code', type='char', string='Internal Reference'),
}
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 = []
# TODO: this is needed to set given values to first variant after creation
# these fields should be moved to product as lead to confusion
related_vals = {}
- if vals.get('ean13'):
- related_vals['ean13'] = vals['ean13']
+ if vals.get('barcode'):
+ related_vals['barcode'] = vals['barcode']
if vals.get('default_code'):
related_vals['default_code'] = vals['default_code']
if related_vals:
''' Store the standard price change in order to be able to retrieve the cost of a product template for a given date'''
if isinstance(ids, (int, long)):
ids = [ids]
- if 'uom_po_id' in vals:
- new_uom = self.pool.get('product.uom').browse(cr, uid, vals['uom_po_id'], context=context)
- for product in self.browse(cr, uid, ids, context=context):
- old_uom = product.uom_po_id
- if old_uom.category_id.id != new_uom.category_id.id:
- raise osv.except_osv(_('Unit of Measure categories Mismatch!'), _("New Unit of Measure '%s' must belong to same Unit of Measure category '%s' as of old Unit of Measure '%s'. If you need to change the unit of measure, you may deactivate this product from the 'Procurements' tab and create a new one.") % (new_uom.name, old_uom.category_id.name, old_uom.name,))
if 'standard_price' in vals:
for prod_template_id in ids:
self._set_standard_price(cr, uid, prod_template_id, vals['standard_price'], context=context)
'categ_id' : _default_category,
'type' : 'consu',
'active': True,
+ 'sequence': 1,
}
def _check_uom(self, cursor, user, ids, context=None):
return super(product_template, self).name_get(cr, user, ids, context)
+
+
+
class product_product(osv.osv):
_name = "product.product"
_description = "Product"
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'),
'default_code' : fields.char('Internal Reference', select=True),
'active': fields.boolean('Active', help="If unchecked, it will allow you to hide the product without removing it."),
- 'product_tmpl_id': fields.many2one('product.template', 'Product Template', required=True, ondelete="cascade", select=True),
- 'ean13': fields.char('EAN13 Barcode', size=13, help="International Article Number used for product identification."),
+ 'product_tmpl_id': fields.many2one('product.template', 'Product Template', required=True, ondelete="cascade", select=True, auto_join=True),
+ 'barcode': fields.char('Barcode', help="International Article Number used for product identification.", oldname='ean13'),
'name_template': fields.related('product_tmpl_id', 'name', string="Template Name", type='char', store={
'product.template': (_get_name_template_ids, ['name'], 10),
'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",
unlink_ids = []
unlink_product_tmpl_ids = []
for product in self.browse(cr, uid, ids, context=context):
+ # Check if product still exists, in case it has been unlinked by unlinking its template
+ if not product.exists():
+ continue
tmpl_id = product.product_tmpl_id.id
# Check if the product is last product of this template
other_product_ids = self.search(cr, uid, [('product_tmpl_id', '=', tmpl_id), ('id', '!=', product.id)], context=context)
return {'value': {'uom_po_id': uom_id}}
return False
- def _check_ean_key(self, cr, uid, ids, context=None):
- for product in self.read(cr, uid, ids, ['ean13'], context=context):
- if not check_ean(product['ean13']):
- return False
- return True
-
- _constraints = [(_check_ean_key, 'You provided an invalid "EAN13 Barcode" reference. You may use the "Internal Reference" field instead.', ['ean13'])]
-
def on_order(self, cr, uid, ids, orderline, quantity):
pass
def _name_get(d):
name = d.get('name','')
- code = d.get('default_code',False)
+ code = context.get('display_default_code', True) and d.get('default_code',False) or False
if code:
name = '[%s] %s' % (code,name)
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))
return result
def name_search(self, cr, user, name='', args=None, operator='ilike', context=None, limit=100):
+ if context is None:
+ context = {}
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, [('barcode','=',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:
ids = self.search(cr, user, [('default_code','=', res.group(2))] + args, limit=limit, context=context)
+ # still no results, partner in context: search on supplier info as last hope to find something
+ if not ids and context.get('partner_id'):
+ supplier_ids = self.pool['product.supplierinfo'].search(
+ cr, user, [
+ ('name', '=', context.get('partner_id')),
+ '|',
+ ('product_code', operator, name),
+ ('product_name', operator, name)
+ ], context=context)
+ if supplier_ids:
+ ids = self.search(cr, user, [('product_tmpl_id.seller_ids', 'in', supplier_ids)], limit=limit, context=context)
else:
ids = self.search(cr, user, args, limit=limit, context=context)
result = self.name_get(cr, user, ids, context=context)
return super(product_product, self).create(cr, uid, vals, context=ctx)
+
+ 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"
_description = "Packaging"
- _rec_name = 'ean'
+ _rec_name = 'barcode'
_order = 'sequence'
_columns = {
'sequence': fields.integer('Sequence', help="Gives the sequence order when displaying a list of packaging."),
'rows' : fields.integer('Number of Layers', required=True,
help='The number of layers on a pallet or box'),
'product_tmpl_id' : fields.many2one('product.template', 'Product', select=1, ondelete='cascade', required=True),
- 'ean' : fields.char('EAN', size=14, help="The EAN code of the package unit."),
+ 'barcode' : fields.char('Barcode', help="The Barcode of the package unit.", oldname="ean"),
'code' : fields.char('Code', help="The code of the transport unit."),
'weight': fields.float('Total Package Weight',
help='The weight of a full package, pallet or box.'),
}
- def _check_ean_key(self, cr, uid, ids, context=None):
- for pack in self.browse(cr, uid, ids, context=context):
- if not check_ean(pack.ean):
- return False
- return True
-
- _constraints = [(_check_ean_key, 'Error: Invalid ean code', ['ean'])]
-
def name_get(self, cr, uid, ids, context=None):
if not len(ids):
return []
res = []
for pckg in self.browse(cr, uid, ids, context=context):
- p_name = pckg.ean and '[' + pckg.ean + '] ' or ''
+ p_name = pckg.barcode and '[' + pckg.barcode + '] ' or ''
p_name += pckg.ul.name
res.append((pckg.id,p_name))
return res
'product_tmpl_id' : fields.many2one('product.template', 'Product Template', required=True, ondelete='cascade', select=True, oldname='product_id'),
'delay' : fields.integer('Delivery Lead Time', required=True, help="Lead time in days between the confirmation of the purchase order and the receipt of the products in your warehouse. Used by the scheduler for automatic computation of the purchase order planning."),
'pricelist_ids': fields.one2many('pricelist.partnerinfo', 'suppinfo_id', 'Supplier Pricelist', copy=True),
- 'company_id':fields.many2one('res.company','Company',select=1),
+ 'company_id':fields.many2one('res.company', string='Company',select=1),
}
_defaults = {
'min_qty': 0.0,
'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
projects / odoo / odoo.git / blobdiff