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