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