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