addons/product/product.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22 import math
  23 import re
  24
  25 from _common import ceiling
  26
  27 from openerp import SUPERUSER_ID
  28 from openerp import tools
  29 from openerp.osv import osv, orm, fields, expression
  30 from openerp.tools.translate import _
  31
  32 import openerp.addons.decimal_precision as dp
  33 from openerp.tools.float_utils import float_round
  34
  35 def ean_checksum(eancode):
  36     """returns the checksum of an ean string of length 13, returns -1 if the string has the wrong length"""
  37     if len(eancode) != 13:
  38         return -1
  39     oddsum=0
  40     evensum=0
  41     total=0
  42     eanvalue=eancode
  43     reversevalue = eanvalue[::-1]
  44     finalean=reversevalue[1:]
  45
  46     for i in range(len(finalean)):
  47         if i % 2 == 0:
  48             oddsum += int(finalean[i])
  49         else:
  50             evensum += int(finalean[i])
  51     total=(oddsum * 3) + evensum
  52
  53     check = int(10 - math.ceil(total % 10.0)) %10
  54     return check
  55
  56 def check_ean(eancode):
  57     """returns True if eancode is a valid ean13 string, or null"""
  58     if not eancode:
  59         return True
  60     if len(eancode) != 13:
  61         return False
  62     try:
  63         int(eancode)
  64     except:
  65         return False
  66     return ean_checksum(eancode) == int(eancode[-1])
  67
  68 def sanitize_ean13(ean13):
  69     """Creates and returns a valid ean13 from an invalid one"""
  70     if not ean13:
  71         return "0000000000000"
  72     ean13 = re.sub("[A-Za-z]","0",ean13);
  73     ean13 = re.sub("[^0-9]","",ean13);
  74     ean13 = ean13[:13]
  75     if len(ean13) < 13:
  76         ean13 = ean13 + '0' * (13-len(ean13))
  77     return ean13[:-1] + str(ean_checksum(ean13))
  78
  79 #----------------------------------------------------------
  80 # UOM
  81 #----------------------------------------------------------
  82
  83 class product_uom_categ(osv.osv):
  84     _name = 'product.uom.categ'
  85     _description = 'Product uom categ'
  86     _columns = {
  87         'name': fields.char('Name', required=True, translate=True),
  88     }
  89
  90 class product_uom(osv.osv):
  91     _name = 'product.uom'
  92     _description = 'Product Unit of Measure'
  93
  94     def _compute_factor_inv(self, factor):
  95         return factor and (1.0 / factor) or 0.0
  96
  97     def _factor_inv(self, cursor, user, ids, name, arg, context=None):
  98         res = {}
  99         for uom in self.browse(cursor, user, ids, context=context):
 100             res[uom.id] = self._compute_factor_inv(uom.factor)
 101         return res
 102
 103     def _factor_inv_write(self, cursor, user, id, name, value, arg, context=None):
 104         return self.write(cursor, user, id, {'factor': self._compute_factor_inv(value)}, context=context)
 105
 106     def name_create(self, cr, uid, name, context=None):
 107         """ The UoM category and factor are required, so we'll have to add temporary values
 108             for imported UoMs """
 109         uom_categ = self.pool.get('product.uom.categ')
 110         # look for the category based on the english name, i.e. no context on purpose!
 111         # TODO: should find a way to have it translated but not created until actually used
 112         categ_misc = 'Unsorted/Imported Units'
 113         categ_id = uom_categ.search(cr, uid, [('name', '=', categ_misc)])
 114         if categ_id:
 115             categ_id = categ_id[0]
 116         else:
 117             categ_id, _ = uom_categ.name_create(cr, uid, categ_misc)
 118         uom_id = self.create(cr, uid, {self._rec_name: name,
 119                                        'category_id': categ_id,
 120                                        'factor': 1})
 121         return self.name_get(cr, uid, [uom_id], context=context)[0]
 122
 123     def create(self, cr, uid, data, context=None):
 124         if 'factor_inv' in data:
 125             if data['factor_inv'] != 1:
 126                 data['factor'] = self._compute_factor_inv(data['factor_inv'])
 127             del(data['factor_inv'])
 128         return super(product_uom, self).create(cr, uid, data, context)
 129
 130     _order = "name"
 131     _columns = {
 132         'name': fields.char('Unit of Measure', required=True, translate=True),
 133         'category_id': fields.many2one('product.uom.categ', 'Category', required=True, ondelete='cascade',
 134             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."),
 135         'factor': fields.float('Ratio', required=True, digits=0, # force NUMERIC with unlimited precision
 136             help='How much bigger or smaller this unit is compared to the reference Unit of Measure for this category:\n'\
 137                     '1 * (reference unit) = ratio * (this unit)'),
 138         'factor_inv': fields.function(_factor_inv, digits=0, # force NUMERIC with unlimited precision
 139             fnct_inv=_factor_inv_write,
 140             string='Bigger Ratio',
 141             help='How many times this Unit of Measure is bigger than the reference Unit of Measure in this category:\n'\
 142                     '1 * (this unit) = ratio * (reference unit)', required=True),
 143         'rounding': fields.float('Rounding Precision', digits_compute=dp.get_precision('Product Unit of Measure'), required=True,
 144             help="The computed quantity will be a multiple of this value. "\
 145                  "Use 1.0 for a Unit of Measure that cannot be further split, such as a piece."),
 146         'active': fields.boolean('Active', help="By unchecking the active field you can disable a unit of measure without deleting it."),
 147         'uom_type': fields.selection([('bigger','Bigger than the reference Unit of Measure'),
 148                                       ('reference','Reference Unit of Measure for this category'),
 149                                       ('smaller','Smaller than the reference Unit of Measure')],'Type', required=1),
 150     }
 151
 152     _defaults = {
 153         'active': 1,
 154         'rounding': 0.01,
 155         'uom_type': 'reference',
 156     }
 157
 158     _sql_constraints = [
 159         ('factor_gt_zero', 'CHECK (factor!=0)', 'The conversion ratio for a unit of measure cannot be 0!')
 160     ]
 161
 162     def _compute_qty(self, cr, uid, from_uom_id, qty, to_uom_id=False):
 163         if not from_uom_id or not qty or not to_uom_id:
 164             return qty
 165         uoms = self.browse(cr, uid, [from_uom_id, to_uom_id])
 166         if uoms[0].id == from_uom_id:
 167             from_unit, to_unit = uoms[0], uoms[-1]
 168         else:
 169             from_unit, to_unit = uoms[-1], uoms[0]
 170         return self._compute_qty_obj(cr, uid, from_unit, qty, to_unit)
 171
 172     def _compute_qty_obj(self, cr, uid, from_unit, qty, to_unit, context=None):
 173         if context is None:
 174             context = {}
 175         if from_unit.category_id.id != to_unit.category_id.id:
 176             if context.get('raise-exception', True):
 177                 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,))
 178             else:
 179                 return qty
 180         # First round to the precision of the original unit, so that
 181         # float representation errors do not bias the following ceil()
 182         # e.g. with 1 / (1/12) we could get 12.0000048, ceiling to 13!
 183         amount = float_round(qty/from_unit.factor, precision_rounding=from_unit.rounding)
 184         if to_unit:
 185             amount = ceiling(amount * to_unit.factor, to_unit.rounding)
 186         return amount
 187
 188     def _compute_price(self, cr, uid, from_uom_id, price, to_uom_id=False):
 189         if not from_uom_id or not price or not to_uom_id:
 190             return price
 191         uoms = self.browse(cr, uid, [from_uom_id, to_uom_id])
 192         if uoms[0].id == from_uom_id:
 193             from_unit, to_unit = uoms[0], uoms[-1]
 194         else:
 195             from_unit, to_unit = uoms[-1], uoms[0]
 196         if from_unit.category_id.id != to_unit.category_id.id:
 197             return price
 198         amount = price * from_unit.factor
 199         if to_uom_id:
 200             amount = amount / to_unit.factor
 201         return amount
 202
 203     def onchange_type(self, cursor, user, ids, value):
 204         if value == 'reference':
 205             return {'value': {'factor': 1, 'factor_inv': 1}}
 206         return {}
 207
 208     def write(self, cr, uid, ids, vals, context=None):
 209         if 'category_id' in vals:
 210             for uom in self.browse(cr, uid, ids, context=context):
 211                 if uom.category_id.id != vals['category_id']:
 212                     raise osv.except_osv(_('Warning!'),_("Cannot change the category of existing Unit of Measure '%s'.") % (uom.name,))
 213         return super(product_uom, self).write(cr, uid, ids, vals, context=context)
 214
 215
 216
 217 class product_ul(osv.osv):
 218     _name = "product.ul"
 219     _description = "Shipping Unit"
 220     _columns = {
 221         'name' : fields.char('Name', select=True, required=True, translate=True),
 222         'type' : fields.selection([('unit','Unit'),('pack','Pack'),('box', 'Box'), ('pallet', 'Pallet')], 'Type', required=True),
 223     }
 224
 225
 226 #----------------------------------------------------------
 227 # Categories
 228 #----------------------------------------------------------
 229 class product_category(osv.osv):
 230
 231     def name_get(self, cr, uid, ids, context=None):
 232         if isinstance(ids, (list, tuple)) and not len(ids):
 233             return []
 234         if isinstance(ids, (long, int)):
 235             ids = [ids]
 236         reads = self.read(cr, uid, ids, ['name','parent_id'], context=context)
 237         res = []
 238         for record in reads:
 239             name = record['name']
 240             if record['parent_id']:
 241                 name = record['parent_id'][1]+' / '+name
 242             res.append((record['id'], name))
 243         return res
 244
 245     def _name_get_fnc(self, cr, uid, ids, prop, unknow_none, context=None):
 246         res = self.name_get(cr, uid, ids, context=context)
 247         return dict(res)
 248
 249     _name = "product.category"
 250     _description = "Product Category"
 251     _columns = {
 252         'name': fields.char('Name', required=True, translate=True, select=True),
 253         'complete_name': fields.function(_name_get_fnc, type="char", string='Name'),
 254         'parent_id': fields.many2one('product.category','Parent Category', select=True, ondelete='cascade'),
 255         'child_id': fields.one2many('product.category', 'parent_id', string='Child Categories'),
 256         'sequence': fields.integer('Sequence', select=True, help="Gives the sequence order when displaying a list of product categories."),
 257         '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."),
 258         'parent_left': fields.integer('Left Parent', select=1),
 259         'parent_right': fields.integer('Right Parent', select=1),
 260     }
 261
 262
 263     _defaults = {
 264         'type' : lambda *a : 'normal',
 265     }
 266
 267     _parent_name = "parent_id"
 268     _parent_store = True
 269     _parent_order = 'sequence, name'
 270     _order = 'parent_left'
 271
 272     _constraints = [
 273         (osv.osv._check_recursion, 'Error ! You cannot create recursive categories.', ['parent_id'])
 274     ]
 275     def child_get(self, cr, uid, ids):
 276         return [ids]
 277
 278
 279 class product_public_category(osv.osv):
 280     _name = "product.public.category"
 281     _description = "Public Category"
 282     _order = "sequence, name"
 283
 284     _constraints = [
 285         (osv.osv._check_recursion, 'Error ! You cannot create recursive categories.', ['parent_id'])
 286     ]
 287
 288     def name_get(self, cr, uid, ids, context=None):
 289         if not len(ids):
 290             return []
 291         reads = self.read(cr, uid, ids, ['name','parent_id'], context=context)
 292         res = []
 293         for record in reads:
 294             name = record['name']
 295             if record['parent_id']:
 296                 name = record['parent_id'][1]+' / '+name
 297             res.append((record['id'], name))
 298         return res
 299
 300     def _name_get_fnc(self, cr, uid, ids, prop, unknow_none, context=None):
 301         res = self.name_get(cr, uid, ids, context=context)
 302         return dict(res)
 303
 304     def _get_image(self, cr, uid, ids, name, args, context=None):
 305         result = dict.fromkeys(ids, False)
 306         for obj in self.browse(cr, uid, ids, context=context):
 307             result[obj.id] = tools.image_get_resized_images(obj.image)
 308         return result
 309
 310     def _set_image(self, cr, uid, id, name, value, args, context=None):
 311         return self.write(cr, uid, [id], {'image': tools.image_resize_image_big(value)}, context=context)
 312
 313     _columns = {
 314         'name': fields.char('Name', required=True, translate=True),
 315         'complete_name': fields.function(_name_get_fnc, type="char", string='Name'),
 316         'parent_id': fields.many2one('product.public.category','Parent Category', select=True),
 317         'child_id': fields.one2many('product.public.category', 'parent_id', string='Children Categories'),
 318         'sequence': fields.integer('Sequence', help="Gives the sequence order when displaying a list of product categories."),
 319
 320         # NOTE: there is no 'default image', because by default we don't show thumbnails for categories. However if we have a thumbnail
 321         # for at least one category, then we display a default image on the other, so that the buttons have consistent styling.
 322         # In this case, the default image is set by the js code.
 323         # NOTE2: image: all image fields are base64 encoded and PIL-supported
 324         'image': fields.binary("Image",
 325             help="This field holds the image used as image for the cateogry, limited to 1024x1024px."),
 326         'image_medium': fields.function(_get_image, fnct_inv=_set_image,
 327             string="Medium-sized image", type="binary", multi="_get_image",
 328             store={
 329                 'product.public.category': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 330             },
 331             help="Medium-sized image of the category. It is automatically "\
 332                  "resized as a 128x128px image, with aspect ratio preserved. "\
 333                  "Use this field in form views or some kanban views."),
 334         'image_small': fields.function(_get_image, fnct_inv=_set_image,
 335             string="Smal-sized image", type="binary", multi="_get_image",
 336             store={
 337                 'product.public.category': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 338             },
 339             help="Small-sized image of the category. It is automatically "\
 340                  "resized as a 64x64px image, with aspect ratio preserved. "\
 341                  "Use this field anywhere a small image is required."),
 342     }
 343
 344
 345 #----------------------------------------------------------
 346 # Products
 347 #----------------------------------------------------------
 348 class product_template(osv.osv):
 349     _name = "product.template"
 350     _inherit = ['mail.thread']
 351     _description = "Product Template"
 352
 353     def _get_image(self, cr, uid, ids, name, args, context=None):
 354         result = dict.fromkeys(ids, False)
 355         for obj in self.browse(cr, uid, ids, context=context):
 356             result[obj.id] = tools.image_get_resized_images(obj.image, avoid_resize_medium=True)
 357         return result
 358
 359     def _set_image(self, cr, uid, id, name, value, args, context=None):
 360         return self.write(cr, uid, [id], {'image': tools.image_resize_image_big(value)}, context=context)
 361
 362     _columns = {
 363         'name': fields.char('Name', required=True, translate=True, select=True),
 364         'product_manager': fields.many2one('res.users','Product Manager'),
 365         'description': fields.text('Description',translate=True,
 366             help="A precise description of the Product, used only for internal information purposes."),
 367         'description_purchase': fields.text('Purchase Description',translate=True,
 368             help="A description of the Product that you want to communicate to your suppliers. "
 369                  "This description will be copied to every Purchase Order, Reception and Supplier Invoice/Refund."),
 370         'description_sale': fields.text('Sale Description',translate=True,
 371             help="A description of the Product that you want to communicate to your customers. "
 372                  "This description will be copied to every Sale Order, Delivery Order and Customer Invoice/Refund"),
 373         '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."),
 374         '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."),
 375         'rental': fields.boolean('Can be Rent'),
 376         'categ_id': fields.many2one('product.category','Category', required=True, change_default=True, domain="[('type','=','normal')]" ,help="Select category for the current product"),
 377         'public_categ_id': fields.many2one('product.public.category','Public Category', help="Those categories are used to group similar products for public sales (eg.: point of sale, e-commerce)."),
 378         '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."),
 379         'standard_price': fields.float('Cost Price', digits_compute=dp.get_precision('Product Price'), help="Cost price of the product template used for standard stock valuation in accounting and used as a base price on purchase orders.", groups="base.group_user"),
 380         'volume': fields.float('Volume', help="The volume in m3."),
 381         'weight': fields.float('Gross Weight', digits_compute=dp.get_precision('Stock Weight'), help="The gross weight in Kg."),
 382         'weight_net': fields.float('Net Weight', digits_compute=dp.get_precision('Stock Weight'), help="The net weight in Kg."),
 383         'cost_method': fields.selection([('standard','Standard Price'), ('average','Average Price')], 'Costing Method', required=True,
 384             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."),
 385         'warranty': fields.float('Warranty'),
 386         'sale_ok': fields.boolean('Can be Sold', help="Specify if the product can be selected in a sales order line."),
 387         'state': fields.selection([('',''),
 388             ('draft', 'In Development'),
 389             ('sellable','Normal'),
 390             ('end','End of Lifecycle'),
 391             ('obsolete','Obsolete')], 'Status'),
 392         'uom_id': fields.many2one('product.uom', 'Unit of Measure', required=True, help="Default Unit of Measure used for all stock operation."),
 393         '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."),
 394         'uos_id' : fields.many2one('product.uom', 'Unit of Sale',
 395             help='Specify 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.'),
 396         'uos_coeff': fields.float('Unit of Measure -> UOS Coeff', digits_compute= dp.get_precision('Product UoS'),
 397             help='Coefficient to convert default Unit of Measure to Unit of Sale\n'
 398             ' uos = uom * coeff'),
 399         'mes_type': fields.selection((('fixed', 'Fixed'), ('variable', 'Variable')), 'Measure Type'),
 400         'seller_ids': fields.one2many('product.supplierinfo', 'product_tmpl_id', 'Supplier'),
 401         'company_id': fields.many2one('res.company', 'Company', select=1),
 402         # image: all image fields are base64 encoded and PIL-supported
 403         'image': fields.binary("Image",
 404             help="This field holds the image used as image for the product, limited to 1024x1024px."),
 405         'image_medium': fields.function(_get_image, fnct_inv=_set_image,
 406             string="Medium-sized image", type="binary", multi="_get_image",
 407             store={
 408                 'product.template': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 409             },
 410             help="Medium-sized image of the product. It is automatically "\
 411                  "resized as a 128x128px image, with aspect ratio preserved, "\
 412                  "only when the image exceeds one of those sizes. Use this field in form views or some kanban views."),
 413         'image_small': fields.function(_get_image, fnct_inv=_set_image,
 414             string="Small-sized image", type="binary", multi="_get_image",
 415             store={
 416                 'product.template': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 417             },
 418             help="Small-sized image of the product. It is automatically "\
 419                  "resized as a 64x64px image, with aspect ratio preserved. "\
 420                  "Use this field anywhere a small image is required."),
 421         'product_variant_ids': fields.one2many('product.product', 'product_tmpl_id', 'Product Variants', required=True),
 422     }
 423
 424     def _get_uom_id(self, cr, uid, *args):
 425         cr.execute('select id from product_uom order by id limit 1')
 426         res = cr.fetchone()
 427         return res and res[0] or False
 428
 429     def _default_category(self, cr, uid, context=None):
 430         if context is None:
 431             context = {}
 432         if 'categ_id' in context and context['categ_id']:
 433             return context['categ_id']
 434         md = self.pool.get('ir.model.data')
 435         res = False
 436         try:
 437             res = md.get_object_reference(cr, uid, 'product', 'product_category_all')[1]
 438         except ValueError:
 439             res = False
 440         return res
 441
 442     def onchange_uom(self, cursor, user, ids, uom_id, uom_po_id):
 443         if uom_id:
 444             return {'value': {'uom_po_id': uom_id}}
 445         return {}
 446
 447     def write(self, cr, uid, ids, vals, context=None):
 448         if 'uom_po_id' in vals:
 449             new_uom = self.pool.get('product.uom').browse(cr, uid, vals['uom_po_id'], context=context)
 450             for product in self.browse(cr, uid, ids, context=context):
 451                 old_uom = product.uom_po_id
 452                 if old_uom.category_id.id != new_uom.category_id.id:
 453                     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,))
 454         return super(product_template, self).write(cr, uid, ids, vals, context=context)
 455
 456     def copy(self, cr, uid, id, default=None, context=None):
 457         if default is None:
 458             default = {}
 459         template = self.browse(cr, uid, id, context=context)
 460         default['name'] = _("%s (copy)") % (template['name'])
 461         return super(product_template, self).copy(cr, uid, id, default=default, context=context)
 462
 463     _defaults = {
 464         'company_id': lambda s,cr,uid,c: s.pool.get('res.company')._company_default_get(cr, uid, 'product.template', context=c),
 465         'list_price': 1,
 466         'cost_method': 'standard',
 467         'standard_price': 0.0,
 468         'sale_ok': 1,
 469         'produce_delay': 1,
 470         'uom_id': _get_uom_id,
 471         'uom_po_id': _get_uom_id,
 472         'uos_coeff' : 1.0,
 473         'mes_type' : 'fixed',
 474         'categ_id' : _default_category,
 475         'type' : 'consu',
 476     }
 477
 478     def _check_uom(self, cursor, user, ids, context=None):
 479         for product in self.browse(cursor, user, ids, context=context):
 480             if product.uom_id.category_id.id != product.uom_po_id.category_id.id:
 481                 return False
 482         return True
 483
 484     def _check_uos(self, cursor, user, ids, context=None):
 485         for product in self.browse(cursor, user, ids, context=context):
 486             if product.uos_id \
 487                     and product.uos_id.category_id.id \
 488                     == product.uom_id.category_id.id:
 489                 return False
 490         return True
 491
 492     _constraints = [
 493         (_check_uom, 'Error: The default Unit of Measure and the purchase Unit of Measure must be in the same category.', ['uom_id']),
 494     ]
 495
 496     def name_get(self, cr, user, ids, context=None):
 497         if context is None:
 498             context = {}
 499         if 'partner_id' in context:
 500             pass
 501         return super(product_template, self).name_get(cr, user, ids, context)
 502
 503
 504 class product_product(osv.osv):
 505     _name = "product.product"
 506     _description = "Product"
 507     _inherits = {'product.template': 'product_tmpl_id'}
 508     _inherit = ['mail.thread']
 509     _order = 'default_code,name_template'
 510
 511     def view_header_get(self, cr, uid, view_id, view_type, context=None):
 512         if context is None:
 513             context = {}
 514         res = super(product_product, self).view_header_get(cr, uid, view_id, view_type, context)
 515         if (context.get('categ_id', False)):
 516             return _('Products: ')+self.pool.get('product.category').browse(cr, uid, context['categ_id'], context=context).name
 517         return res
 518
 519     def _product_price(self, cr, uid, ids, name, arg, context=None):
 520         plobj = self.pool.get('product.pricelist')
 521         res = {}
 522         if context is None:
 523             context = {}
 524         quantity = context.get('quantity') or 1.0
 525         pricelist = context.get('pricelist', False)
 526         partner = context.get('partner', False)
 527         if pricelist:
 528             # Support context pricelists specified as display_name or ID for compatibility
 529             if isinstance(pricelist, basestring):
 530                 pricelist_ids = plobj.name_search(
 531                     cr, uid, pricelist, operator='=', context=context, limit=1)
 532                 pricelist = pricelist_ids[0][0] if pricelist_ids else pricelist
 533
 534             if isinstance(pricelist, (int, long)):
 535                 products = self.browse(cr, uid, ids, context=context)
 536                 qtys = map(lambda x: (x, quantity, partner), products)
 537                 pl = plobj.browse(cr, uid, pricelist, context=context)
 538                 price = plobj._price_get_multi(cr,uid, pl, qtys, context=context)
 539                 for id in ids:
 540                     res[id] = price.get(id, 0.0)
 541         for id in ids:
 542             res.setdefault(id, 0.0)
 543         return res
 544
 545     def _get_product_available_func(states, what):
 546         def _product_available(self, cr, uid, ids, name, arg, context=None):
 547             return {}.fromkeys(ids, 0.0)
 548         return _product_available
 549
 550     _product_qty_available = _get_product_available_func(('done',), ('in', 'out'))
 551     _product_virtual_available = _get_product_available_func(('confirmed','waiting','assigned','done'), ('in', 'out'))
 552     _product_outgoing_qty = _get_product_available_func(('confirmed','waiting','assigned'), ('out',))
 553     _product_incoming_qty = _get_product_available_func(('confirmed','waiting','assigned'), ('in',))
 554
 555     def _product_lst_price(self, cr, uid, ids, name, arg, context=None):
 556         res = {}
 557         product_uom_obj = self.pool.get('product.uom')
 558         for id in ids:
 559             res.setdefault(id, 0.0)
 560         for product in self.browse(cr, uid, ids, context=context):
 561             if 'uom' in context:
 562                 uom = product.uos_id or product.uom_id
 563                 res[product.id] = product_uom_obj._compute_price(cr, uid,
 564                         uom.id, product.list_price, context['uom'])
 565             else:
 566                 res[product.id] = product.list_price
 567             res[product.id] =  (res[product.id] or 0.0) * (product.price_margin or 1.0) + product.price_extra
 568         return res
 569
 570     def _save_product_lst_price(self, cr, uid, product_id, field_name, field_value, arg, context=None):
 571         field_value = field_value or 0.0
 572         product = self.browse(cr, uid, product_id, context=context)
 573         list_price = (field_value - product.price_extra) / (product.price_margin or 1.0)
 574         return self.write(cr, uid, [product_id], {'list_price': list_price}, context=context)
 575
 576
 577     def _get_partner_code_name(self, cr, uid, ids, product, partner_id, context=None):
 578         for supinfo in product.seller_ids:
 579             if supinfo.name.id == partner_id:
 580                 return {'code': supinfo.product_code or product.default_code, 'name': supinfo.product_name or product.name, 'variants': ''}
 581         res = {'code': product.default_code, 'name': product.name, 'variants': product.variants}
 582         return res
 583
 584     def _product_code(self, cr, uid, ids, name, arg, context=None):
 585         res = {}
 586         if context is None:
 587             context = {}
 588         for p in self.browse(cr, uid, ids, context=context):
 589             res[p.id] = self._get_partner_code_name(cr, uid, [], p, context.get('partner_id', None), context=context)['code']
 590         return res
 591
 592     def _product_partner_ref(self, cr, uid, ids, name, arg, context=None):
 593         res = {}
 594         if context is None:
 595             context = {}
 596         for p in self.browse(cr, uid, ids, context=context):
 597             data = self._get_partner_code_name(cr, uid, [], p, context.get('partner_id', None), context=context)
 598             if not data['variants']:
 599                 data['variants'] = p.variants
 600             if not data['code']:
 601                 data['code'] = p.code
 602             if not data['name']:
 603                 data['name'] = p.name
 604             res[p.id] = (data['code'] and ('['+data['code']+'] ') or '') + \
 605                     (data['name'] or '') + (data['variants'] and (' - '+data['variants']) or '')
 606         return res
 607
 608     def _is_only_child(self, cr, uid, ids, name, arg, context=None):
 609         res = dict.fromkeys(ids, True)
 610         for product in self.browse(cr, uid, ids, context=context):
 611             if product.product_tmpl_id and len(product.product_tmpl_id.product_variant_ids) > 1:
 612                 res[product.id] = False
 613         return res
 614
 615     def _get_main_product_supplier(self, cr, uid, product, context=None):
 616         """Determines the main (best) product supplier for ``product``,
 617         returning the corresponding ``supplierinfo`` record, or False
 618         if none were found. The default strategy is to select the
 619         supplier with the highest priority (i.e. smallest sequence).
 620
 621         :param browse_record product: product to supply
 622         :rtype: product.supplierinfo browse_record or False
 623         """
 624         sellers = [(seller_info.sequence, seller_info)
 625                        for seller_info in product.seller_ids or []
 626                        if seller_info and isinstance(seller_info.sequence, (int, long))]
 627         return sellers and sellers[0][1] or False
 628
 629     def _calc_seller(self, cr, uid, ids, fields, arg, context=None):
 630         result = {}
 631         for product in self.browse(cr, uid, ids, context=context):
 632             main_supplier = self._get_main_product_supplier(cr, uid, product, context=context)
 633             result[product.id] = {
 634                 'seller_info_id': main_supplier and main_supplier.id or False,
 635                 'seller_delay': main_supplier.delay if main_supplier else 1,
 636                 'seller_qty': main_supplier and main_supplier.qty or 0.0,
 637                 'seller_id': main_supplier and main_supplier.name.id or False
 638             }
 639         return result
 640
 641     def _get_name_template_ids(self, cr, uid, ids, context=None):
 642         result = set()
 643         template_ids = self.pool.get('product.product').search(cr, uid, [('product_tmpl_id', 'in', ids)])
 644         for el in template_ids:
 645             result.add(el)
 646         return list(result)
 647
 648     _columns = {
 649         'qty_available': fields.function(_product_qty_available, type='float', string='Quantity On Hand'),
 650         'virtual_available': fields.function(_product_virtual_available, type='float', string='Quantity Available'),
 651         'incoming_qty': fields.function(_product_incoming_qty, type='float', string='Incoming'),
 652         'outgoing_qty': fields.function(_product_outgoing_qty, type='float', string='Outgoing'),
 653         'price': fields.function(_product_price, fnct_inv=_save_product_lst_price, type='float', string='Price', digits_compute=dp.get_precision('Product Price')),
 654         'lst_price' : fields.function(_product_lst_price, fnct_inv=_save_product_lst_price, type='float', string='Public Price', digits_compute=dp.get_precision('Product Price')),
 655         'code': fields.function(_product_code, type='char', string='Internal Reference'),
 656         'partner_ref' : fields.function(_product_partner_ref, type='char', string='Customer ref'),
 657         'default_code' : fields.char('Internal Reference', select=True),
 658         'active': fields.boolean('Active', help="If unchecked, it will allow you to hide the product without removing it."),
 659         'variants': fields.char('Variants', translate=True),
 660         'product_tmpl_id': fields.many2one('product.template', 'Product Template', required=True, ondelete="cascade", select=True),
 661         'is_only_child': fields.function(
 662             _is_only_child, type='boolean', string='Sole child of the parent template'),
 663         'ean13': fields.char('EAN13 Barcode', size=13, help="International Article Number used for product identification."),
 664         '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."),
 665         'price_extra': fields.float('Variant Price Extra', digits_compute=dp.get_precision('Product Price'), help="Price Extra: Extra price for the variant on sale price. eg. 200 price extra, 1000 + 200 = 1200."),
 666         'price_margin': fields.float('Variant Price Margin', digits_compute=dp.get_precision('Product Price'), help="Price Margin: Margin in percentage amount on sale price for the variant. eg. 10 price margin, 1000 * 1.1 = 1100."),
 667         'pricelist_id': fields.dummy(string='Pricelist', relation='product.pricelist', type='many2one'),
 668         'name_template': fields.related('product_tmpl_id', 'name', string="Template Name", type='char', store={
 669             'product.template': (_get_name_template_ids, ['name'], 10),
 670             'product.product': (lambda self, cr, uid, ids, c=None: ids, [], 10),
 671         }, select=True),
 672         'color': fields.integer('Color Index'),
 673         'seller_info_id': fields.function(_calc_seller, type='many2one', relation="product.supplierinfo", string="Supplier Info", multi="seller_info"),
 674         '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."),
 675         'seller_qty': fields.function(_calc_seller, type='float', string='Supplier Quantity', multi="seller_info", help="This is minimum quantity to purchase from Main Supplier."),
 676         '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"),
 677     }
 678
 679     _defaults = {
 680         'active': lambda *a: 1,
 681         'price_extra': lambda *a: 0.0,
 682         'price_margin': lambda *a: 1.0,
 683         'color': 0,
 684         'is_only_child': True,
 685     }
 686
 687     def unlink(self, cr, uid, ids, context=None):
 688         unlink_ids = []
 689         unlink_product_tmpl_ids = []
 690         for product in self.browse(cr, uid, ids, context=context):
 691             # Check if product still exists, in case it has been unlinked by unlinking its template
 692             if not product.exists():
 693                 continue
 694             tmpl_id = product.product_tmpl_id.id
 695             # Check if the product is last product of this template
 696             other_product_ids = self.search(cr, uid, [('product_tmpl_id', '=', tmpl_id), ('id', '!=', product.id)], context=context)
 697             if not other_product_ids:
 698                 unlink_product_tmpl_ids.append(tmpl_id)
 699             unlink_ids.append(product.id)
 700         res = super(product_product, self).unlink(cr, uid, unlink_ids, context=context)
 701         # delete templates after calling super, as deleting template could lead to deleting
 702         # products due to ondelete='cascade'
 703         self.pool.get('product.template').unlink(cr, uid, unlink_product_tmpl_ids, context=context)
 704         return res
 705
 706     def onchange_uom(self, cursor, user, ids, uom_id, uom_po_id):
 707         if uom_id and uom_po_id:
 708             uom_obj=self.pool.get('product.uom')
 709             uom=uom_obj.browse(cursor,user,[uom_id])[0]
 710             uom_po=uom_obj.browse(cursor,user,[uom_po_id])[0]
 711             if uom.category_id.id != uom_po.category_id.id:
 712                 return {'value': {'uom_po_id': uom_id}}
 713         return False
 714
 715     def _check_ean_key(self, cr, uid, ids, context=None):
 716         for product in self.read(cr, uid, ids, ['ean13'], context=context):
 717             res = check_ean(product['ean13'])
 718         return res
 719
 720     _constraints = [(_check_ean_key, 'You provided an invalid "EAN13 Barcode" reference. You may use the "Internal Reference" field instead.', ['ean13'])]
 721
 722     def on_order(self, cr, uid, ids, orderline, quantity):
 723         pass
 724
 725     def name_get(self, cr, user, ids, context=None):
 726         if context is None:
 727             context = {}
 728         if isinstance(ids, (int, long)):
 729             ids = [ids]
 730         if not len(ids):
 731             return []
 732         def _name_get(d):
 733             name = d.get('name','')
 734             code = d.get('default_code',False)
 735             if code:
 736                 name = '[%s] %s' % (code,name)
 737             if d.get('variants'):
 738                 name = name + ' - %s' % (d['variants'],)
 739             return (d['id'], name)
 740
 741         partner_id = context.get('partner_id', False)
 742         if partner_id:
 743             partner_ids = [partner_id, self.pool['res.partner'].browse(cr, user, partner_id, context=context).commercial_partner_id.id]
 744         else:
 745             partner_ids = []
 746
 747         # all user don't have access to seller and partner
 748         # check access and use superuser
 749         self.check_access_rights(cr, user, "read")
 750         self.check_access_rule(cr, user, ids, "read", context=context)
 751
 752         result = []
 753         for product in self.browse(cr, SUPERUSER_ID, ids, context=context):
 754             sellers = partner_ids and filter(lambda x: x.name.id in partner_ids, product.seller_ids) or []
 755             if sellers:
 756                 for s in sellers:
 757                     mydict = {
 758                               'id': product.id,
 759                               'name': s.product_name or product.name,
 760                               'default_code': s.product_code or product.default_code,
 761                               'variants': product.variants
 762                               }
 763                     result.append(_name_get(mydict))
 764             else:
 765                 mydict = {
 766                           'id': product.id,
 767                           'name': product.name,
 768                           'default_code': product.default_code,
 769                           'variants': product.variants
 770                           }
 771                 result.append(_name_get(mydict))
 772         return result
 773
 774     def name_search(self, cr, user, name='', args=None, operator='ilike', context=None, limit=100):
 775         if not args:
 776             args = []
 777         if name:
 778             positive_operators = ['=', 'ilike', '=ilike', 'like', '=like']
 779             ids = []
 780             if operator in positive_operators:
 781                 ids = self.search(cr, user, [('default_code','=',name)]+ args, limit=limit, context=context)
 782                 if not ids:
 783                     ids = self.search(cr, user, [('ean13','=',name)]+ args, limit=limit, context=context)
 784             if not ids and operator not in expression.NEGATIVE_TERM_OPERATORS:
 785                 # Do not merge the 2 next lines into one single search, SQL search performance would be abysmal
 786                 # on a database with thousands of matching products, due to the huge merge+unique needed for the
 787                 # OR operator (and given the fact that the 'name' lookup results come from the ir.translation table
 788                 # Performing a quick memory merge of ids in Python will give much better performance
 789                 ids = set(self.search(cr, user, args + [('default_code', operator, name)], limit=limit, context=context))
 790                 if not limit or len(ids) < limit:
 791                     # we may underrun the limit because of dupes in the results, that's fine
 792                     limit2 = (limit - len(ids)) if limit else False
 793                     ids.update(self.search(cr, user, args + [('name', operator, name)], limit=limit2, context=context))
 794                 ids = list(ids)
 795             elif not ids and operator in expression.NEGATIVE_TERM_OPERATORS:
 796                 ids = self.search(cr, user, args + ['&', ('default_code', operator, name), ('name', operator, name)], limit=limit, context=context)
 797             if not ids and operator in positive_operators:
 798                 ptrn = re.compile('(\[(.*?)\])')
 799                 res = ptrn.search(name)
 800                 if res:
 801                     ids = self.search(cr, user, [('default_code','=', res.group(2))] + args, limit=limit, context=context)
 802         else:
 803             ids = self.search(cr, user, args, limit=limit, context=context)
 804         result = self.name_get(cr, user, ids, context=context)
 805         return result
 806
 807     #
 808     # Could be overrided for variants matrices prices
 809     #
 810     def price_get(self, cr, uid, ids, ptype='list_price', context=None):
 811         products = self.browse(cr, uid, ids, context=context)
 812         return self._price_get(cr, uid, products, ptype=ptype, context=context)
 813
 814     def _price_get(self, cr, uid, products, ptype='list_price', context=None):
 815         if context is None:
 816             context = {}
 817
 818         if 'currency_id' in context:
 819             pricetype_obj = self.pool.get('product.price.type')
 820             price_type_id = pricetype_obj.search(cr, uid, [('field','=',ptype)])[0]
 821             price_type_currency_id = pricetype_obj.browse(cr,uid,price_type_id).currency_id.id
 822
 823         res = {}
 824         company_id = self.pool['res.users'].read(cr, uid, uid, ['company_id'], context=context)['company_id'][0]
 825         # standard_price field can only be seen by users in base.group_user
 826         # Thus, in order to compute the sale price from the cost price for users not in this group
 827         # We fetch the standard price as the superuser
 828         for product in products:
 829             if ptype != 'standard_price':
 830                 res[product.id] = product[ptype] or 0.0
 831             else:
 832                 res[product.id] = self.read(cr, SUPERUSER_ID, product.id, [ptype], context=dict(context, force_company=company_id))[ptype] or 0.0
 833
 834         product_uom_obj = self.pool.get('product.uom')
 835         for product in products:
 836             if ptype == 'list_price':
 837                 res[product.id] = (res[product.id] * (product.price_margin or 1.0)) + \
 838                         product.price_extra
 839             if 'uom' in context:
 840                 uom = product.uom_id or product.uos_id
 841                 res[product.id] = product_uom_obj._compute_price(cr, uid,
 842                         uom.id, res[product.id], context['uom'])
 843             # Convert from price_type currency to asked one
 844             if 'currency_id' in context:
 845                 # Take the price_type currency from the product field
 846                 # This is right cause a field cannot be in more than one currency
 847                 res[product.id] = self.pool.get('res.currency').compute(cr, uid, price_type_currency_id,
 848                     context['currency_id'], res[product.id],context=context)
 849
 850         return res
 851
 852     def copy(self, cr, uid, id, default=None, context=None):
 853         if context is None:
 854             context={}
 855
 856         product = self.browse(cr, uid, id, context)
 857         if context.get('variant'):
 858             # if we copy a variant or create one, we keep the same template
 859             default['product_tmpl_id'] = product.product_tmpl_id.id
 860         elif 'name' not in default:
 861             default['name'] = _("%s (copy)") % (product.name,)
 862
 863         return super(product_product, self).copy(cr, uid, id, default=default, context=context)
 864
 865     def search(self, cr, uid, args, offset=0, limit=None, order=None, context=None, count=False):
 866         if context is None:
 867             context = {}
 868         if context.get('search_default_categ_id'):
 869             args.append((('categ_id', 'child_of', context['search_default_categ_id'])))
 870         return super(product_product, self).search(cr, uid, args, offset=offset, limit=limit, order=order, context=context, count=count)
 871
 872     def open_product_template(self, cr, uid, ids, context=None):
 873         """ Utility method used to add an "Open Template" button in product views """
 874         product = self.browse(cr, uid, ids[0], context=context)
 875         return {'type': 'ir.actions.act_window',
 876                 'res_model': 'product.template',
 877                 'view_mode': 'form',
 878                 'res_id': product.product_tmpl_id.id,
 879                 'target': 'new'}
 880
 881     def _compute_uos_qty(self, cr, uid, ids, uom, qty, uos, context=None):
 882         '''
 883         Computes product's invoicing quantity in UoS from quantity in UoM.
 884         Takes into account the
 885         :param uom: Source unit
 886         :param qty: Source quantity
 887         :param uos: Target UoS unit.
 888         '''
 889         if not uom or not qty or not uos:
 890             return qty
 891         uom_obj = self.pool['product.uom']
 892         product_id = ids[0] if isinstance(ids, (list, tuple)) else ids
 893         product = self.browse(cr, uid, product_id, context=context)
 894         if isinstance(uos, (int, long)):
 895             uos = uom_obj.browse(cr, uid, uos, context=context)
 896         if isinstance(uom, (int, long)):
 897             uom = uom_obj.browse(cr, uid, uom, context=context)
 898         if product.uos_id:  # Product has UoS defined
 899             # We cannot convert directly between units even if the units are of the same category
 900             # as we need to apply the conversion coefficient which is valid only between quantities
 901             # in product's default UoM/UoS
 902             qty_default_uom = uom_obj._compute_qty_obj(cr, uid, uom, qty, product.uom_id)  # qty in product's default UoM
 903             qty_default_uos = qty_default_uom * product.uos_coeff
 904             return uom_obj._compute_qty_obj(cr, uid, product.uos_id, qty_default_uos, uos)
 905         else:
 906             return uom_obj._compute_qty_obj(cr, uid, uom, qty, uos)
 907
 908
 909
 910 class product_packaging(osv.osv):
 911     _name = "product.packaging"
 912     _description = "Packaging"
 913     _rec_name = 'ean'
 914     _order = 'sequence'
 915     _columns = {
 916         'sequence': fields.integer('Sequence', help="Gives the sequence order when displaying a list of packaging."),
 917         'name' : fields.text('Description'),
 918         'qty' : fields.float('Quantity by Package',
 919             help="The total number of products you can put by pallet or box."),
 920         'ul' : fields.many2one('product.ul', 'Type of Package', required=True),
 921         'ul_qty' : fields.integer('Package by layer', help='The number of packages by layer'),
 922         'rows' : fields.integer('Number of Layers', required=True,
 923             help='The number of layers on a pallet or box'),
 924         'product_id' : fields.many2one('product.product', 'Product', select=1, ondelete='cascade', required=True),
 925         'ean' : fields.char('EAN', size=14, help="The EAN code of the package unit."),
 926         'code' : fields.char('Code', help="The code of the transport unit."),
 927         'weight': fields.float('Total Package Weight',
 928             help='The weight of a full package, pallet or box.'),
 929         'weight_ul': fields.float('Empty Package Weight'),
 930         'height': fields.float('Height', help='The height of the package'),
 931         'width': fields.float('Width', help='The width of the package'),
 932         'length': fields.float('Length', help='The length of the package'),
 933     }
 934
 935
 936     def _check_ean_key(self, cr, uid, ids, context=None):
 937         for pack in self.browse(cr, uid, ids, context=context):
 938             res = check_ean(pack.ean)
 939         return res
 940
 941     _constraints = [(_check_ean_key, 'Error: Invalid ean code', ['ean'])]
 942
 943     def name_get(self, cr, uid, ids, context=None):
 944         if not len(ids):
 945             return []
 946         res = []
 947         for pckg in self.browse(cr, uid, ids, context=context):
 948             p_name = pckg.ean and '[' + pckg.ean + '] ' or ''
 949             p_name += pckg.ul.name
 950             res.append((pckg.id,p_name))
 951         return res
 952
 953     def _get_1st_ul(self, cr, uid, context=None):
 954         cr.execute('select id from product_ul order by id asc limit 1')
 955         res = cr.fetchone()
 956         return (res and res[0]) or False
 957
 958     _defaults = {
 959         'rows' : lambda *a : 3,
 960         'sequence' : lambda *a : 1,
 961         'ul' : _get_1st_ul,
 962     }
 963
 964     def checksum(ean):
 965         salt = '31' * 6 + '3'
 966         sum = 0
 967         for ean_part, salt_part in zip(ean, salt):
 968             sum += int(ean_part) * int(salt_part)
 969         return (10 - (sum % 10)) % 10
 970     checksum = staticmethod(checksum)
 971
 972
 973
 974 class product_supplierinfo(osv.osv):
 975     _name = "product.supplierinfo"
 976     _description = "Information about a product supplier"
 977     def _calc_qty(self, cr, uid, ids, fields, arg, context=None):
 978         result = {}
 979         for supplier_info in self.browse(cr, uid, ids, context=context):
 980             for field in fields:
 981                 result[supplier_info.id] = {field:False}
 982             qty = supplier_info.min_qty
 983             result[supplier_info.id]['qty'] = qty
 984         return result
 985
 986     _columns = {
 987         'name' : fields.many2one('res.partner', 'Supplier', required=True,domain = [('supplier','=',True)], ondelete='cascade', help="Supplier of this product"),
 988         'product_name': fields.char('Supplier Product Name', help="This supplier's product name will be used when printing a request for quotation. Keep empty to use the internal one."),
 989         'product_code': fields.char('Supplier Product Code', help="This supplier's product code will be used when printing a request for quotation. Keep empty to use the internal one."),
 990         'sequence' : fields.integer('Sequence', help="Assigns the priority to the list of product supplier."),
 991         'product_uom': fields.related('product_tmpl_id', 'uom_po_id', type='many2one', relation='product.uom', string="Supplier Unit of Measure", readonly="1", help="This comes from the product form."),
 992         'min_qty': fields.float('Minimal Quantity', required=True, help="The minimal quantity to purchase to this supplier, expressed in the supplier Product Unit of Measure if not empty, in the default unit of measure of the product otherwise."),
 993         'qty': fields.function(_calc_qty, store=True, type='float', string='Quantity', multi="qty", help="This is a quantity which is converted into Default Unit of Measure."),
 994         'product_tmpl_id' : fields.many2one('product.template', 'Product Template', required=True, ondelete='cascade', select=True, oldname='product_id'),
 995         'delay' : fields.integer('Delivery Lead Time', required=True, help="Lead time in days between the confirmation of the purchase order and the reception of the products in your warehouse. Used by the scheduler for automatic computation of the purchase order planning."),
 996         'pricelist_ids': fields.one2many('pricelist.partnerinfo', 'suppinfo_id', 'Supplier Pricelist'),
 997         'company_id':fields.many2one('res.company','Company',select=1),
 998     }
 999     _defaults = {
1000         'qty': lambda *a: 0.0,
1001         'sequence': lambda *a: 1,
1002         'delay': lambda *a: 1,
1003         'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'product.supplierinfo', context=c),
1004     }
1005     def price_get(self, cr, uid, supplier_ids, product_id, product_qty=1, context=None):
1006         """
1007         Calculate price from supplier pricelist.
1008         @param supplier_ids: Ids of res.partner object.
1009         @param product_id: Id of product.
1010         @param product_qty: specify quantity to purchase.
1011         """
1012         if type(supplier_ids) in (int,long,):
1013             supplier_ids = [supplier_ids]
1014         res = {}
1015         product_pool = self.pool.get('product.product')
1016         partner_pool = self.pool.get('res.partner')
1017         pricelist_pool = self.pool.get('product.pricelist')
1018         currency_pool = self.pool.get('res.currency')
1019         currency_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id.id
1020         # Compute price from standard price of product
1021         product_price = product_pool.price_get(cr, uid, [product_id], 'standard_price', context=context)[product_id]
1022         product = product_pool.browse(cr, uid, product_id, context=context)
1023         for supplier in partner_pool.browse(cr, uid, supplier_ids, context=context):
1024             price = product_price
1025             # Compute price from Purchase pricelist of supplier
1026             pricelist_id = supplier.property_product_pricelist_purchase.id
1027             if pricelist_id:
1028                 price = pricelist_pool.price_get(cr, uid, [pricelist_id], product_id, product_qty, context=context).setdefault(pricelist_id, 0)
1029                 price = currency_pool.compute(cr, uid, pricelist_pool.browse(cr, uid, pricelist_id).currency_id.id, currency_id, price)
1030
1031             # Compute price from supplier pricelist which are in Supplier Information
1032             supplier_info_ids = self.search(cr, uid, [('name','=',supplier.id),('product_tmpl_id','=',product.product_tmpl_id.id)])
1033             if supplier_info_ids:
1034                 cr.execute('SELECT * ' \
1035                     'FROM pricelist_partnerinfo ' \
1036                     'WHERE suppinfo_id IN %s' \
1037                     'AND min_quantity <= %s ' \
1038                     'ORDER BY min_quantity DESC LIMIT 1', (tuple(supplier_info_ids),product_qty,))
1039                 res2 = cr.dictfetchone()
1040                 if res2:
1041                     price = res2['price']
1042             res[supplier.id] = price
1043         return res
1044     _order = 'sequence'
1045
1046
1047 class pricelist_partnerinfo(osv.osv):
1048     _name = 'pricelist.partnerinfo'
1049     _columns = {
1050         'name': fields.char('Description'),
1051         'suppinfo_id': fields.many2one('product.supplierinfo', 'Partner Information', required=True, ondelete='cascade'),
1052         '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."),
1053         '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"),
1054     }
1055     _order = 'min_quantity asc'
1056
1057 class res_currency(osv.osv):
1058     _inherit = 'res.currency'
1059
1060     def _check_main_currency_rounding(self, cr, uid, ids, context=None):
1061         cr.execute('SELECT digits FROM decimal_precision WHERE name like %s',('Account',))
1062         digits = cr.fetchone()
1063         if digits and len(digits):
1064             digits = digits[0]
1065             main_currency = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id
1066             for currency_id in ids:
1067                 if currency_id == main_currency.id:
1068                     if main_currency.rounding < 10 ** -digits:
1069                         return False
1070         return True
1071
1072     _constraints = [
1073         (_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']),
1074     ]
1075
1076 class decimal_precision(osv.osv):
1077     _inherit = 'decimal.precision'
1078
1079     def _check_main_currency_rounding(self, cr, uid, ids, context=None):
1080         cr.execute('SELECT id, digits FROM decimal_precision WHERE name like %s',('Account',))
1081         res = cr.fetchone()
1082         if res and len(res):
1083             account_precision_id, digits = res
1084             main_currency = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id
1085             for decimal_precision in ids:
1086                 if decimal_precision == account_precision_id:
1087                     if main_currency.rounding < 10 ** -digits:
1088                         return False
1089         return True
1090
1091     _constraints = [
1092         (_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']),
1093     ]
1094
1095 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: