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 import time
  25 from _common import ceiling
  26
  27 from openerp import SUPERUSER_ID
  28 from openerp import tools
  29 from openerp.osv import osv, fields
  30 from openerp.tools.translate import _
  31 from openerp.tools import DEFAULT_SERVER_DATETIME_FORMAT
  32
  33 import openerp.addons.decimal_precision as dp
  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', 'Product 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=(12, 12),
 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=(12,12),
 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, round=True):
 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, round=round)
 171
 172     def _compute_qty_obj(self, cr, uid, from_unit, qty, to_unit, round=True, 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         amount = qty / from_unit.factor
 181         if to_unit:
 182             amount = amount * to_unit.factor
 183             if round:
 184                 amount = ceiling(amount, to_unit.rounding)
 185         return amount
 186
 187     def _compute_price(self, cr, uid, from_uom_id, price, to_uom_id=False):
 188         if not from_uom_id or not price or not to_uom_id:
 189             return price
 190         from_unit, to_unit = self.browse(cr, uid, [from_uom_id, to_uom_id])
 191         if from_unit.category_id.id != to_unit.category_id.id:
 192             return price
 193         amount = price * from_unit.factor
 194         if to_uom_id:
 195             amount = amount / to_unit.factor
 196         return amount
 197
 198     def onchange_type(self, cursor, user, ids, value):
 199         if value == 'reference':
 200             return {'value': {'factor': 1, 'factor_inv': 1}}
 201         return {}
 202
 203     def write(self, cr, uid, ids, vals, context=None):
 204         if 'category_id' in vals:
 205             for uom in self.browse(cr, uid, ids, context=context):
 206                 if uom.category_id.id != vals['category_id']:
 207                     raise osv.except_osv(_('Warning!'),_("Cannot change the category of existing Unit of Measure '%s'.") % (uom.name,))
 208         return super(product_uom, self).write(cr, uid, ids, vals, context=context)
 209
 210
 211
 212 class product_ul(osv.osv):
 213     _name = "product.ul"
 214     _description = "Logistic Unit"
 215     _columns = {
 216         'name' : fields.char('Name', select=True, required=True, translate=True),
 217         'type' : fields.selection([('unit','Unit'),('pack','Pack'),('box', 'Box'), ('pallet', 'Pallet')], 'Type', required=True),
 218         'height': fields.float('Height', help='The height of the package'),
 219         'width': fields.float('Width', help='The width of the package'),
 220         'length': fields.float('Length', help='The length of the package'),
 221         'weight': fields.float('Empty Package Weight'),
 222     }
 223
 224
 225 #----------------------------------------------------------
 226 # Categories
 227 #----------------------------------------------------------
 228 class product_category(osv.osv):
 229
 230     def name_get(self, cr, uid, ids, context=None):
 231         if isinstance(ids, (list, tuple)) and not len(ids):
 232             return []
 233         if isinstance(ids, (long, int)):
 234             ids = [ids]
 235         reads = self.read(cr, uid, ids, ['name','parent_id'], context=context)
 236         res = []
 237         for record in reads:
 238             name = record['name']
 239             if record['parent_id']:
 240                 name = record['parent_id'][1]+' / '+name
 241             res.append((record['id'], name))
 242         return res
 243
 244     def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=100):
 245         if not args:
 246             args = []
 247         if not context:
 248             context = {}
 249         if name:
 250             # Be sure name_search is symetric to name_get
 251             name = name.split(' / ')[-1]
 252             ids = self.search(cr, uid, [('name', operator, name)] + args, limit=limit, context=context)
 253         else:
 254             ids = self.search(cr, uid, args, limit=limit, context=context)
 255         return self.name_get(cr, uid, ids, context)
 256
 257     def _name_get_fnc(self, cr, uid, ids, prop, unknow_none, context=None):
 258         res = self.name_get(cr, uid, ids, context=context)
 259         return dict(res)
 260
 261     _name = "product.category"
 262     _description = "Product Category"
 263     _columns = {
 264         'name': fields.char('Name', required=True, translate=True, select=True),
 265         'complete_name': fields.function(_name_get_fnc, type="char", string='Name'),
 266         'parent_id': fields.many2one('product.category','Parent Category', select=True, ondelete='cascade'),
 267         'child_id': fields.one2many('product.category', 'parent_id', string='Child Categories'),
 268         'sequence': fields.integer('Sequence', select=True, help="Gives the sequence order when displaying a list of product categories."),
 269         '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."),
 270         'parent_left': fields.integer('Left Parent', select=1),
 271         'parent_right': fields.integer('Right Parent', select=1),
 272     }
 273
 274
 275     _defaults = {
 276         'type' : lambda *a : 'normal',
 277     }
 278
 279     _parent_name = "parent_id"
 280     _parent_store = True
 281     _parent_order = 'sequence, name'
 282     _order = 'parent_left'
 283
 284     _constraints = [
 285         (osv.osv._check_recursion, 'Error ! You cannot create recursive categories.', ['parent_id'])
 286     ]
 287
 288
 289 class produce_price_history(osv.osv):
 290     """
 291     Keep track of the ``product.template`` standard prices as they are changed.
 292     """
 293
 294     _name = 'product.price.history'
 295     _rec_name = 'datetime'
 296     _order = 'datetime desc'
 297
 298     _columns = {
 299         'company_id': fields.many2one('res.company', required=True),
 300         'product_template_id': fields.many2one('product.template', 'Product Template', required=True, ondelete='cascade'),
 301         'datetime': fields.datetime('Historization Time'),
 302         'cost': fields.float('Historized Cost'),
 303     }
 304
 305     def _get_default_company(self, cr, uid, context=None):
 306         if 'force_company' in context:
 307             return context['force_company']
 308         else:
 309             company = self.pool['res.users'].browse(cr, uid, uid,
 310                 context=context).company_id
 311             return company.id if company else False
 312
 313     _defaults = {
 314         'datetime': fields.datetime.now,
 315         'company_id': _get_default_company,
 316     }
 317
 318
 319 class product_public_category(osv.osv):
 320     _name = "product.public.category"
 321     _description = "Public Category"
 322     _order = "sequence, name"
 323
 324     _constraints = [
 325         (osv.osv._check_recursion, 'Error ! You cannot create recursive categories.', ['parent_id'])
 326     ]
 327
 328     def name_get(self, cr, uid, ids, context=None):
 329         if not len(ids):
 330             return []
 331         reads = self.read(cr, uid, ids, ['name','parent_id'], context=context)
 332         res = []
 333         for record in reads:
 334             name = record['name']
 335             if record['parent_id']:
 336                 name = record['parent_id'][1]+' / '+name
 337             res.append((record['id'], name))
 338         return res
 339
 340     def _name_get_fnc(self, cr, uid, ids, prop, unknow_none, context=None):
 341         res = self.name_get(cr, uid, ids, context=context)
 342         return dict(res)
 343
 344     def _get_image(self, cr, uid, ids, name, args, context=None):
 345         result = dict.fromkeys(ids, False)
 346         for obj in self.browse(cr, uid, ids, context=context):
 347             result[obj.id] = tools.image_get_resized_images(obj.image)
 348         return result
 349
 350     def _set_image(self, cr, uid, id, name, value, args, context=None):
 351         return self.write(cr, uid, [id], {'image': tools.image_resize_image_big(value)}, context=context)
 352
 353     _columns = {
 354         'name': fields.char('Name', required=True, translate=True),
 355         'complete_name': fields.function(_name_get_fnc, type="char", string='Name'),
 356         'parent_id': fields.many2one('product.public.category','Parent Category', select=True),
 357         'child_id': fields.one2many('product.public.category', 'parent_id', string='Children Categories'),
 358         'sequence': fields.integer('Sequence', help="Gives the sequence order when displaying a list of product categories."),
 359
 360         # NOTE: there is no 'default image', because by default we don't show thumbnails for categories. However if we have a thumbnail
 361         # for at least one category, then we display a default image on the other, so that the buttons have consistent styling.
 362         # In this case, the default image is set by the js code.
 363         # NOTE2: image: all image fields are base64 encoded and PIL-supported
 364         'image': fields.binary("Image",
 365             help="This field holds the image used as image for the cateogry, limited to 1024x1024px."),
 366         'image_medium': fields.function(_get_image, fnct_inv=_set_image,
 367             string="Medium-sized image", type="binary", multi="_get_image",
 368             store={
 369                 'product.public.category': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 370             },
 371             help="Medium-sized image of the category. It is automatically "\
 372                  "resized as a 128x128px image, with aspect ratio preserved. "\
 373                  "Use this field in form views or some kanban views."),
 374         'image_small': fields.function(_get_image, fnct_inv=_set_image,
 375             string="Smal-sized image", type="binary", multi="_get_image",
 376             store={
 377                 'product.public.category': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 378             },
 379             help="Small-sized image of the category. It is automatically "\
 380                  "resized as a 64x64px image, with aspect ratio preserved. "\
 381                  "Use this field anywhere a small image is required."),
 382     }
 383
 384
 385 #----------------------------------------------------------
 386 # Products
 387 #----------------------------------------------------------
 388 class product_template(osv.osv):
 389     _name = "product.template"
 390     _inherit = ['mail.thread']
 391     _description = "Product Template"
 392
 393     def _get_image(self, cr, uid, ids, name, args, context=None):
 394         result = dict.fromkeys(ids, False)
 395         for obj in self.browse(cr, uid, ids, context=context):
 396             result[obj.id] = tools.image_get_resized_images(obj.image, avoid_resize_medium=True)
 397         return result
 398
 399     def _set_image(self, cr, uid, id, name, value, args, context=None):
 400         return self.write(cr, uid, [id], {'image': tools.image_resize_image_big(value)}, context=context)
 401
 402     def get_history_price(self, cr, uid, product_tmpl, company_id, date=None, context=None):
 403         if context is None:
 404             context = {}
 405         if date is None:
 406             date = time.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
 407         price_history_obj = self.pool.get('product.price.history')
 408         history_ids = price_history_obj.search(cr, uid, [('company_id', '=', company_id), ('product_template_id', '=', product_tmpl), ('datetime', '<=', date)], limit=1)
 409         if history_ids:
 410             return price_history_obj.read(cr, uid, history_ids[0], ['cost'], context=context)['cost']
 411         return 0.0
 412
 413     def _set_standard_price(self, cr, uid, product_tmpl_id, value, context=None):
 414         ''' Store the standard price change in order to be able to retrieve the cost of a product template for a given date'''
 415         price_history_obj = self.pool['product.price.history']
 416         user_company = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.id
 417         company_id = context.get('force_company', user_company)
 418         price_history_obj.create(cr, uid, {
 419             'product_template_id': product_tmpl_id,
 420             'cost': value,
 421             'company_id': company_id,
 422         }, context=context)
 423
 424     _columns = {
 425         'name': fields.char('Name', required=True, translate=True, select=True),
 426         'product_manager': fields.many2one('res.users','Product Manager'),
 427         'description': fields.text('Description',translate=True,
 428             help="A precise description of the Product, used only for internal information purposes."),
 429         'description_purchase': fields.text('Purchase Description',translate=True,
 430             help="A description of the Product that you want to communicate to your suppliers. "
 431                  "This description will be copied to every Purchase Order, Reception and Supplier Invoice/Refund."),
 432         'description_sale': fields.text('Sale Description',translate=True,
 433             help="A description of the Product that you want to communicate to your customers. "
 434                  "This description will be copied to every Sale Order, Delivery Order and Customer Invoice/Refund"),
 435         '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."),
 436         'rental': fields.boolean('Can be Rent'),
 437         'categ_id': fields.many2one('product.category','Category', required=True, change_default=True, domain="[('type','=','normal')]" ,help="Select category for the current product"),
 438         '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)."),
 439         '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."),
 440         'standard_price': fields.property(type = 'float', digits_compute=dp.get_precision('Product Price'),
 441                                           help="Cost price of the product template used for standard stock valuation in accounting and used as a base price on purchase orders.",
 442                                           groups="base.group_user", string="Cost Price"),
 443         'volume': fields.float('Volume', help="The volume in m3."),
 444         'weight': fields.float('Gross Weight', digits_compute=dp.get_precision('Stock Weight'), help="The gross weight in Kg."),
 445         'weight_net': fields.float('Net Weight', digits_compute=dp.get_precision('Stock Weight'), help="The net weight in Kg."),
 446         'warranty': fields.float('Warranty'),
 447         'sale_ok': fields.boolean('Can be Sold', help="Specify if the product can be selected in a sales order line."),
 448         'state': fields.selection([('',''),
 449             ('draft', 'In Development'),
 450             ('sellable','Normal'),
 451             ('end','End of Lifecycle'),
 452             ('obsolete','Obsolete')], 'Status'),
 453         'uom_id': fields.many2one('product.uom', 'Unit of Measure', required=True, help="Default Unit of Measure used for all stock operation."),
 454         '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."),
 455         'uos_id' : fields.many2one('product.uom', 'Unit of Sale',
 456             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.'),
 457         'uos_coeff': fields.float('Unit of Measure -> UOS Coeff', digits_compute= dp.get_precision('Product UoS'),
 458             help='Coefficient to convert default Unit of Measure to Unit of Sale\n'
 459             ' uos = uom * coeff'),
 460         'mes_type': fields.selection((('fixed', 'Fixed'), ('variable', 'Variable')), 'Measure Type'),
 461         'seller_ids': fields.one2many('product.supplierinfo', 'product_tmpl_id', 'Supplier'),
 462         'company_id': fields.many2one('res.company', 'Company', select=1),
 463         # image: all image fields are base64 encoded and PIL-supported
 464         'image': fields.binary("Image",
 465             help="This field holds the image used as image for the product, limited to 1024x1024px."),
 466         'image_medium': fields.function(_get_image, fnct_inv=_set_image,
 467             string="Medium-sized image", type="binary", multi="_get_image",
 468             store={
 469                 'product.template': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 470             },
 471             help="Medium-sized image of the product. It is automatically "\
 472                  "resized as a 128x128px image, with aspect ratio preserved, "\
 473                  "only when the image exceeds one of those sizes. Use this field in form views or some kanban views."),
 474         'image_small': fields.function(_get_image, fnct_inv=_set_image,
 475             string="Small-sized image", type="binary", multi="_get_image",
 476             store={
 477                 'product.template': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 478             },
 479             help="Small-sized image of the product. It is automatically "\
 480                  "resized as a 64x64px image, with aspect ratio preserved. "\
 481                  "Use this field anywhere a small image is required."),
 482         'product_variant_ids': fields.one2many('product.product', 'product_tmpl_id', 'Product Variants', required=True),
 483     }
 484
 485     def _get_uom_id(self, cr, uid, *args):
 486         cr.execute('select id from product_uom order by id limit 1')
 487         res = cr.fetchone()
 488         return res and res[0] or False
 489
 490     def _default_category(self, cr, uid, context=None):
 491         if context is None:
 492             context = {}
 493         if 'categ_id' in context and context['categ_id']:
 494             return context['categ_id']
 495         md = self.pool.get('ir.model.data')
 496         res = False
 497         try:
 498             res = md.get_object_reference(cr, uid, 'product', 'product_category_all')[1]
 499         except ValueError:
 500             res = False
 501         return res
 502
 503     def onchange_uom(self, cursor, user, ids, uom_id, uom_po_id):
 504         if uom_id:
 505             return {'value': {'uom_po_id': uom_id}}
 506         return {}
 507
 508     def create(self, cr, uid, vals, context=None):
 509         ''' Store the initial standard price in order to be able to retrieve the cost of a product template for a given date'''
 510         product_template_id = super(product_template, self).create(cr, uid, vals, context=context)
 511         self._set_standard_price(cr, uid, product_template_id, vals.get('standard_price', 0.0), context=context)
 512         return product_template_id
 513
 514     def write(self, cr, uid, ids, vals, context=None):
 515         ''' Store the standard price change in order to be able to retrieve the cost of a product template for a given date'''
 516         if isinstance(id, (int, long)):
 517             ids = [ids]
 518         if 'uom_po_id' in vals:
 519             new_uom = self.pool.get('product.uom').browse(cr, uid, vals['uom_po_id'], context=context)
 520             for product in self.browse(cr, uid, ids, context=context):
 521                 old_uom = product.uom_po_id
 522                 if old_uom.category_id.id != new_uom.category_id.id:
 523                     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,))
 524         if 'standard_price' in vals:
 525             for prod_template_id in ids:
 526                 self._set_standard_price(cr, uid, prod_template_id, vals['standard_price'], context=context)
 527         return super(product_template, self).write(cr, uid, ids, vals, context=context)
 528
 529     def copy(self, cr, uid, id, default=None, context=None):
 530         if default is None:
 531             default = {}
 532         template = self.browse(cr, uid, id, context=context)
 533         default['name'] = _("%s (copy)") % (template['name'])
 534         return super(product_template, self).copy(cr, uid, id, default=default, context=context)
 535
 536     _defaults = {
 537         'company_id': lambda s,cr,uid,c: s.pool.get('res.company')._company_default_get(cr, uid, 'product.template', context=c),
 538         'list_price': 1,
 539         'standard_price': 0.0,
 540         'sale_ok': 1,
 541         'uom_id': _get_uom_id,
 542         'uom_po_id': _get_uom_id,
 543         'uos_coeff': 1.0,
 544         'mes_type': 'fixed',
 545         'categ_id' : _default_category,
 546         'type' : 'consu',
 547     }
 548
 549     def _check_uom(self, cursor, user, ids, context=None):
 550         for product in self.browse(cursor, user, ids, context=context):
 551             if product.uom_id.category_id.id != product.uom_po_id.category_id.id:
 552                 return False
 553         return True
 554
 555     def _check_uos(self, cursor, user, ids, context=None):
 556         for product in self.browse(cursor, user, ids, context=context):
 557             if product.uos_id \
 558                     and product.uos_id.category_id.id \
 559                     == product.uom_id.category_id.id:
 560                 return False
 561         return True
 562
 563     _constraints = [
 564         (_check_uom, 'Error: The default Unit of Measure and the purchase Unit of Measure must be in the same category.', ['uom_id']),
 565     ]
 566
 567     def name_get(self, cr, user, ids, context=None):
 568         if context is None:
 569             context = {}
 570         if 'partner_id' in context:
 571             pass
 572         return super(product_template, self).name_get(cr, user, ids, context)
 573
 574
 575 class product_product(osv.osv):
 576     _name = "product.product"
 577     _description = "Product"
 578     _inherits = {'product.template': 'product_tmpl_id'}
 579     _inherit = ['mail.thread']
 580     _order = 'default_code,name_template'
 581
 582     def view_header_get(self, cr, uid, view_id, view_type, context=None):
 583         if context is None:
 584             context = {}
 585         res = super(product_product, self).view_header_get(cr, uid, view_id, view_type, context)
 586         if (context.get('categ_id', False)):
 587             return _('Products: ') + self.pool.get('product.category').browse(cr, uid, context['categ_id'], context=context).name
 588         return res
 589
 590     def _product_price(self, cr, uid, ids, name, arg, context=None):
 591         plobj = self.pool.get('product.pricelist')
 592         res = {}
 593         if context is None:
 594             context = {}
 595         quantity = context.get('quantity') or 1.0
 596         pricelist = context.get('pricelist', False)
 597         partner = context.get('partner', False)
 598         if pricelist:
 599             # Support context pricelists specified as display_name or ID for compatibility
 600             if isinstance(pricelist, basestring):
 601                 pricelist_ids = plobj.name_search(
 602                     cr, uid, pricelist, operator='=', context=context, limit=1)
 603                 pricelist = pricelist_ids[0][0] if pricelist_ids else pricelist
 604
 605             if isinstance(pricelist, (int, long)):
 606                 products = self.browse(cr, uid, ids, context=context)
 607                 qtys = map(lambda x: (x, quantity, partner), products)
 608                 pl = plobj.browse(cr, uid, pricelist, context=context)
 609                 price = plobj._price_get_multi(cr,uid, pl, qtys, context=context)
 610                 for id in ids:
 611                     res[id] = price.get(id, 0.0)
 612         for id in ids:
 613             res.setdefault(id, 0.0)
 614         return res
 615
 616     def _product_lst_price(self, cr, uid, ids, name, arg, context=None):
 617         res = {}
 618         product_uom_obj = self.pool.get('product.uom')
 619         for id in ids:
 620             res.setdefault(id, 0.0)
 621         for product in self.browse(cr, uid, ids, context=context):
 622             if 'uom' in context:
 623                 uom = product.uos_id or product.uom_id
 624                 res[product.id] = product_uom_obj._compute_price(cr, uid,
 625                         uom.id, product.list_price, context['uom'])
 626             else:
 627                 res[product.id] = product.list_price
 628             res[product.id] =  (res[product.id] or 0.0) * (product.price_margin or 1.0) + product.price_extra
 629         return res
 630
 631     def _save_product_lst_price(self, cr, uid, product_id, field_name, field_value, arg, context=None):
 632         field_value = field_value or 0.0
 633         product = self.browse(cr, uid, product_id, context=context)
 634         list_price = (field_value - product.price_extra) / (product.price_margin or 1.0)
 635         return self.write(cr, uid, [product_id], {'list_price': list_price}, context=context)
 636
 637     def _get_partner_code_name(self, cr, uid, ids, product, partner_id, context=None):
 638         for supinfo in product.seller_ids:
 639             if supinfo.name.id == partner_id:
 640                 return {'code': supinfo.product_code or product.default_code, 'name': supinfo.product_name or product.name, 'variants': ''}
 641         res = {'code': product.default_code, 'name': product.name, 'variants': product.variants}
 642         return res
 643
 644     def _product_code(self, cr, uid, ids, name, arg, context=None):
 645         res = {}
 646         if context is None:
 647             context = {}
 648         for p in self.browse(cr, uid, ids, context=context):
 649             res[p.id] = self._get_partner_code_name(cr, uid, [], p, context.get('partner_id', None), context=context)['code']
 650         return res
 651
 652     def _product_partner_ref(self, cr, uid, ids, name, arg, context=None):
 653         res = {}
 654         if context is None:
 655             context = {}
 656         for p in self.browse(cr, uid, ids, context=context):
 657             data = self._get_partner_code_name(cr, uid, [], p, context.get('partner_id', None), context=context)
 658             if not data['variants']:
 659                 data['variants'] = p.variants
 660             if not data['code']:
 661                 data['code'] = p.code
 662             if not data['name']:
 663                 data['name'] = p.name
 664             res[p.id] = (data['code'] and ('['+data['code']+'] ') or '') + \
 665                     (data['name'] or '') + (data['variants'] and (' - '+data['variants']) or '')
 666         return res
 667
 668     def _is_only_child(self, cr, uid, ids, name, arg, context=None):
 669         res = dict.fromkeys(ids, True)
 670         for product in self.browse(cr, uid, ids, context=context):
 671             if product.product_tmpl_id and len(product.product_tmpl_id.product_variant_ids) > 1:
 672                 res[product.id] = False
 673         return res
 674
 675     def _get_main_product_supplier(self, cr, uid, product, context=None):
 676         """Determines the main (best) product supplier for ``product``,
 677         returning the corresponding ``supplierinfo`` record, or False
 678         if none were found. The default strategy is to select the
 679         supplier with the highest priority (i.e. smallest sequence).
 680
 681         :param browse_record product: product to supply
 682         :rtype: product.supplierinfo browse_record or False
 683         """
 684         sellers = [(seller_info.sequence, seller_info)
 685                        for seller_info in product.seller_ids or []
 686                        if seller_info and isinstance(seller_info.sequence, (int, long))]
 687         return sellers and sellers[0][1] or False
 688
 689     def _calc_seller(self, cr, uid, ids, fields, arg, context=None):
 690         result = {}
 691         for product in self.browse(cr, uid, ids, context=context):
 692             main_supplier = self._get_main_product_supplier(cr, uid, product, context=context)
 693             result[product.id] = {
 694                 'seller_info_id': main_supplier and main_supplier.id or False,
 695                 'seller_delay': main_supplier.delay if main_supplier else 1,
 696                 'seller_qty': main_supplier and main_supplier.qty or 0.0,
 697                 'seller_id': main_supplier and main_supplier.name.id or False
 698             }
 699         return result
 700
 701     def _get_name_template_ids(self, cr, uid, ids, context=None):
 702         result = set()
 703         template_ids = self.pool.get('product.product').search(cr, uid, [('product_tmpl_id', 'in', ids)])
 704         for el in template_ids:
 705             result.add(el)
 706         return list(result)
 707
 708     _columns = {
 709         'price': fields.function(_product_price, fnct_inv=_save_product_lst_price, type='float', string='Price', digits_compute=dp.get_precision('Product Price')),
 710         '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')),
 711         'code': fields.function(_product_code, type='char', string='Internal Reference'),
 712         'partner_ref' : fields.function(_product_partner_ref, type='char', string='Customer ref'),
 713         'default_code' : fields.char('Internal Reference', select=True),
 714         'active': fields.boolean('Active', help="If unchecked, it will allow you to hide the product without removing it."),
 715         'variants': fields.char('Variants', translate=True),
 716         'product_tmpl_id': fields.many2one('product.template', 'Product Template', required=True, ondelete="cascade", select=True),
 717         'is_only_child': fields.function(
 718             _is_only_child, type='boolean', string='Sole child of the parent template'),
 719         'ean13': fields.char('EAN13 Barcode', size=13, help="International Article Number used for product identification."),
 720         'packaging': fields.one2many('product.packaging', 'product_id', 'Packaging', 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."),
 721         '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."),
 722         '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."),
 723         'pricelist_id': fields.dummy(string='Pricelist', relation='product.pricelist', type='many2one'),
 724         'name_template': fields.related('product_tmpl_id', 'name', string="Template Name", type='char', store={
 725             'product.template': (_get_name_template_ids, ['name'], 10),
 726             'product.product': (lambda self, cr, uid, ids, c=None: ids, [], 10),
 727         }, select=True),
 728         'color': fields.integer('Color Index'),
 729         'seller_info_id': fields.function(_calc_seller, type='many2one', relation="product.supplierinfo", string="Supplier Info", multi="seller_info"),
 730         '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."),
 731         'seller_qty': fields.function(_calc_seller, type='float', string='Supplier Quantity', multi="seller_info", help="This is minimum quantity to purchase from Main Supplier."),
 732         '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"),
 733     }
 734
 735     _defaults = {
 736         'active': lambda *a: 1,
 737         'price_extra': lambda *a: 0.0,
 738         'price_margin': lambda *a: 1.0,
 739         'color': 0,
 740         'is_only_child': True,
 741     }
 742
 743     def unlink(self, cr, uid, ids, context=None):
 744         unlink_ids = []
 745         unlink_product_tmpl_ids = []
 746         for product in self.browse(cr, uid, ids, context=context):
 747             tmpl_id = product.product_tmpl_id.id
 748             # Check if the product is last product of this template
 749             other_product_ids = self.search(cr, uid, [('product_tmpl_id', '=', tmpl_id), ('id', '!=', product.id)], context=context)
 750             if not other_product_ids:
 751                 unlink_product_tmpl_ids.append(tmpl_id)
 752             unlink_ids.append(product.id)
 753         res = super(product_product, self).unlink(cr, uid, unlink_ids, context=context)
 754         # delete templates after calling super, as deleting template could lead to deleting
 755         # products due to ondelete='cascade'
 756         self.pool.get('product.template').unlink(cr, uid, unlink_product_tmpl_ids, context=context)
 757         return res
 758
 759     def onchange_uom(self, cursor, user, ids, uom_id, uom_po_id):
 760         if uom_id and uom_po_id:
 761             uom_obj=self.pool.get('product.uom')
 762             uom=uom_obj.browse(cursor,user,[uom_id])[0]
 763             uom_po=uom_obj.browse(cursor,user,[uom_po_id])[0]
 764             if uom.category_id.id != uom_po.category_id.id:
 765                 return {'value': {'uom_po_id': uom_id}}
 766         return False
 767
 768     def _check_ean_key(self, cr, uid, ids, context=None):
 769         for product in self.read(cr, uid, ids, ['ean13'], context=context):
 770             res = check_ean(product['ean13'])
 771         return res
 772
 773     _constraints = [(_check_ean_key, 'You provided an invalid "EAN13 Barcode" reference. You may use the "Internal Reference" field instead.', ['ean13'])]
 774
 775     def on_order(self, cr, uid, ids, orderline, quantity):
 776         pass
 777
 778     def name_get(self, cr, user, ids, context=None):
 779         if context is None:
 780             context = {}
 781         if isinstance(ids, (int, long)):
 782             ids = [ids]
 783         if not len(ids):
 784             return []
 785         def _name_get(d):
 786             name = d.get('name','')
 787             code = d.get('default_code',False)
 788             if code:
 789                 name = '[%s] %s' % (code,name)
 790             if d.get('variants'):
 791                 name = name + ' - %s' % (d['variants'],)
 792             return (d['id'], name)
 793
 794         partner_id = context.get('partner_id', False)
 795
 796         # all user don't have access to seller and partner
 797         # check access and use superuser
 798         self.check_access_rights(cr, user, "read")
 799         self.check_access_rule(cr, user, ids, "read", context=context)
 800
 801         result = []
 802         for product in self.browse(cr, SUPERUSER_ID, ids, context=context):
 803             sellers = []
 804             if partner_id:
 805                 sellers = filter(lambda x: x.name.id == partner_id, product.seller_ids)
 806             if sellers:
 807                 for s in sellers:
 808                     mydict = {
 809                               'id': product.id,
 810                               'name': s.product_name or product.name,
 811                               'default_code': s.product_code or product.default_code,
 812                               'variants': product.variants
 813                               }
 814                     result.append(_name_get(mydict))
 815             else:
 816                 mydict = {
 817                           'id': product.id,
 818                           'name': product.name,
 819                           'default_code': product.default_code,
 820                           'variants': product.variants
 821                           }
 822                 result.append(_name_get(mydict))
 823         return result
 824
 825     def name_search(self, cr, user, name='', args=None, operator='ilike', context=None, limit=100):
 826         if not args:
 827             args = []
 828         if name:
 829             ids = self.search(cr, user, [('default_code','=',name)]+ args, limit=limit, context=context)
 830             if not ids:
 831                 ids = self.search(cr, user, [('ean13','=',name)]+ args, limit=limit, context=context)
 832             if not ids:
 833                 # Do not merge the 2 next lines into one single search, SQL search performance would be abysmal
 834                 # on a database with thousands of matching products, due to the huge merge+unique needed for the
 835                 # OR operator (and given the fact that the 'name' lookup results come from the ir.translation table
 836                 # Performing a quick memory merge of ids in Python will give much better performance
 837                 ids = set(self.search(cr, user, args + [('default_code', operator, name)], limit=limit, context=context))
 838                 if not limit or len(ids) < limit:
 839                     # we may underrun the limit because of dupes in the results, that's fine
 840                     limit2 = (limit - len(ids)) if limit else False
 841                     ids.update(self.search(cr, user, args + [('name', operator, name)], limit=limit2, context=context))
 842                 ids = list(ids)
 843             if not ids:
 844                 ptrn = re.compile('(\[(.*?)\])')
 845                 res = ptrn.search(name)
 846                 if res:
 847                     ids = self.search(cr, user, [('default_code','=', res.group(2))] + args, limit=limit, context=context)
 848         else:
 849             ids = self.search(cr, user, args, limit=limit, context=context)
 850         result = self.name_get(cr, user, ids, context=context)
 851         return result
 852
 853     #
 854     # Could be overrided for variants matrices prices
 855     #
 856     def price_get(self, cr, uid, ids, ptype='list_price', context=None):
 857         products = self.browse(cr, uid, ids, context=context)
 858         return self._price_get(cr, uid, products, ptype=ptype, context=context)
 859
 860     def _price_get(self, cr, uid, products, ptype='list_price', context=None):
 861         if context is None:
 862             context = {}
 863
 864         if 'currency_id' in context:
 865             pricetype_obj = self.pool.get('product.price.type')
 866             price_type_id = pricetype_obj.search(cr, uid, [('field','=',ptype)])[0]
 867             price_type_currency_id = pricetype_obj.browse(cr,uid,price_type_id).currency_id.id
 868
 869         res = {}
 870         # standard_price field can only be seen by users in base.group_user
 871         # Thus, in order to compute the sale price from the cost price for users not in this group
 872         # We fetch the standard price as the superuser
 873         for product in products:
 874             if ptype != 'standard_price':
 875                 res[product.id] = product[ptype] or 0.0
 876             else:
 877                 res[product.id] = self.read(cr, SUPERUSER_ID, product.id, [ptype], context=context)[ptype] or 0.0
 878
 879         product_uom_obj = self.pool.get('product.uom')
 880         for product in products:
 881             if ptype == 'list_price':
 882                 res[product.id] = (res[product.id] * (product.price_margin or 1.0)) + \
 883                         product.price_extra
 884             if 'uom' in context:
 885                 uom = product.uom_id or product.uos_id
 886                 res[product.id] = product_uom_obj._compute_price(cr, uid,
 887                         uom.id, res[product.id], context['uom'])
 888             # Convert from price_type currency to asked one
 889             if 'currency_id' in context:
 890                 # Take the price_type currency from the product field
 891                 # This is right cause a field cannot be in more than one currency
 892                 res[product.id] = self.pool.get('res.currency').compute(cr, uid, price_type_currency_id,
 893                     context['currency_id'], res[product.id],context=context)
 894
 895         return res
 896
 897     def copy(self, cr, uid, id, default=None, context=None):
 898         if context is None:
 899             context={}
 900
 901         product = self.browse(cr, uid, id, context)
 902         if context.get('variant'):
 903             # if we copy a variant or create one, we keep the same template
 904             default['product_tmpl_id'] = product.product_tmpl_id.id
 905         elif 'name' not in default:
 906             default['name'] = _("%s (copy)") % (product.name,)
 907
 908         return super(product_product, self).copy(cr, uid, id, default=default, context=context)
 909
 910     def search(self, cr, uid, args, offset=0, limit=None, order=None, context=None, count=False):
 911         if context is None:
 912             context = {}
 913         if context.get('search_default_categ_id'):
 914             args.append((('categ_id', 'child_of', context['search_default_categ_id'])))
 915         return super(product_product, self).search(cr, uid, args, offset=offset, limit=limit, order=order, context=context, count=count)
 916
 917     def open_product_template(self, cr, uid, ids, context=None):
 918         """ Utility method used to add an "Open Template" button in product views """
 919         product = self.browse(cr, uid, ids[0], context=context)
 920         return {'type': 'ir.actions.act_window',
 921                 'res_model': 'product.template',
 922                 'view_mode': 'form',
 923                 'res_id': product.product_tmpl_id.id,
 924                 'target': 'new'}
 925
 926
 927 class product_packaging(osv.osv):
 928     _name = "product.packaging"
 929     _description = "Packaging"
 930     _rec_name = 'ean'
 931     _order = 'sequence'
 932     _columns = {
 933         'sequence': fields.integer('Sequence', help="Gives the sequence order when displaying a list of packaging."),
 934         'name' : fields.text('Description'),
 935         'qty' : fields.float('Quantity by Package',
 936             help="The total number of products you can put by pallet or box."),
 937         'ul' : fields.many2one('product.ul', 'Package Logistic Unit', required=True),
 938         'ul_qty' : fields.integer('Package by layer', help='The number of packages by layer'),
 939         'ul_container': fields.many2one('product.ul', 'Pallet Logistic Unit'),
 940         'rows' : fields.integer('Number of Layers', required=True,
 941             help='The number of layers on a pallet or box'),
 942         'product_id' : fields.many2one('product.product', 'Product', select=1, ondelete='cascade', required=True),
 943         'ean' : fields.char('EAN', size=14, help="The EAN code of the package unit."),
 944         'code' : fields.char('Code', help="The code of the transport unit."),
 945         'weight': fields.float('Total Package Weight',
 946             help='The weight of a full package, pallet or box.'),
 947     }
 948
 949     def _check_ean_key(self, cr, uid, ids, context=None):
 950         for pack in self.browse(cr, uid, ids, context=context):
 951             res = check_ean(pack.ean)
 952         return res
 953
 954     _constraints = [(_check_ean_key, 'Error: Invalid ean code', ['ean'])]
 955
 956     def name_get(self, cr, uid, ids, context=None):
 957         if not len(ids):
 958             return []
 959         res = []
 960         for pckg in self.browse(cr, uid, ids, context=context):
 961             p_name = pckg.ean and '[' + pckg.ean + '] ' or ''
 962             p_name += pckg.ul.name
 963             res.append((pckg.id,p_name))
 964         return res
 965
 966     def _get_1st_ul(self, cr, uid, context=None):
 967         cr.execute('select id from product_ul order by id asc limit 1')
 968         res = cr.fetchone()
 969         return (res and res[0]) or False
 970
 971     _defaults = {
 972         'rows' : lambda *a : 3,
 973         'sequence' : lambda *a : 1,
 974         'ul' : _get_1st_ul,
 975     }
 976
 977     def checksum(ean):
 978         salt = '31' * 6 + '3'
 979         sum = 0
 980         for ean_part, salt_part in zip(ean, salt):
 981             sum += int(ean_part) * int(salt_part)
 982         return (10 - (sum % 10)) % 10
 983     checksum = staticmethod(checksum)
 984
 985
 986
 987 class product_supplierinfo(osv.osv):
 988     _name = "product.supplierinfo"
 989     _description = "Information about a product supplier"
 990     def _calc_qty(self, cr, uid, ids, fields, arg, context=None):
 991         result = {}
 992         for supplier_info in self.browse(cr, uid, ids, context=context):
 993             for field in fields:
 994                 result[supplier_info.id] = {field:False}
 995             qty = supplier_info.min_qty
 996             result[supplier_info.id]['qty'] = qty
 997         return result
 998
 999     _columns = {
1000         'name' : fields.many2one('res.partner', 'Supplier', required=True,domain = [('supplier','=',True)], ondelete='cascade', help="Supplier of this product"),
1001         '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."),
1002         '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."),
1003         'sequence' : fields.integer('Sequence', help="Assigns the priority to the list of product supplier."),
1004         '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."),
1005         '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."),
1006         '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."),
1007         'product_tmpl_id' : fields.many2one('product.template', 'Product Template', required=True, ondelete='cascade', select=True, oldname='product_id'),
1008         '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."),
1009         'pricelist_ids': fields.one2many('pricelist.partnerinfo', 'suppinfo_id', 'Supplier Pricelist'),
1010         'company_id':fields.many2one('res.company','Company',select=1),
1011     }
1012     _defaults = {
1013         'qty': lambda *a: 0.0,
1014         'sequence': lambda *a: 1,
1015         'delay': lambda *a: 1,
1016         'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'product.supplierinfo', context=c),
1017     }
1018     def price_get(self, cr, uid, supplier_ids, product_id, product_qty=1, context=None):
1019         """
1020         Calculate price from supplier pricelist.
1021         @param supplier_ids: Ids of res.partner object.
1022         @param product_id: Id of product.
1023         @param product_qty: specify quantity to purchase.
1024         """
1025         if type(supplier_ids) in (int,long,):
1026             supplier_ids = [supplier_ids]
1027         res = {}
1028         product_pool = self.pool.get('product.product')
1029         partner_pool = self.pool.get('res.partner')
1030         pricelist_pool = self.pool.get('product.pricelist')
1031         currency_pool = self.pool.get('res.currency')
1032         currency_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id.id
1033         # Compute price from standard price of product
1034         product_price = product_pool.price_get(cr, uid, [product_id], 'standard_price', context=context)[product_id]
1035         product = product_pool.browse(cr, uid, product_id, context=context)
1036         for supplier in partner_pool.browse(cr, uid, supplier_ids, context=context):
1037             price = product_price
1038             # Compute price from Purchase pricelist of supplier
1039             pricelist_id = supplier.property_product_pricelist_purchase.id
1040             if pricelist_id:
1041                 price = pricelist_pool.price_get(cr, uid, [pricelist_id], product_id, product_qty, context=context).setdefault(pricelist_id, 0)
1042                 price = currency_pool.compute(cr, uid, pricelist_pool.browse(cr, uid, pricelist_id).currency_id.id, currency_id, price)
1043
1044             # Compute price from supplier pricelist which are in Supplier Information
1045             supplier_info_ids = self.search(cr, uid, [('name','=',supplier.id),('product_tmpl_id','=',product.product_tmpl_id.id)])
1046             if supplier_info_ids:
1047                 cr.execute('SELECT * ' \
1048                     'FROM pricelist_partnerinfo ' \
1049                     'WHERE suppinfo_id IN %s' \
1050                     'AND min_quantity <= %s ' \
1051                     'ORDER BY min_quantity DESC LIMIT 1', (tuple(supplier_info_ids),product_qty,))
1052                 res2 = cr.dictfetchone()
1053                 if res2:
1054                     price = res2['price']
1055             res[supplier.id] = price
1056         return res
1057     _order = 'sequence'
1058
1059
1060 class pricelist_partnerinfo(osv.osv):
1061     _name = 'pricelist.partnerinfo'
1062     _columns = {
1063         'name': fields.char('Description'),
1064         'suppinfo_id': fields.many2one('product.supplierinfo', 'Partner Information', required=True, ondelete='cascade'),
1065         '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."),
1066         '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"),
1067     }
1068     _order = 'min_quantity asc'
1069
1070 class res_currency(osv.osv):
1071     _inherit = 'res.currency'
1072
1073     def _check_main_currency_rounding(self, cr, uid, ids, context=None):
1074         cr.execute('SELECT digits FROM decimal_precision WHERE name like %s',('Account',))
1075         digits = cr.fetchone()
1076         if digits and len(digits):
1077             digits = digits[0]
1078             main_currency = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id
1079             for currency_id in ids:
1080                 if currency_id == main_currency.id:
1081                     if main_currency.rounding < 10 ** -digits:
1082                         return False
1083         return True
1084
1085     _constraints = [
1086         (_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']),
1087     ]
1088
1089 class decimal_precision(osv.osv):
1090     _inherit = 'decimal.precision'
1091
1092     def _check_main_currency_rounding(self, cr, uid, ids, context=None):
1093         cr.execute('SELECT id, digits FROM decimal_precision WHERE name like %s',('Account',))
1094         res = cr.fetchone()
1095         if res and len(res):
1096             account_precision_id, digits = res
1097             main_currency = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id
1098             for decimal_precision in ids:
1099                 if decimal_precision == account_precision_id:
1100                     if main_currency.rounding < 10 ** -digits:
1101                         return False
1102         return True
1103
1104     _constraints = [
1105         (_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']),
1106     ]
1107
1108 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: