addons/product/product.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22 import math
  23 import re
  24
  25 from _common import ceiling
  26
  27 from openerp import tools, SUPERUSER_ID
  28 from openerp.osv import osv, fields, expression
  29 from openerp.tools.translate import _
  30
  31 import openerp.addons.decimal_precision as dp
  32 from openerp.tools.float_utils import float_round
  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', size=64, required=True, translate=True),
  87     }
  88 product_uom_categ()
  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', size=64, required=True, translate=True),
 133         'category_id': fields.many2one('product.uom.categ', 'Category', required=True, ondelete='cascade',
 134             help="Conversion between Units of Measure can only occur if they belong to the same category. The conversion will be made based on the ratios."),
 135         'factor': fields.float('Ratio', required=True,digits=(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='Ratio',
 141             help='How many times this Unit of Measure is bigger than the reference Unit of Measure in this category:\n'\
 142                     '1 * (this unit) = ratio * (reference unit)', required=True),
 143         'rounding': fields.float('Rounding Precision', digits_compute=dp.get_precision('Product Unit of Measure'), required=True,
 144             help="The computed quantity will be a multiple of this value. "\
 145                  "Use 1.0 for a Unit of Measure that cannot be further split, such as a piece."),
 146         'active': fields.boolean('Active', help="By unchecking the active field you can disable a unit of measure without deleting it."),
 147         'uom_type': fields.selection([('bigger','Bigger than the reference Unit of Measure'),
 148                                       ('reference','Reference Unit of Measure for this category'),
 149                                       ('smaller','Smaller than the reference Unit of Measure')],'Type', required=1),
 150     }
 151
 152     _defaults = {
 153         'active': 1,
 154         'rounding': 0.01,
 155         'uom_type': 'reference',
 156     }
 157
 158     _sql_constraints = [
 159         ('factor_gt_zero', 'CHECK (factor!=0)', 'The conversion ratio for a unit of measure cannot be 0!')
 160     ]
 161
 162     def _compute_qty(self, cr, uid, from_uom_id, qty, to_uom_id=False):
 163         if not from_uom_id or not qty or not to_uom_id:
 164             return qty
 165         uoms = self.browse(cr, uid, [from_uom_id, to_uom_id])
 166         if uoms[0].id == from_uom_id:
 167             from_unit, to_unit = uoms[0], uoms[-1]
 168         else:
 169             from_unit, to_unit = uoms[-1], uoms[0]
 170         return self._compute_qty_obj(cr, uid, from_unit, qty, to_unit)
 171
 172     def _compute_qty_obj(self, cr, uid, from_unit, qty, to_unit, context=None):
 173         if context is None:
 174             context = {}
 175         if from_unit.category_id.id <> to_unit.category_id.id:
 176             if context.get('raise-exception', True):
 177                 raise osv.except_osv(_('Error!'), _('Conversion from Product UoM %s to Default UoM %s is not possible as they both belong to different Category!.') % (from_unit.name,to_unit.name,))
 178             else:
 179                 return qty
 180         # First round to the precision of the original unit, so that
 181         # float representation errors do not bias the following ceil()
 182         # e.g. with 1 / (1/12) we could get 12.0000048, ceiling to 13!
 183         amount = float_round(qty/from_unit.factor, precision_rounding=from_unit.rounding)
 184         if to_unit:
 185             amount = ceiling(amount * to_unit.factor, to_unit.rounding)
 186         return amount
 187
 188     def _compute_price(self, cr, uid, from_uom_id, price, to_uom_id=False):
 189         if not from_uom_id or not price or not to_uom_id:
 190             return price
 191         uoms = self.browse(cr, uid, [from_uom_id, to_uom_id])
 192         if uoms[0].id == from_uom_id:
 193             from_unit, to_unit = uoms[0], uoms[-1]
 194         else:
 195             from_unit, to_unit = uoms[-1], uoms[0]
 196         if from_unit.category_id.id <> to_unit.category_id.id:
 197             return price
 198         amount = price * from_unit.factor
 199         if to_uom_id:
 200             amount = amount / to_unit.factor
 201         return amount
 202
 203     def onchange_type(self, cursor, user, ids, value):
 204         if value == 'reference':
 205             return {'value': {'factor': 1, 'factor_inv': 1}}
 206         return {}
 207
 208     def write(self, cr, uid, ids, vals, context=None):
 209         if 'category_id' in vals:
 210             for uom in self.browse(cr, uid, ids, context=context):
 211                 if uom.category_id.id != vals['category_id']:
 212                     raise osv.except_osv(_('Warning!'),_("Cannot change the category of existing Unit of Measure '%s'.") % (uom.name,))
 213         return super(product_uom, self).write(cr, uid, ids, vals, context=context)
 214
 215 product_uom()
 216
 217
 218 class product_ul(osv.osv):
 219     _name = "product.ul"
 220     _description = "Shipping Unit"
 221     _columns = {
 222         'name' : fields.char('Name', size=64,select=True, required=True, translate=True),
 223         'type' : fields.selection([('unit','Unit'),('pack','Pack'),('box', 'Box'), ('pallet', 'Pallet')], 'Type', required=True),
 224     }
 225 product_ul()
 226
 227
 228 #----------------------------------------------------------
 229 # Categories
 230 #----------------------------------------------------------
 231 class product_category(osv.osv):
 232
 233     def name_get(self, cr, uid, ids, context=None):
 234         if isinstance(ids, (list, tuple)) and not len(ids):
 235             return []
 236         if isinstance(ids, (long, int)):
 237             ids = [ids]
 238         reads = self.read(cr, uid, ids, ['name','parent_id'], context=context)
 239         res = []
 240         for record in reads:
 241             name = record['name']
 242             if record['parent_id']:
 243                 name = record['parent_id'][1]+' / '+name
 244             res.append((record['id'], name))
 245         return res
 246
 247     def _name_get_fnc(self, cr, uid, ids, prop, unknow_none, context=None):
 248         res = self.name_get(cr, uid, ids, context=context)
 249         return dict(res)
 250
 251     _name = "product.category"
 252     _description = "Product Category"
 253     _columns = {
 254         'name': fields.char('Name', size=64, required=True, translate=True, select=True),
 255         'complete_name': fields.function(_name_get_fnc, type="char", string='Name'),
 256         'parent_id': fields.many2one('product.category','Parent Category', select=True, ondelete='cascade'),
 257         'child_id': fields.one2many('product.category', 'parent_id', string='Child Categories'),
 258         'sequence': fields.integer('Sequence', select=True, help="Gives the sequence order when displaying a list of product categories."),
 259         '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."),
 260         'parent_left': fields.integer('Left Parent', select=1),
 261         'parent_right': fields.integer('Right Parent', select=1),
 262     }
 263
 264
 265     _defaults = {
 266         'type' : lambda *a : 'normal',
 267     }
 268
 269     _parent_name = "parent_id"
 270     _parent_store = True
 271     _parent_order = 'sequence, name'
 272     _order = 'parent_left'
 273
 274     def _check_recursion(self, cr, uid, ids, context=None):
 275         level = 100
 276         while len(ids):
 277             cr.execute('select distinct parent_id from product_category where id IN %s',(tuple(ids),))
 278             ids = filter(None, map(lambda x:x[0], cr.fetchall()))
 279             if not level:
 280                 return False
 281             level -= 1
 282         return True
 283
 284     _constraints = [
 285         (_check_recursion, 'Error ! You cannot create recursive categories.', ['parent_id'])
 286     ]
 287     def child_get(self, cr, uid, ids):
 288         return [ids]
 289
 290 product_category()
 291
 292
 293 #----------------------------------------------------------
 294 # Products
 295 #----------------------------------------------------------
 296 class product_template(osv.osv):
 297     _name = "product.template"
 298     _description = "Product Template"
 299
 300     _columns = {
 301         'name': fields.char('Name', size=128, required=True, translate=True, select=True),
 302         'product_manager': fields.many2one('res.users','Product Manager'),
 303         'description': fields.text('Description',translate=True),
 304         'description_purchase': fields.text('Purchase Description',translate=True),
 305         'description_sale': fields.text('Sale Description',translate=True),
 306         '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."),
 307         'produce_delay': fields.float('Manufacturing Lead Time', help="Average delay in days to produce this product. In the case of multi-level BOM, the manufacturing lead times of the components will be added."),
 308         'rental': fields.boolean('Can be Rent'),
 309         'categ_id': fields.many2one('product.category','Category', required=True, change_default=True, domain="[('type','=','normal')]" ,help="Select category for the current product"),
 310         '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."),
 311         'standard_price': fields.float('Cost', digits_compute=dp.get_precision('Product Price'), help="Cost price of the product used for standard stock valuation in accounting and used as a base price on purchase orders.", groups="base.group_user"),
 312         'volume': fields.float('Volume', help="The volume in m3."),
 313         'weight': fields.float('Gross Weight', digits_compute=dp.get_precision('Stock Weight'), help="The gross weight in Kg."),
 314         'weight_net': fields.float('Net Weight', digits_compute=dp.get_precision('Stock Weight'), help="The net weight in Kg."),
 315         'cost_method': fields.selection([('standard','Standard Price'), ('average','Average Price')], 'Costing Method', required=True,
 316             help="Standard Price: The cost price is manually updated at the end of a specific period (usually every year). \nAverage Price: The cost price is recomputed at each incoming shipment."),
 317         'warranty': fields.float('Warranty'),
 318         'sale_ok': fields.boolean('Can be Sold', help="Specify if the product can be selected in a sales order line."),
 319         'state': fields.selection([('',''),
 320             ('draft', 'In Development'),
 321             ('sellable','Normal'),
 322             ('end','End of Lifecycle'),
 323             ('obsolete','Obsolete')], 'Status'),
 324         'uom_id': fields.many2one('product.uom', 'Unit of Measure', required=True, help="Default Unit of Measure used for all stock operation."),
 325         '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."),
 326         'uos_id' : fields.many2one('product.uom', 'Unit of Sale',
 327             help='Sepcify 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.'),
 328         'uos_coeff': fields.float('Unit of Measure -> UOS Coeff', digits_compute= dp.get_precision('Product UoS'),
 329             help='Coefficient to convert default Unit of Measure to Unit of Sale\n'
 330             ' uos = uom * coeff'),
 331         'mes_type': fields.selection((('fixed', 'Fixed'), ('variable', 'Variable')), 'Measure Type'),
 332         'seller_ids': fields.one2many('product.supplierinfo', 'product_id', 'Supplier'),
 333         'company_id': fields.many2one('res.company', 'Company', select=1),
 334     }
 335
 336     def _get_uom_id(self, cr, uid, *args):
 337         cr.execute('select id from product_uom order by id limit 1')
 338         res = cr.fetchone()
 339         return res and res[0] or False
 340
 341     def _default_category(self, cr, uid, context=None):
 342         if context is None:
 343             context = {}
 344         if 'categ_id' in context and context['categ_id']:
 345             return context['categ_id']
 346         md = self.pool.get('ir.model.data')
 347         res = False
 348         try:
 349             res = md.get_object_reference(cr, uid, 'product', 'product_category_all')[1]
 350         except ValueError:
 351             res = False
 352         return res
 353
 354     def onchange_uom(self, cursor, user, ids, uom_id, uom_po_id):
 355         if uom_id:
 356             return {'value': {'uom_po_id': uom_id}}
 357         return {}
 358
 359     def write(self, cr, uid, ids, vals, context=None):
 360         if 'uom_po_id' in vals:
 361             new_uom = self.pool.get('product.uom').browse(cr, uid, vals['uom_po_id'], context=context)
 362             for product in self.browse(cr, uid, ids, context=context):
 363                 old_uom = product.uom_po_id
 364                 if old_uom.category_id.id != new_uom.category_id.id:
 365                     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,))
 366         return super(product_template, self).write(cr, uid, ids, vals, context=context)
 367
 368     _defaults = {
 369         'company_id': lambda s,cr,uid,c: s.pool.get('res.company')._company_default_get(cr, uid, 'product.template', context=c),
 370         'list_price': 1,
 371         'cost_method': 'standard',
 372         'standard_price': 0.0,
 373         'sale_ok': 1,
 374         'produce_delay': 1,
 375         'uom_id': _get_uom_id,
 376         'uom_po_id': _get_uom_id,
 377         'uos_coeff' : 1.0,
 378         'mes_type' : 'fixed',
 379         'categ_id' : _default_category,
 380         'type' : 'consu',
 381     }
 382
 383     def _check_uom(self, cursor, user, ids, context=None):
 384         for product in self.browse(cursor, user, ids, context=context):
 385             if product.uom_id.category_id.id <> product.uom_po_id.category_id.id:
 386                 return False
 387         return True
 388
 389     def _check_uos(self, cursor, user, ids, context=None):
 390         for product in self.browse(cursor, user, ids, context=context):
 391             if product.uos_id \
 392                     and product.uos_id.category_id.id \
 393                     == product.uom_id.category_id.id:
 394                 return False
 395         return True
 396
 397     _constraints = [
 398         (_check_uom, 'Error: The default Unit of Measure and the purchase Unit of Measure must be in the same category.', ['uom_id']),
 399     ]
 400
 401     def name_get(self, cr, user, ids, context=None):
 402         if context is None:
 403             context = {}
 404         if 'partner_id' in context:
 405             pass
 406         return super(product_template, self).name_get(cr, user, ids, context)
 407
 408 product_template()
 409
 410 class product_product(osv.osv):
 411     def view_header_get(self, cr, uid, view_id, view_type, context=None):
 412         if context is None:
 413             context = {}
 414         res = super(product_product, self).view_header_get(cr, uid, view_id, view_type, context)
 415         if (context.get('categ_id', False)):
 416             return _('Products: ')+self.pool.get('product.category').browse(cr, uid, context['categ_id'], context=context).name
 417         return res
 418
 419     def _product_price(self, cr, uid, ids, name, arg, context=None):
 420         res = {}
 421         if context is None:
 422             context = {}
 423         quantity = context.get('quantity') or 1.0
 424         pricelist = context.get('pricelist', False)
 425         partner = context.get('partner', False)
 426         if pricelist:
 427             # Support context pricelists specified as display_name or ID for compatibility
 428             if isinstance(pricelist, basestring):
 429                 pricelist_ids = self.pool.get('product.pricelist').name_search(
 430                     cr, uid, pricelist, operator='=', context=context, limit=1)
 431                 pricelist = pricelist_ids[0][0] if pricelist_ids else pricelist
 432             for id in ids:
 433                 try:
 434                     price = self.pool.get('product.pricelist').price_get(cr,uid,[pricelist], id, quantity, partner=partner, context=context)[pricelist]
 435                 except:
 436                     price = 0.0
 437                 res[id] = price
 438         for id in ids:
 439             res.setdefault(id, 0.0)
 440         return res
 441
 442     def _get_product_available_func(states, what):
 443         def _product_available(self, cr, uid, ids, name, arg, context=None):
 444             return {}.fromkeys(ids, 0.0)
 445         return _product_available
 446
 447     _product_qty_available = _get_product_available_func(('done',), ('in', 'out'))
 448     _product_virtual_available = _get_product_available_func(('confirmed','waiting','assigned','done'), ('in', 'out'))
 449     _product_outgoing_qty = _get_product_available_func(('confirmed','waiting','assigned'), ('out',))
 450     _product_incoming_qty = _get_product_available_func(('confirmed','waiting','assigned'), ('in',))
 451
 452     def _product_lst_price(self, cr, uid, ids, name, arg, context=None):
 453         res = {}
 454         product_uom_obj = self.pool.get('product.uom')
 455         for id in ids:
 456             res.setdefault(id, 0.0)
 457         for product in self.browse(cr, uid, ids, context=context):
 458             if 'uom' in context:
 459                 uom = product.uos_id or product.uom_id
 460                 res[product.id] = product_uom_obj._compute_price(cr, uid,
 461                         uom.id, product.list_price, context['uom'])
 462             else:
 463                 res[product.id] = product.list_price
 464             res[product.id] =  (res[product.id] or 0.0) * (product.price_margin or 1.0) + product.price_extra
 465         return res
 466
 467     def _get_partner_code_name(self, cr, uid, ids, product, partner_id, context=None):
 468         for supinfo in product.seller_ids:
 469             if supinfo.name.id == partner_id:
 470                 return {'code': supinfo.product_code or product.default_code, 'name': supinfo.product_name or product.name, 'variants': ''}
 471         res = {'code': product.default_code, 'name': product.name, 'variants': product.variants}
 472         return res
 473
 474     def _product_code(self, cr, uid, ids, name, arg, context=None):
 475         res = {}
 476         if context is None:
 477             context = {}
 478         for p in self.browse(cr, uid, ids, context=context):
 479             res[p.id] = self._get_partner_code_name(cr, uid, [], p, context.get('partner_id', None), context=context)['code']
 480         return res
 481
 482     def _product_partner_ref(self, cr, uid, ids, name, arg, context=None):
 483         res = {}
 484         if context is None:
 485             context = {}
 486         for p in self.browse(cr, uid, ids, context=context):
 487             data = self._get_partner_code_name(cr, uid, [], p, context.get('partner_id', None), context=context)
 488             if not data['variants']:
 489                 data['variants'] = p.variants
 490             if not data['code']:
 491                 data['code'] = p.code
 492             if not data['name']:
 493                 data['name'] = p.name
 494             res[p.id] = (data['code'] and ('['+data['code']+'] ') or '') + \
 495                     (data['name'] or '') + (data['variants'] and (' - '+data['variants']) or '')
 496         return res
 497
 498
 499     def _get_main_product_supplier(self, cr, uid, product, context=None):
 500         """Determines the main (best) product supplier for ``product``,
 501         returning the corresponding ``supplierinfo`` record, or False
 502         if none were found. The default strategy is to select the
 503         supplier with the highest priority (i.e. smallest sequence).
 504
 505         :param browse_record product: product to supply
 506         :rtype: product.supplierinfo browse_record or False
 507         """
 508         sellers = [(seller_info.sequence, seller_info)
 509                        for seller_info in product.seller_ids or []
 510                        if seller_info and isinstance(seller_info.sequence, (int, long))]
 511         return sellers and sellers[0][1] or False
 512
 513     def _calc_seller(self, cr, uid, ids, fields, arg, context=None):
 514         result = {}
 515         for product in self.browse(cr, uid, ids, context=context):
 516             main_supplier = self._get_main_product_supplier(cr, uid, product, context=context)
 517             result[product.id] = {
 518                 'seller_info_id': main_supplier and main_supplier.id or False,
 519                 'seller_delay': main_supplier.delay if main_supplier else 1,
 520                 'seller_qty': main_supplier and main_supplier.qty or 0.0,
 521                 'seller_id': main_supplier and main_supplier.name.id or False
 522             }
 523         return result
 524
 525
 526     def _get_image(self, cr, uid, ids, name, args, context=None):
 527         result = dict.fromkeys(ids, False)
 528         for obj in self.browse(cr, uid, ids, context=context):
 529             result[obj.id] = tools.image_get_resized_images(obj.image, avoid_resize_medium=True)
 530         return result
 531
 532     def _set_image(self, cr, uid, id, name, value, args, context=None):
 533         return self.write(cr, uid, [id], {'image': tools.image_resize_image_big(value)}, context=context)
 534
 535     _defaults = {
 536         'active': lambda *a: 1,
 537         'price_extra': lambda *a: 0.0,
 538         'price_margin': lambda *a: 1.0,
 539         'color': 0,
 540     }
 541
 542     _name = "product.product"
 543     _description = "Product"
 544     _table = "product_product"
 545     _inherits = {'product.template': 'product_tmpl_id'}
 546     _inherit = ['mail.thread']
 547     _order = 'default_code,name_template'
 548     _columns = {
 549         'qty_available': fields.function(_product_qty_available, type='float', string='Quantity On Hand'),
 550         'virtual_available': fields.function(_product_virtual_available, type='float', string='Quantity Available'),
 551         'incoming_qty': fields.function(_product_incoming_qty, type='float', string='Incoming'),
 552         'outgoing_qty': fields.function(_product_outgoing_qty, type='float', string='Outgoing'),
 553         'price': fields.function(_product_price, type='float', string='Price', digits_compute=dp.get_precision('Product Price')),
 554         'lst_price' : fields.function(_product_lst_price, type='float', string='Public Price', digits_compute=dp.get_precision('Product Price')),
 555         'code': fields.function(_product_code, type='char', string='Internal Reference'),
 556         'partner_ref' : fields.function(_product_partner_ref, type='char', string='Customer ref'),
 557         'default_code' : fields.char('Internal Reference', size=64, select=True),
 558         'active': fields.boolean('Active', help="If unchecked, it will allow you to hide the product without removing it."),
 559         'variants': fields.char('Variants', size=64),
 560         'product_tmpl_id': fields.many2one('product.template', 'Product Template', required=True, ondelete="cascade", select=True),
 561         'ean13': fields.char('EAN13 Barcode', size=13, help="International Article Number used for product identification."),
 562         '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."),
 563         'price_extra': fields.float('Variant Price Extra', digits_compute=dp.get_precision('Product Price')),
 564         'price_margin': fields.float('Variant Price Margin', digits_compute=dp.get_precision('Product Price')),
 565         'pricelist_id': fields.dummy(string='Pricelist', relation='product.pricelist', type='many2one'),
 566         'name_template': fields.related('product_tmpl_id', 'name', string="Template Name", type='char', size=128, store=True, select=True),
 567         'color': fields.integer('Color Index'),
 568         # image: all image fields are base64 encoded and PIL-supported
 569         'image': fields.binary("Image",
 570             help="This field holds the image used as image for the product, limited to 1024x1024px."),
 571         'image_medium': fields.function(_get_image, fnct_inv=_set_image,
 572             string="Medium-sized image", type="binary", multi="_get_image",
 573             store={
 574                 'product.product': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 575             },
 576             help="Medium-sized image of the product. It is automatically "\
 577                  "resized as a 128x128px image, with aspect ratio preserved, "\
 578                  "only when the image exceeds one of those sizes. Use this field in form views or some kanban views."),
 579         'image_small': fields.function(_get_image, fnct_inv=_set_image,
 580             string="Small-sized image", type="binary", multi="_get_image",
 581             store={
 582                 'product.product': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 583             },
 584             help="Small-sized image of the product. It is automatically "\
 585                  "resized as a 64x64px image, with aspect ratio preserved. "\
 586                  "Use this field anywhere a small image is required."),
 587         'seller_info_id': fields.function(_calc_seller, type='many2one', relation="product.supplierinfo", string="Supplier Info", multi="seller_info"),
 588         '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."),
 589         'seller_qty': fields.function(_calc_seller, type='float', string='Supplier Quantity', multi="seller_info", help="This is minimum quantity to purchase from Main Supplier."),
 590         '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"),
 591     }
 592     def unlink(self, cr, uid, ids, context=None):
 593         unlink_ids = []
 594         unlink_product_tmpl_ids = []
 595         for product in self.browse(cr, uid, ids, context=context):
 596             # Check if product still exists, in case it has been unlinked by unlinking its template
 597             if not product.exists():
 598                 continue
 599             tmpl_id = product.product_tmpl_id.id
 600             # Check if the product is last product of this template
 601             other_product_ids = self.search(cr, uid, [('product_tmpl_id', '=', tmpl_id), ('id', '!=', product.id)], context=context)
 602             if not other_product_ids:
 603                 unlink_product_tmpl_ids.append(tmpl_id)
 604             unlink_ids.append(product.id)
 605         res = super(product_product, self).unlink(cr, uid, unlink_ids, context=context)
 606         # delete templates after calling super, as deleting template could lead to deleting
 607         # products due to ondelete='cascade'
 608         self.pool.get('product.template').unlink(cr, uid, unlink_product_tmpl_ids, context=context)
 609         return res
 610
 611     def onchange_uom(self, cursor, user, ids, uom_id, uom_po_id):
 612         if uom_id and uom_po_id:
 613             uom_obj=self.pool.get('product.uom')
 614             uom=uom_obj.browse(cursor,user,[uom_id])[0]
 615             uom_po=uom_obj.browse(cursor,user,[uom_po_id])[0]
 616             if uom.category_id.id != uom_po.category_id.id:
 617                 return {'value': {'uom_po_id': uom_id}}
 618         return False
 619
 620     def _check_ean_key(self, cr, uid, ids, context=None):
 621         for product in self.read(cr, uid, ids, ['ean13'], context=context):
 622             res = check_ean(product['ean13'])
 623         return res
 624
 625
 626     _constraints = [(_check_ean_key, 'You provided an invalid "EAN13 Barcode" reference. You may use the "Internal Reference" field instead.', ['ean13'])]
 627
 628     def on_order(self, cr, uid, ids, orderline, quantity):
 629         pass
 630
 631     def name_get(self, cr, user, ids, context=None):
 632         if context is None:
 633             context = {}
 634         if isinstance(ids, (int, long)):
 635             ids = [ids]
 636         if not len(ids):
 637             return []
 638         def _name_get(d):
 639             name = d.get('name','')
 640             code = d.get('default_code',False)
 641             if code:
 642                 name = '[%s] %s' % (code,name)
 643             if d.get('variants'):
 644                 name = name + ' - %s' % (d['variants'],)
 645             return (d['id'], name)
 646
 647         partner_id = context.get('partner_id', False)
 648
 649         result = []
 650         for product in self.browse(cr, user, ids, context=context):
 651             sellers = filter(lambda x: x.name.id == partner_id, product.seller_ids)
 652             if sellers:
 653                 for s in sellers:
 654                     mydict = {
 655                               'id': product.id,
 656                               'name': s.product_name or product.name,
 657                               'default_code': s.product_code or product.default_code,
 658                               'variants': product.variants
 659                               }
 660                     result.append(_name_get(mydict))
 661             else:
 662                 mydict = {
 663                           'id': product.id,
 664                           'name': product.name,
 665                           'default_code': product.default_code,
 666                           'variants': product.variants
 667                           }
 668                 result.append(_name_get(mydict))
 669         return result
 670
 671     def name_search(self, cr, user, name='', args=None, operator='ilike', context=None, limit=100):
 672         if not args:
 673             args = []
 674         if name:
 675             positive_operators = ['=', 'ilike', '=ilike', 'like', '=like']
 676             ids = []
 677             if operator in positive_operators:
 678                 ids = self.search(cr, user, [('default_code','=',name)]+ args, limit=limit, context=context)
 679                 if not ids:
 680                     ids = self.search(cr, user, [('ean13','=',name)]+ args, limit=limit, context=context)
 681             if not ids and operator not in expression.NEGATIVE_TERM_OPERATORS:
 682                 # Do not merge the 2 next lines into one single search, SQL search performance would be abysmal
 683                 # on a database with thousands of matching products, due to the huge merge+unique needed for the
 684                 # OR operator (and given the fact that the 'name' lookup results come from the ir.translation table
 685                 # Performing a quick memory merge of ids in Python will give much better performance
 686                 ids = set()
 687                 ids.update(self.search(cr, user, args + [('default_code',operator,name)], limit=limit, context=context))
 688                 if not limit or len(ids) < limit:
 689                     # we may underrun the limit because of dupes in the results, that's fine
 690                     ids.update(self.search(cr, user, args + [('name',operator,name)], limit=(limit and (limit-len(ids)) or False) , context=context))
 691                 ids = list(ids)
 692             elif not ids and operator in expression.NEGATIVE_TERM_OPERATORS:
 693                 ids = self.search(cr, user, args + ['&', ('default_code', operator, name), ('name', operator, name)], limit=limit, context=context)
 694             if not ids and operator in positive_operators:
 695                 ptrn = re.compile('(\[(.*?)\])')
 696                 res = ptrn.search(name)
 697                 if res:
 698                     ids = self.search(cr, user, [('default_code','=', res.group(2))] + args, limit=limit, context=context)
 699         else:
 700             ids = self.search(cr, user, args, limit=limit, context=context)
 701         result = self.name_get(cr, user, ids, context=context)
 702         return result
 703
 704     #
 705     # Could be overrided for variants matrices prices
 706     #
 707     def price_get(self, cr, uid, ids, ptype='list_price', context=None):
 708         if context is None:
 709             context = {}
 710
 711         if 'currency_id' in context:
 712             pricetype_obj = self.pool.get('product.price.type')
 713             price_type_id = pricetype_obj.search(cr, uid, [('field','=',ptype)])[0]
 714             price_type_currency_id = pricetype_obj.browse(cr,uid,price_type_id).currency_id.id
 715
 716         res = {}
 717         product_uom_obj = self.pool.get('product.uom')
 718         for product in self.browse(cr, SUPERUSER_ID, ids, context=context):
 719             res[product.id] = product[ptype] or 0.0
 720             if ptype == 'list_price':
 721                 res[product.id] = (res[product.id] * (product.price_margin or 1.0)) + \
 722                         product.price_extra
 723             if 'uom' in context:
 724                 uom = product.uom_id or product.uos_id
 725                 res[product.id] = product_uom_obj._compute_price(cr, uid,
 726                         uom.id, res[product.id], context['uom'])
 727             # Convert from price_type currency to asked one
 728             if 'currency_id' in context:
 729                 # Take the price_type currency from the product field
 730                 # This is right cause a field cannot be in more than one currency
 731                 res[product.id] = self.pool.get('res.currency').compute(cr, uid, price_type_currency_id,
 732                     context['currency_id'], res[product.id],context=context)
 733
 734         return res
 735
 736     def copy(self, cr, uid, id, default=None, context=None):
 737         if context is None:
 738             context={}
 739
 740         if not default:
 741             default = {}
 742
 743         product = self.read(cr, uid, id, ['name'], context=context)
 744         default = default.copy()
 745         default.update(name=_("%s (copy)") % (product['name']))
 746
 747         if context.get('variant',False):
 748             fields = ['product_tmpl_id', 'active', 'variants', 'default_code',
 749                     'price_margin', 'price_extra']
 750             data = self.read(cr, uid, id, fields=fields, context=context)
 751             for f in fields:
 752                 if f in default:
 753                     data[f] = default[f]
 754             data['product_tmpl_id'] = data.get('product_tmpl_id', False) \
 755                     and data['product_tmpl_id'][0]
 756             del data['id']
 757             return self.create(cr, uid, data)
 758         else:
 759             return super(product_product, self).copy(cr, uid, id, default=default,
 760                     context=context)
 761
 762     def search(self, cr, uid, args, offset=0, limit=None, order=None, context=None, count=False):
 763         if context is None:
 764             context = {}
 765         if context and context.get('search_default_categ_id', False):
 766             args.append((('categ_id', 'child_of', context['search_default_categ_id'])))
 767         return super(product_product, self).search(cr, uid, args, offset=offset, limit=limit, order=order, context=context, count=count)
 768
 769 product_product()
 770
 771 class product_packaging(osv.osv):
 772     _name = "product.packaging"
 773     _description = "Packaging"
 774     _rec_name = 'ean'
 775     _order = 'sequence'
 776     _columns = {
 777         'sequence': fields.integer('Sequence', help="Gives the sequence order when displaying a list of packaging."),
 778         'name' : fields.text('Description', size=64),
 779         'qty' : fields.float('Quantity by Package',
 780             help="The total number of products you can put by pallet or box."),
 781         'ul' : fields.many2one('product.ul', 'Type of Package', required=True),
 782         'ul_qty' : fields.integer('Package by layer', help='The number of packages by layer'),
 783         'rows' : fields.integer('Number of Layers', required=True,
 784             help='The number of layers on a pallet or box'),
 785         'product_id' : fields.many2one('product.product', 'Product', select=1, ondelete='cascade', required=True),
 786         'ean' : fields.char('EAN', size=14,
 787             help="The EAN code of the package unit."),
 788         'code' : fields.char('Code', size=14,
 789             help="The code of the transport unit."),
 790         'weight': fields.float('Total Package Weight',
 791             help='The weight of a full package, pallet or box.'),
 792         'weight_ul': fields.float('Empty Package Weight'),
 793         'height': fields.float('Height', help='The height of the package'),
 794         'width': fields.float('Width', help='The width of the package'),
 795         'length': fields.float('Length', help='The length of the package'),
 796     }
 797
 798
 799     def _check_ean_key(self, cr, uid, ids, context=None):
 800         for pack in self.browse(cr, uid, ids, context=context):
 801             res = check_ean(pack.ean)
 802         return res
 803
 804     _constraints = [(_check_ean_key, 'Error: Invalid ean code', ['ean'])]
 805
 806     def name_get(self, cr, uid, ids, context=None):
 807         if not len(ids):
 808             return []
 809         res = []
 810         for pckg in self.browse(cr, uid, ids, context=context):
 811             p_name = pckg.ean and '[' + pckg.ean + '] ' or ''
 812             p_name += pckg.ul.name
 813             res.append((pckg.id,p_name))
 814         return res
 815
 816     def _get_1st_ul(self, cr, uid, context=None):
 817         cr.execute('select id from product_ul order by id asc limit 1')
 818         res = cr.fetchone()
 819         return (res and res[0]) or False
 820
 821     _defaults = {
 822         'rows' : lambda *a : 3,
 823         'sequence' : lambda *a : 1,
 824         'ul' : _get_1st_ul,
 825     }
 826
 827     def checksum(ean):
 828         salt = '31' * 6 + '3'
 829         sum = 0
 830         for ean_part, salt_part in zip(ean, salt):
 831             sum += int(ean_part) * int(salt_part)
 832         return (10 - (sum % 10)) % 10
 833     checksum = staticmethod(checksum)
 834
 835 product_packaging()
 836
 837
 838 class product_supplierinfo(osv.osv):
 839     _name = "product.supplierinfo"
 840     _description = "Information about a product supplier"
 841     def _calc_qty(self, cr, uid, ids, fields, arg, context=None):
 842         result = {}
 843         product_uom_pool = self.pool.get('product.uom')
 844         for supplier_info in self.browse(cr, uid, ids, context=context):
 845             for field in fields:
 846                 result[supplier_info.id] = {field:False}
 847             qty = supplier_info.min_qty
 848             result[supplier_info.id]['qty'] = qty
 849         return result
 850
 851     _columns = {
 852         'name' : fields.many2one('res.partner', 'Supplier', required=True,domain = [('supplier','=',True)], ondelete='cascade', help="Supplier of this product"),
 853         'product_name': fields.char('Supplier Product Name', size=128, help="This supplier's product name will be used when printing a request for quotation. Keep empty to use the internal one."),
 854         'product_code': fields.char('Supplier Product Code', size=64, help="This supplier's product code will be used when printing a request for quotation. Keep empty to use the internal one."),
 855         'sequence' : fields.integer('Sequence', help="Assigns the priority to the list of product supplier."),
 856         'product_uom': fields.related('product_id', 'uom_po_id', type='many2one', relation='product.uom', string="Supplier Unit of Measure", readonly="1", help="This comes from the product form."),
 857         '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."),
 858         '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."),
 859         'product_id' : fields.many2one('product.template', 'Product', required=True, ondelete='cascade', select=True),
 860         '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."),
 861         'pricelist_ids': fields.one2many('pricelist.partnerinfo', 'suppinfo_id', 'Supplier Pricelist'),
 862         'company_id':fields.many2one('res.company','Company',select=1),
 863     }
 864     _defaults = {
 865         'qty': lambda *a: 0.0,
 866         'sequence': lambda *a: 1,
 867         'delay': lambda *a: 1,
 868         'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'product.supplierinfo', context=c),
 869     }
 870     def price_get(self, cr, uid, supplier_ids, product_id, product_qty=1, context=None):
 871         """
 872         Calculate price from supplier pricelist.
 873         @param supplier_ids: Ids of res.partner object.
 874         @param product_id: Id of product.
 875         @param product_qty: specify quantity to purchase.
 876         """
 877         if type(supplier_ids) in (int,long,):
 878             supplier_ids = [supplier_ids]
 879         res = {}
 880         product_pool = self.pool.get('product.product')
 881         partner_pool = self.pool.get('res.partner')
 882         pricelist_pool = self.pool.get('product.pricelist')
 883         currency_pool = self.pool.get('res.currency')
 884         currency_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id.id
 885         for supplier in partner_pool.browse(cr, uid, supplier_ids, context=context):
 886             # Compute price from standard price of product
 887             price = product_pool.price_get(cr, uid, [product_id], 'standard_price', context=context)[product_id]
 888
 889             # Compute price from Purchase pricelist of supplier
 890             pricelist_id = supplier.property_product_pricelist_purchase.id
 891             if pricelist_id:
 892                 price = pricelist_pool.price_get(cr, uid, [pricelist_id], product_id, product_qty, context=context).setdefault(pricelist_id, 0)
 893                 price = currency_pool.compute(cr, uid, pricelist_pool.browse(cr, uid, pricelist_id).currency_id.id, currency_id, price)
 894
 895             # Compute price from supplier pricelist which are in Supplier Information
 896             supplier_info_ids = self.search(cr, uid, [('name','=',supplier.id),('product_id','=',product_id)])
 897             if supplier_info_ids:
 898                 cr.execute('SELECT * ' \
 899                     'FROM pricelist_partnerinfo ' \
 900                     'WHERE suppinfo_id IN %s' \
 901                     'AND min_quantity <= %s ' \
 902                     'ORDER BY min_quantity DESC LIMIT 1', (tuple(supplier_info_ids),product_qty,))
 903                 res2 = cr.dictfetchone()
 904                 if res2:
 905                     price = res2['price']
 906             res[supplier.id] = price
 907         return res
 908     _order = 'sequence'
 909 product_supplierinfo()
 910
 911
 912 class pricelist_partnerinfo(osv.osv):
 913     _name = 'pricelist.partnerinfo'
 914     _columns = {
 915         'name': fields.char('Description', size=64),
 916         'suppinfo_id': fields.many2one('product.supplierinfo', 'Partner Information', required=True, ondelete='cascade'),
 917         '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."),
 918         '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"),
 919     }
 920     _order = 'min_quantity asc'
 921 pricelist_partnerinfo()
 922
 923 class res_currency(osv.osv):
 924     _inherit = 'res.currency'
 925
 926     def _check_main_currency_rounding(self, cr, uid, ids, context=None):
 927         cr.execute('SELECT digits FROM decimal_precision WHERE name like %s',('Account',))
 928         digits = cr.fetchone()
 929         if digits and len(digits):
 930             digits = digits[0]
 931             main_currency = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id
 932             for currency_id in ids:
 933                 if currency_id == main_currency.id:
 934                     if main_currency.rounding < 10 ** -digits:
 935                         return False
 936         return True
 937
 938     _constraints = [
 939         (_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']),
 940     ]
 941
 942 class decimal_precision(osv.osv):
 943     _inherit = 'decimal.precision'
 944
 945     def _check_main_currency_rounding(self, cr, uid, ids, context=None):
 946         cr.execute('SELECT id, digits FROM decimal_precision WHERE name like %s',('Account',))
 947         res = cr.fetchone()
 948         if res and len(res):
 949             account_precision_id, digits = res
 950             main_currency = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id
 951             for decimal_precision in ids:
 952                 if decimal_precision == account_precision_id:
 953                     if main_currency.rounding < 10 ** -digits:
 954                         return False
 955         return True
 956
 957     _constraints = [
 958         (_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']),
 959     ]
 960
 961 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: