#
##############################################################################
-from osv import osv, fields
-import decimal_precision as dp
-
import math
-from _common import rounding
import re
-import tools
-from tools.translate import _
+
+from _common import rounding
+
+from openerp import tools
+from openerp.osv import osv, fields
+from openerp.tools.translate import _
+
+import openerp.addons.decimal_precision as dp
def ean_checksum(eancode):
"""returns the checksum of an ean string of length 13, returns -1 if the string has the wrong length"""
_columns = {
'name': fields.char('Name', size=64, required=True, translate=True),
}
-product_uom_categ()
class product_uom(osv.osv):
_name = 'product.uom'
def _factor_inv_write(self, cursor, user, id, name, value, arg, context=None):
return self.write(cursor, user, id, {'factor': self._compute_factor_inv(value)}, context=context)
+ def name_create(self, cr, uid, name, context=None):
+ """ The UoM category and factor are required, so we'll have to add temporary values
+ for imported UoMs """
+ uom_categ = self.pool.get('product.uom.categ')
+ # look for the category based on the english name, i.e. no context on purpose!
+ # TODO: should find a way to have it translated but not created until actually used
+ categ_misc = 'Unsorted/Imported Units'
+ categ_id = uom_categ.search(cr, uid, [('name', '=', categ_misc)])
+ if categ_id:
+ categ_id = categ_id[0]
+ else:
+ categ_id, _ = uom_categ.name_create(cr, uid, categ_misc)
+ uom_id = self.create(cr, uid, {self._rec_name: name,
+ 'category_id': categ_id,
+ 'factor': 1})
+ return self.name_get(cr, uid, [uom_id], context=context)[0]
+
def create(self, cr, uid, data, context=None):
if 'factor_inv' in data:
if data['factor_inv'] <> 1:
_order = "name"
_columns = {
- 'name': fields.char('Name', size=64, required=True, translate=True),
- 'category_id': fields.many2one('product.uom.categ', 'Unit of Measure Category', required=True, ondelete='cascade',
- help="Quantity conversions may happen automatically between Units of Measure in the same category, according to their respective ratios."),
+ 'name': fields.char('Unit of Measure', size=64, required=True, translate=True),
+ 'category_id': fields.many2one('product.uom.categ', '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),
- help='How many times this Unit of Measure is smaller than the reference Unit of Measure in this category:\n'\
+ 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),
fnct_inv=_factor_inv_write,
'active': fields.boolean('Active', help="By unchecking the active field you can disable a unit of measure without deleting it."),
'uom_type': fields.selection([('bigger','Bigger than the reference Unit of Measure'),
('reference','Reference Unit of Measure for this category'),
- ('smaller','Smaller than the reference Unit of Measure')],'Unit of Measure Type', required=1),
+ ('smaller','Smaller than the reference Unit of Measure')],'Type', required=1),
}
_defaults = {
raise osv.except_osv(_('Warning!'),_("Cannot change the category of existing Unit of Measure '%s'.") % (uom.name,))
return super(product_uom, self).write(cr, uid, ids, vals, context=context)
-product_uom()
class product_ul(osv.osv):
'name' : fields.char('Name', size=64,select=True, required=True, translate=True),
'type' : fields.selection([('unit','Unit'),('pack','Pack'),('box', 'Box'), ('pallet', 'Pallet')], 'Type', required=True),
}
-product_ul()
#----------------------------------------------------------
class product_category(osv.osv):
def name_get(self, cr, uid, ids, context=None):
- if not len(ids):
+ if isinstance(ids, (list, tuple)) and not len(ids):
return []
+ if isinstance(ids, (long, int)):
+ ids = [ids]
reads = self.read(cr, uid, ids, ['name','parent_id'], context=context)
res = []
for record in reads:
'parent_id': fields.many2one('product.category','Parent Category', select=True, ondelete='cascade'),
'child_id': fields.one2many('product.category', 'parent_id', string='Child Categories'),
'sequence': fields.integer('Sequence', select=True, help="Gives the sequence order when displaying a list of product categories."),
- 'type': fields.selection([('view','View'), ('normal','Normal')], 'Category Type'),
+ 'type': fields.selection([('view','View'), ('normal','Normal')], 'Category Type', help="A category of the view type is a virtual category that can be used as the parent of another category to create a hierarchical structure."),
'parent_left': fields.integer('Left Parent', select=1),
'parent_right': fields.integer('Right Parent', select=1),
}
def child_get(self, cr, uid, ids):
return [ids]
-product_category()
#----------------------------------------------------------
_columns = {
'name': fields.char('Name', size=128, required=True, translate=True, select=True),
- 'product_manager': fields.many2one('res.users','Product Manager',help="Responsible for product."),
+ 'product_manager': fields.many2one('res.users','Product Manager'),
'description': fields.text('Description',translate=True),
'description_purchase': fields.text('Purchase Description',translate=True),
'description_sale': fields.text('Sale Description',translate=True),
- 'type': fields.selection([('product','Stockable Product'),('consu', 'Consumable'),('service','Service')], 'Product Type', required=True, help="Will change the way procurements are processed. Consumable are product where you don't manage stock."),
- 'supply_method': fields.selection([('produce','Manufacture'),('buy','Buy')], 'Supply Method', required=True, help="Produce will generate production order or tasks, according to the product type. Buy will trigger purchase orders when requested."),
- 'sale_delay': fields.float('Customer Lead Time', help="This is the average delay in days between the confirmation of the customer order and the delivery of the finished products. It's the time you promise to your customers."),
- 'produce_delay': fields.float('Manufacturing Lead Time', help="Average delay in days to produce this product. This is only for the production order and, if it is a multi-level bill of material, it's only for the level of this product. Different lead times will be summed for all levels and purchase orders."),
- 'procure_method': fields.selection([('make_to_stock','Make to Stock'),('make_to_order','Make to Order')], 'Procurement Method', required=True, help="'Make to Stock': When needed, take from the stock or wait until re-supplying. 'Make to Order': When needed, purchase or produce for the procurement request."),
+ 'type': fields.selection([('consu', 'Consumable'),('service','Service')], 'Product Type', required=True, help="Consumable are product where you don't manage stock, a service is a non-material product provided by a company or an individual."),
+ 'produce_delay': fields.float('Manufacturing Lead Time', help="Average delay in days to produce this product. In the case of multi-level BOM, the manufacturing lead times of the components will be added."),
'rental': fields.boolean('Can be Rent'),
'categ_id': fields.many2one('product.category','Category', required=True, change_default=True, domain="[('type','=','normal')]" ,help="Select category for the current product"),
- 'list_price': fields.float('Sale Price', digits_compute=dp.get_precision('Sale Price'), help="Base price for computing the customer price. Sometimes called the catalog price."),
- 'standard_price': fields.float('Cost Price', required=True, digits_compute=dp.get_precision('Purchase Price'), help="Product's cost for accounting stock valuation. It is the base price for the supplier price.", groups="base.group_user"),
+ 'list_price': fields.float('Sale Price', digits_compute=dp.get_precision('Product Price'), help="Base price to compute the customer price. Sometimes called the catalog price."),
+ 'standard_price': fields.float('Cost', digits_compute=dp.get_precision('Product Price'), help="Cost price of the product used for standard stock valuation in accounting and used as a base price on purchase orders.", groups="base.group_user"),
'volume': fields.float('Volume', help="The volume in m3."),
'weight': fields.float('Gross Weight', digits_compute=dp.get_precision('Stock Weight'), help="The gross weight in Kg."),
'weight_net': fields.float('Net Weight', digits_compute=dp.get_precision('Stock Weight'), help="The net weight in Kg."),
'cost_method': fields.selection([('standard','Standard Price'), ('average','Average Price')], 'Costing Method', required=True,
- help="Standard Price: the cost price is fixed and recomputed periodically (usually at the end of the year), Average Price: the cost price is recomputed at each reception of products."),
- 'warranty': fields.float('Warranty (months)'),
- 'sale_ok': fields.boolean('Can be Sold', help="Determines if the product can be visible in the list of product within a selection from a sale order line."),
- 'purchase_ok': fields.boolean('Can be Purchased', help="Determine if the product is visible in the list of products within a selection from a purchase order line."),
+ help="Standard Price: The cost price is manually updated at the end of a specific period (usually every year). \nAverage Price: The cost price is recomputed at each incoming shipment."),
+ 'warranty': fields.float('Warranty'),
+ 'sale_ok': fields.boolean('Can be Sold', help="Specify if the product can be selected in a sales order line."),
'state': fields.selection([('',''),
('draft', 'In Development'),
('sellable','Normal'),
('end','End of Lifecycle'),
- ('obsolete','Obsolete')], 'Status', help="Tells the user if he can use the product or not."),
- 'uom_id': fields.many2one('product.uom', 'Default Unit of Measure', required=True, help="Default Unit of Measure used for all stock operation."),
+ ('obsolete','Obsolete')], 'Status'),
+ 'uom_id': fields.many2one('product.uom', 'Unit of Measure', required=True, help="Default Unit of Measure used for all stock operation."),
'uom_po_id': fields.many2one('product.uom', 'Purchase Unit of Measure', required=True, help="Default Unit of Measure used for purchase orders. It must be in the same category than the default unit of measure."),
'uos_id' : fields.many2one('product.uom', 'Unit of Sale',
- help='Used by companies that manage two units of measure: invoicing and inventory management. For example, in food industries, you will manage a stock of ham but invoice in Kg. Keep empty to use the default Unit of Measure.'),
+ help='Sepcify a unit of measure here if invoicing is made in another unit of measure than inventory. Keep empty to use the default unit of measure.'),
'uos_coeff': fields.float('Unit of Measure -> UOS Coeff', digits_compute= dp.get_precision('Product UoS'),
- help='Coefficient to convert Unit of Measure to UOS\n'
+ help='Coefficient to convert default Unit of Measure to Unit of Sale\n'
' uos = uom * coeff'),
- 'mes_type': fields.selection((('fixed', 'Fixed'), ('variable', 'Variable')), 'Measure Type', required=True),
- 'seller_ids': fields.one2many('product.supplierinfo', 'product_id', 'Partners'),
- 'loc_rack': fields.char('Rack', size=16),
- 'loc_row': fields.char('Row', size=16),
- 'loc_case': fields.char('Case', size=16),
+ 'mes_type': fields.selection((('fixed', 'Fixed'), ('variable', 'Variable')), 'Measure Type'),
+ 'seller_ids': fields.one2many('product.supplierinfo', 'product_id', 'Supplier'),
'company_id': fields.many2one('res.company', 'Company', select=1),
}
res = False
return res
- def onchange_uom(self, cursor, user, ids, uom_id,uom_po_id):
+ def onchange_uom(self, cursor, user, ids, uom_id, uom_po_id):
if uom_id:
return {'value': {'uom_po_id': uom_id}}
return {}
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 'Procurement & Locations' tab and create a new one.") % (new_uom.name, old_uom.category_id.name, old_uom.name,))
+ 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,))
return super(product_template, self).write(cr, uid, ids, vals, context=context)
_defaults = {
'company_id': lambda s,cr,uid,c: s.pool.get('res.company')._company_default_get(cr, uid, 'product.template', context=c),
- 'list_price': lambda *a: 1,
- 'cost_method': lambda *a: 'standard',
- 'supply_method': lambda *a: 'buy',
- 'standard_price': lambda *a: 1,
- 'sale_ok': lambda *a: 1,
- 'sale_delay': lambda *a: 7,
- 'produce_delay': lambda *a: 1,
- 'purchase_ok': lambda *a: 1,
- 'procure_method': lambda *a: 'make_to_stock',
+ 'list_price': 1,
+ 'cost_method': 'standard',
+ 'standard_price': 0.0,
+ 'sale_ok': 1,
+ 'produce_delay': 1,
'uom_id': _get_uom_id,
'uom_po_id': _get_uom_id,
- 'uos_coeff' : lambda *a: 1.0,
- 'mes_type' : lambda *a: 'fixed',
+ 'uos_coeff' : 1.0,
+ 'mes_type' : 'fixed',
'categ_id' : _default_category,
- 'type' : lambda *a: 'consu',
+ 'type' : 'consu',
}
def _check_uom(self, cursor, user, ids, context=None):
pass
return super(product_template, self).name_get(cr, user, ids, context)
-product_template()
class product_product(osv.osv):
def view_header_get(self, cr, uid, view_id, view_type, context=None):
main_supplier = self._get_main_product_supplier(cr, uid, product, context=context)
result[product.id] = {
'seller_info_id': main_supplier and main_supplier.id or False,
- 'seller_delay': main_supplier and main_supplier.delay or 1,
+ 'seller_delay': main_supplier.delay if main_supplier else 1,
'seller_qty': main_supplier and main_supplier.qty or 0.0,
'seller_id': main_supplier and main_supplier.name.id or False
}
def _get_image(self, cr, uid, ids, name, args, context=None):
result = dict.fromkeys(ids, False)
for obj in self.browse(cr, uid, ids, context=context):
- result[obj.id] = tools.image_get_resized_images(obj.image)
+ result[obj.id] = tools.image_get_resized_images(obj.image, avoid_resize_medium=True)
return result
-
+
def _set_image(self, cr, uid, id, name, value, args, context=None):
return self.write(cr, uid, [id], {'image': tools.image_resize_image_big(value)}, context=context)
+ def _get_name_template_ids(self, cr, uid, ids, context=None):
+ result = set()
+ template_ids = self.pool.get('product.product').search(cr, uid, [('product_tmpl_id', 'in', ids)])
+ for el in template_ids:
+ result.add(el)
+ return list(result)
+
_defaults = {
'active': lambda *a: 1,
'price_extra': lambda *a: 0.0,
'virtual_available': fields.function(_product_virtual_available, type='float', string='Quantity Available'),
'incoming_qty': fields.function(_product_incoming_qty, type='float', string='Incoming'),
'outgoing_qty': fields.function(_product_outgoing_qty, type='float', string='Outgoing'),
- 'price': fields.function(_product_price, type='float', string='Pricelist', digits_compute=dp.get_precision('Sale Price')),
- 'lst_price' : fields.function(_product_lst_price, type='float', string='Public Price', digits_compute=dp.get_precision('Sale Price')),
- 'code': fields.function(_product_code, type='char', string='Reference'),
+ 'price': fields.function(_product_price, type='float', string='Price', digits_compute=dp.get_precision('Product Price')),
+ 'lst_price' : fields.function(_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('Reference', size=64, select=True),
- 'active': fields.boolean('Active', help="If the active field is set to False, it will allow you to hide the product without removing it."),
+ 'default_code' : fields.char('Internal Reference', size=64, select=True),
+ 'active': fields.boolean('Active', help="If unchecked, it will allow you to hide the product without removing it."),
'variants': fields.char('Variants', size=64),
- 'product_tmpl_id': fields.many2one('product.template', 'Product Template', required=True, ondelete="cascade"),
- 'ean13': fields.char('EAN13', size=13, help="The numbers encoded in EAN-13 bar codes are product identification numbers."),
+ '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."),
'packaging' : fields.one2many('product.packaging', 'product_id', 'Logistical Units', help="Gives the different ways to package the same product. This has no impact on the picking order and is mainly used if you use the EDI module."),
- 'price_extra': fields.float('Variant Price Extra', digits_compute=dp.get_precision('Sale Price')),
- 'price_margin': fields.float('Variant Price Margin', digits_compute=dp.get_precision('Sale Price')),
+ 'price_extra': fields.float('Variant Price Extra', digits_compute=dp.get_precision('Product Price')),
+ 'price_margin': fields.float('Variant Price Margin', digits_compute=dp.get_precision('Product Price')),
'pricelist_id': fields.dummy(string='Pricelist', relation='product.pricelist', type='many2one'),
- 'name_template': fields.related('product_tmpl_id', 'name', string="Name", type='char', size=128, store=True, select=True),
+ 'name_template': fields.related('product_tmpl_id', 'name', string="Template Name", type='char', size=128, store={
+ 'product.template': (_get_name_template_ids, ['name'], 10),
+ 'product.product': (lambda self, cr, uid, ids, c=None: ids, [], 10),
+
+ }, select=True),
'color': fields.integer('Color Index'),
+ # image: all image fields are base64 encoded and PIL-supported
'image': fields.binary("Image",
- help="This field holds the image used for the product. "\
- "The image is base64 encoded, and PIL-supported. "\
- "It is limited to a 1024x1024 px image."),
+ help="This field holds the image used as image for the product, limited to 1024x1024px."),
'image_medium': fields.function(_get_image, fnct_inv=_set_image,
string="Medium-sized image", type="binary", multi="_get_image",
- store = {
+ store={
'product.product': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
},
help="Medium-sized image of the product. It is automatically "\
- "resized as a 180x180 px image, with aspect ratio preserved. "\
- "Use this field in form views or some kanban views."),
+ "resized as a 128x128px image, with aspect ratio preserved, "\
+ "only when the image exceeds one of those sizes. Use this field in form views or some kanban views."),
'image_small': fields.function(_get_image, fnct_inv=_set_image,
string="Small-sized image", type="binary", multi="_get_image",
- store = {
+ store={
'product.product': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
},
help="Small-sized image of the product. It is automatically "\
- "resized as a 50x50 px image, with aspect ratio preserved. "\
+ "resized as a 64x64px image, with aspect ratio preserved. "\
"Use this field anywhere a small image is required."),
- 'seller_info_id': fields.function(_calc_seller, type='many2one', relation="product.supplierinfo", multi="seller_info"),
+ 'seller_info_id': fields.function(_calc_seller, type='many2one', relation="product.supplierinfo", string="Supplier Info", multi="seller_info"),
'seller_delay': fields.function(_calc_seller, type='integer', string='Supplier Lead Time', multi="seller_info", help="This is the average delay in days between the purchase order confirmation and the reception of goods for this product and for the default supplier. It is used by the scheduler to order requests based on reordering delays."),
'seller_qty': fields.function(_calc_seller, type='float', string='Supplier Quantity', multi="seller_info", help="This is minimum quantity to purchase from Main Supplier."),
'seller_id': fields.function(_calc_seller, type='many2one', relation="res.partner", string='Main Supplier', help="Main Supplier who has highest priority in Supplier List.", multi="seller_info"),
}
-
- def create(self, cr, uid, vals, context=None):
- obj_id = super(product_product, self).create(cr, uid, vals, context=context)
- self.create_send_note(cr, uid, [obj_id], context=context)
- return obj_id
-
- def create_send_note(self, cr, uid, ids, context=None):
- return self.message_append_note(cr, uid, ids, body=_("Product has been <b>created</b>."), context=context)
-
def unlink(self, cr, uid, ids, context=None):
unlink_ids = []
unlink_product_tmpl_ids = []
# 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)
if not other_product_ids:
- unlink_product_tmpl_ids.append(tmpl_id)
+ unlink_product_tmpl_ids.append(tmpl_id)
unlink_ids.append(product.id)
+ res = super(product_product, self).unlink(cr, uid, unlink_ids, context=context)
+ # delete templates after calling super, as deleting template could lead to deleting
+ # products due to ondelete='cascade'
self.pool.get('product.template').unlink(cr, uid, unlink_product_tmpl_ids, context=context)
- return super(product_product, self).unlink(cr, uid, unlink_ids, context=context)
+ return res
- def onchange_uom(self, cursor, user, ids, uom_id,uom_po_id):
+ def onchange_uom(self, cursor, user, ids, uom_id, uom_po_id):
if uom_id and uom_po_id:
uom_obj=self.pool.get('product.uom')
uom=uom_obj.browse(cursor,user,[uom_id])[0]
return res
- _constraints = [(_check_ean_key, 'Error: Invalid ean code', ['ean13'])]
+ _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
# Performing a quick memory merge of ids in Python will give much better performance
ids = set()
ids.update(self.search(cr, user, args + [('default_code',operator,name)], limit=limit, context=context))
- if len(ids) < limit:
+ if not limit or len(ids) < limit:
# we may underrun the limit because of dupes in the results, that's fine
- ids.update(self.search(cr, user, args + [('name',operator,name)], limit=(limit-len(ids)), context=context))
+ ids.update(self.search(cr, user, args + [('name',operator,name)], limit=(limit and (limit-len(ids)) or False) , context=context))
ids = list(ids)
if not ids:
ptrn = re.compile('(\[(.*?)\])')
context_wo_lang.pop('lang', None)
product = self.read(cr, uid, id, ['name'], context=context_wo_lang)
default = default.copy()
- default['name'] = product['name'] + ' (copy)'
+ default.update(name=_("%s (copy)") % (product['name']))
if context.get('variant',False):
fields = ['product_tmpl_id', 'active', 'variants', 'default_code',
else:
return super(product_product, self).copy(cr, uid, id, default=default,
context=context)
-product_product()
+
+ def search(self, cr, uid, args, offset=0, limit=None, order=None, context=None, count=False):
+ if context is None:
+ context = {}
+ if context and context.get('search_default_categ_id', False):
+ args.append((('categ_id', 'child_of', context['search_default_categ_id'])))
+ return super(product_product, self).search(cr, uid, args, offset=offset, limit=limit, order=order, context=context, count=False)
+
class product_packaging(osv.osv):
_name = "product.packaging"
help="The code of the transport unit."),
'weight': fields.float('Total Package Weight',
help='The weight of a full package, pallet or box.'),
- 'weight_ul': fields.float('Empty Package Weight',
- help='The weight of the empty UL'),
+ 'weight_ul': fields.float('Empty Package Weight'),
'height': fields.float('Height', help='The height of the package'),
'width': fields.float('Width', help='The width of the package'),
'length': fields.float('Length', help='The length of the package'),
return (10 - (sum % 10)) % 10
checksum = staticmethod(checksum)
-product_packaging()
class product_supplierinfo(osv.osv):
res[supplier.id] = price
return res
_order = 'sequence'
-product_supplierinfo()
class pricelist_partnerinfo(osv.osv):
'name': fields.char('Description', size=64),
'suppinfo_id': fields.many2one('product.supplierinfo', 'Partner Information', required=True, ondelete='cascade'),
'min_quantity': fields.float('Quantity', required=True, help="The minimal quantity to trigger this rule, expressed in the supplier Unit of Measure if any or in the default Unit of Measure of the product otherrwise."),
- 'price': fields.float('Unit Price', required=True, digits_compute=dp.get_precision('Purchase Price'), help="This price will be considered as a price for the supplier Unit of Measure if any or the default Unit of Measure of the product otherwise"),
+ 'price': fields.float('Unit Price', required=True, digits_compute=dp.get_precision('Product Price'), help="This price will be considered as a price for the supplier Unit of Measure if any or the default Unit of Measure of the product otherwise"),
}
_order = 'min_quantity asc'
-pricelist_partnerinfo()
+
+class res_currency(osv.osv):
+ _inherit = 'res.currency'
+
+ def _check_main_currency_rounding(self, cr, uid, ids, context=None):
+ cr.execute('SELECT digits FROM decimal_precision WHERE name like %s',('Account',))
+ digits = cr.fetchone()
+ if digits and len(digits):
+ digits = digits[0]
+ 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:
+ return False
+ return True
+
+ _constraints = [
+ (_check_main_currency_rounding, 'Error! You cannot define a rounding factor for the company\'s main currency that is smaller than the decimal precision of \'Account\'.', ['rounding']),
+ ]
+
+class decimal_precision(osv.osv):
+ _inherit = 'decimal.precision'
+
+ def _check_main_currency_rounding(self, cr, uid, ids, context=None):
+ cr.execute('SELECT id, digits FROM decimal_precision WHERE name like %s',('Account',))
+ res = cr.fetchone()
+ if res and len(res):
+ account_precision_id, digits = res
+ 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:
+ return False
+ return True
+
+ _constraints = [
+ (_check_main_currency_rounding, 'Error! You cannot define the decimal precision of \'Account\' as greater than the rounding factor of the company\'s main currency', ['digits']),
+ ]
+
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
projects / odoo / odoo.git / blobdiff