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=0, # force NUMERIC with unlimited precision
 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=0, # force NUMERIC with unlimited precision
 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         if partner_id:
 649             partner_ids = [partner_id, self.pool['res.partner'].browse(cr, user, partner_id, context=context).commercial_partner_id.id]
 650         else:
 651             partner_ids = []
 652
 653         result = []
 654         for product in self.browse(cr, user, ids, context=context):
 655             sellers = partner_ids and filter(lambda x: x.name.id in partner_ids, product.seller_ids) or []
 656             if sellers:
 657                 for s in sellers:
 658                     mydict = {
 659                               'id': product.id,
 660                               'name': s.product_name or product.name,
 661                               'default_code': s.product_code or product.default_code,
 662                               'variants': product.variants
 663                               }
 664                     result.append(_name_get(mydict))
 665             else:
 666                 mydict = {
 667                           'id': product.id,
 668                           'name': product.name,
 669                           'default_code': product.default_code,
 670                           'variants': product.variants
 671                           }
 672                 result.append(_name_get(mydict))
 673         return result
 674
 675     def name_search(self, cr, user, name='', args=None, operator='ilike', context=None, limit=100):
 676         if not args:
 677             args = []
 678         if name:
 679             positive_operators = ['=', 'ilike', '=ilike', 'like', '=like']
 680             ids = []
 681             if operator in positive_operators:
 682                 ids = self.search(cr, user, [('default_code','=',name)]+ args, limit=limit, context=context)
 683                 if not ids:
 684                     ids = self.search(cr, user, [('ean13','=',name)]+ args, limit=limit, context=context)
 685             if not ids and operator not in expression.NEGATIVE_TERM_OPERATORS:
 686                 # Do not merge the 2 next lines into one single search, SQL search performance would be abysmal
 687                 # on a database with thousands of matching products, due to the huge merge+unique needed for the
 688                 # OR operator (and given the fact that the 'name' lookup results come from the ir.translation table
 689                 # Performing a quick memory merge of ids in Python will give much better performance
 690                 ids = set()
 691                 ids.update(self.search(cr, user, args + [('default_code',operator,name)], limit=limit, context=context))
 692                 if not limit or len(ids) < limit:
 693                     # we may underrun the limit because of dupes in the results, that's fine
 694                     ids.update(self.search(cr, user, args + [('name',operator,name)], limit=(limit and (limit-len(ids)) or False) , context=context))
 695                 ids = list(ids)
 696             elif not ids and operator in expression.NEGATIVE_TERM_OPERATORS:
 697                 ids = self.search(cr, user, args + ['&', ('default_code', operator, name), ('name', operator, name)], limit=limit, context=context)
 698             if not ids and operator in positive_operators:
 699                 ptrn = re.compile('(\[(.*?)\])')
 700                 res = ptrn.search(name)
 701                 if res:
 702                     ids = self.search(cr, user, [('default_code','=', res.group(2))] + args, limit=limit, context=context)
 703         else:
 704             ids = self.search(cr, user, args, limit=limit, context=context)
 705         result = self.name_get(cr, user, ids, context=context)
 706         return result
 707
 708     #
 709     # Could be overrided for variants matrices prices
 710     #
 711     def price_get(self, cr, uid, ids, ptype='list_price', context=None):
 712         if context is None:
 713             context = {}
 714
 715         if 'currency_id' in context:
 716             pricetype_obj = self.pool.get('product.price.type')
 717             price_type_id = pricetype_obj.search(cr, uid, [('field','=',ptype)])[0]
 718             price_type_currency_id = pricetype_obj.browse(cr,uid,price_type_id).currency_id.id
 719
 720         res = {}
 721         product_uom_obj = self.pool.get('product.uom')
 722         company_id = self.pool['res.users'].read(cr, uid, uid, ['company_id'], context=context)['company_id'][0]
 723         for product in self.browse(cr, SUPERUSER_ID, ids, context=dict(context, force_company=company_id)):
 724             res[product.id] = product[ptype] or 0.0
 725             if ptype == 'list_price':
 726                 res[product.id] = (res[product.id] * (product.price_margin or 1.0)) + \
 727                         product.price_extra
 728             if 'uom' in context:
 729                 uom = product.uom_id or product.uos_id
 730                 res[product.id] = product_uom_obj._compute_price(cr, uid,
 731                         uom.id, res[product.id], context['uom'])
 732             # Convert from price_type currency to asked one
 733             if 'currency_id' in context:
 734                 # Take the price_type currency from the product field
 735                 # This is right cause a field cannot be in more than one currency
 736                 res[product.id] = self.pool.get('res.currency').compute(cr, uid, price_type_currency_id,
 737                     context['currency_id'], res[product.id],context=context)
 738
 739         return res
 740
 741     def copy(self, cr, uid, id, default=None, context=None):
 742         if context is None:
 743             context={}
 744
 745         if not default:
 746             default = {}
 747
 748         product = self.read(cr, uid, id, ['name'], context=context)
 749         default = default.copy()
 750         default.update(name=_("%s (copy)") % (product['name']))
 751
 752         if context.get('variant',False):
 753             fields = ['product_tmpl_id', 'active', 'variants', 'default_code',
 754                     'price_margin', 'price_extra']
 755             data = self.read(cr, uid, id, fields=fields, context=context)
 756             for f in fields:
 757                 if f in default:
 758                     data[f] = default[f]
 759             data['product_tmpl_id'] = data.get('product_tmpl_id', False) \
 760                     and data['product_tmpl_id'][0]
 761             del data['id']
 762             return self.create(cr, uid, data)
 763         else:
 764             return super(product_product, self).copy(cr, uid, id, default=default,
 765                     context=context)
 766
 767     def search(self, cr, uid, args, offset=0, limit=None, order=None, context=None, count=False):
 768         if context is None:
 769             context = {}
 770         if context and context.get('search_default_categ_id', False):
 771             args.append((('categ_id', 'child_of', context['search_default_categ_id'])))
 772         return super(product_product, self).search(cr, uid, args, offset=offset, limit=limit, order=order, context=context, count=count)
 773
 774     def _compute_uos_qty(self, cr, uid, ids, uom, qty, uos, context=None):
 775         '''
 776         Computes product's invoicing quantity in UoS from quantity in UoM.
 777         Takes into account the
 778         :param uom: Source unit
 779         :param qty: Source quantity
 780         :param uos: Target UoS unit.
 781         '''
 782         if not uom or not qty or not uos:
 783             return qty
 784         uom_obj = self.pool['product.uom']
 785         product_id = ids[0] if isinstance(ids, (list, tuple)) else ids
 786         product = self.browse(cr, uid, product_id, context=context)
 787         if isinstance(uos, (int, long)):
 788             uos = uom_obj.browse(cr, uid, uos, context=context)
 789         if isinstance(uom, (int, long)):
 790             uom = uom_obj.browse(cr, uid, uom, context=context)
 791         if product.uos_id:  # Product has UoS defined
 792             # We cannot convert directly between units even if the units are of the same category
 793             # as we need to apply the conversion coefficient which is valid only between quantities
 794             # in product's default UoM/UoS
 795             qty_default_uom = uom_obj._compute_qty_obj(cr, uid, uom, qty, product.uom_id)  # qty in product's default UoM
 796             qty_default_uos = qty_default_uom * product.uos_coeff
 797             return uom_obj._compute_qty_obj(cr, uid, product.uos_id, qty_default_uos, uos)
 798         else:
 799             return uom_obj._compute_qty_obj(cr, uid, uom, qty, uos)
 800
 801
 802 product_product()
 803
 804 class product_packaging(osv.osv):
 805     _name = "product.packaging"
 806     _description = "Packaging"
 807     _rec_name = 'ean'
 808     _order = 'sequence'
 809     _columns = {
 810         'sequence': fields.integer('Sequence', help="Gives the sequence order when displaying a list of packaging."),
 811         'name' : fields.text('Description', size=64),
 812         'qty' : fields.float('Quantity by Package',
 813             help="The total number of products you can put by pallet or box."),
 814         'ul' : fields.many2one('product.ul', 'Type of Package', required=True),
 815         'ul_qty' : fields.integer('Package by layer', help='The number of packages by layer'),
 816         'rows' : fields.integer('Number of Layers', required=True,
 817             help='The number of layers on a pallet or box'),
 818         'product_id' : fields.many2one('product.product', 'Product', select=1, ondelete='cascade', required=True),
 819         'ean' : fields.char('EAN', size=14,
 820             help="The EAN code of the package unit."),
 821         'code' : fields.char('Code', size=14,
 822             help="The code of the transport unit."),
 823         'weight': fields.float('Total Package Weight',
 824             help='The weight of a full package, pallet or box.'),
 825         'weight_ul': fields.float('Empty Package Weight'),
 826         'height': fields.float('Height', help='The height of the package'),
 827         'width': fields.float('Width', help='The width of the package'),
 828         'length': fields.float('Length', help='The length of the package'),
 829     }
 830
 831
 832     def _check_ean_key(self, cr, uid, ids, context=None):
 833         for pack in self.browse(cr, uid, ids, context=context):
 834             res = check_ean(pack.ean)
 835         return res
 836
 837     _constraints = [(_check_ean_key, 'Error: Invalid ean code', ['ean'])]
 838
 839     def name_get(self, cr, uid, ids, context=None):
 840         if not len(ids):
 841             return []
 842         res = []
 843         for pckg in self.browse(cr, uid, ids, context=context):
 844             p_name = pckg.ean and '[' + pckg.ean + '] ' or ''
 845             p_name += pckg.ul.name
 846             res.append((pckg.id,p_name))
 847         return res
 848
 849     def _get_1st_ul(self, cr, uid, context=None):
 850         cr.execute('select id from product_ul order by id asc limit 1')
 851         res = cr.fetchone()
 852         return (res and res[0]) or False
 853
 854     _defaults = {
 855         'rows' : lambda *a : 3,
 856         'sequence' : lambda *a : 1,
 857         'ul' : _get_1st_ul,
 858     }
 859
 860     def checksum(ean):
 861         salt = '31' * 6 + '3'
 862         sum = 0
 863         for ean_part, salt_part in zip(ean, salt):
 864             sum += int(ean_part) * int(salt_part)
 865         return (10 - (sum % 10)) % 10
 866     checksum = staticmethod(checksum)
 867
 868 product_packaging()
 869
 870
 871 class product_supplierinfo(osv.osv):
 872     _name = "product.supplierinfo"
 873     _description = "Information about a product supplier"
 874     def _calc_qty(self, cr, uid, ids, fields, arg, context=None):
 875         result = {}
 876         product_uom_pool = self.pool.get('product.uom')
 877         for supplier_info in self.browse(cr, uid, ids, context=context):
 878             for field in fields:
 879                 result[supplier_info.id] = {field:False}
 880             qty = supplier_info.min_qty
 881             result[supplier_info.id]['qty'] = qty
 882         return result
 883
 884     _columns = {
 885         'name' : fields.many2one('res.partner', 'Supplier', required=True,domain = [('supplier','=',True)], ondelete='cascade', help="Supplier of this product"),
 886         '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."),
 887         '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."),
 888         'sequence' : fields.integer('Sequence', help="Assigns the priority to the list of product supplier."),
 889         '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."),
 890         '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."),
 891         '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."),
 892         'product_id' : fields.many2one('product.template', 'Product', required=True, ondelete='cascade', select=True),
 893         '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."),
 894         'pricelist_ids': fields.one2many('pricelist.partnerinfo', 'suppinfo_id', 'Supplier Pricelist'),
 895         'company_id':fields.many2one('res.company','Company',select=1),
 896     }
 897     _defaults = {
 898         'qty': lambda *a: 0.0,
 899         'sequence': lambda *a: 1,
 900         'delay': lambda *a: 1,
 901         'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'product.supplierinfo', context=c),
 902     }
 903     def price_get(self, cr, uid, supplier_ids, product_id, product_qty=1, context=None):
 904         """
 905         Calculate price from supplier pricelist.
 906         @param supplier_ids: Ids of res.partner object.
 907         @param product_id: Id of product.
 908         @param product_qty: specify quantity to purchase.
 909         """
 910         if type(supplier_ids) in (int,long,):
 911             supplier_ids = [supplier_ids]
 912         res = {}
 913         product_pool = self.pool.get('product.product')
 914         partner_pool = self.pool.get('res.partner')
 915         pricelist_pool = self.pool.get('product.pricelist')
 916         currency_pool = self.pool.get('res.currency')
 917         currency_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id.id
 918         for supplier in partner_pool.browse(cr, uid, supplier_ids, context=context):
 919             # Compute price from standard price of product
 920             price = product_pool.price_get(cr, uid, [product_id], 'standard_price', context=context)[product_id]
 921
 922             # Compute price from Purchase pricelist of supplier
 923             pricelist_id = supplier.property_product_pricelist_purchase.id
 924             if pricelist_id:
 925                 price = pricelist_pool.price_get(cr, uid, [pricelist_id], product_id, product_qty, context=context).setdefault(pricelist_id, 0)
 926                 price = currency_pool.compute(cr, uid, pricelist_pool.browse(cr, uid, pricelist_id).currency_id.id, currency_id, price)
 927
 928             # Compute price from supplier pricelist which are in Supplier Information
 929             supplier_info_ids = self.search(cr, uid, [('name','=',supplier.id),('product_id','=',product_id)])
 930             if supplier_info_ids:
 931                 cr.execute('SELECT * ' \
 932                     'FROM pricelist_partnerinfo ' \
 933                     'WHERE suppinfo_id IN %s' \
 934                     'AND min_quantity <= %s ' \
 935                     'ORDER BY min_quantity DESC LIMIT 1', (tuple(supplier_info_ids),product_qty,))
 936                 res2 = cr.dictfetchone()
 937                 if res2:
 938                     price = res2['price']
 939             res[supplier.id] = price
 940         return res
 941     _order = 'sequence'
 942 product_supplierinfo()
 943
 944
 945 class pricelist_partnerinfo(osv.osv):
 946     _name = 'pricelist.partnerinfo'
 947     _columns = {
 948         'name': fields.char('Description', size=64),
 949         'suppinfo_id': fields.many2one('product.supplierinfo', 'Partner Information', required=True, ondelete='cascade'),
 950         '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."),
 951         '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"),
 952     }
 953     _order = 'min_quantity asc'
 954 pricelist_partnerinfo()
 955
 956 class res_currency(osv.osv):
 957     _inherit = 'res.currency'
 958
 959     def _check_main_currency_rounding(self, cr, uid, ids, context=None):
 960         cr.execute('SELECT digits FROM decimal_precision WHERE name like %s',('Account',))
 961         digits = cr.fetchone()
 962         if digits and len(digits):
 963             digits = digits[0]
 964             main_currency = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id
 965             for currency_id in ids:
 966                 if currency_id == main_currency.id:
 967                     if main_currency.rounding < 10 ** -digits:
 968                         return False
 969         return True
 970
 971     _constraints = [
 972         (_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']),
 973     ]
 974
 975 class decimal_precision(osv.osv):
 976     _inherit = 'decimal.precision'
 977
 978     def _check_main_currency_rounding(self, cr, uid, ids, context=None):
 979         cr.execute('SELECT id, digits FROM decimal_precision WHERE name like %s',('Account',))
 980         res = cr.fetchone()
 981         if res and len(res):
 982             account_precision_id, digits = res
 983             main_currency = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id
 984             for decimal_precision in ids:
 985                 if decimal_precision == account_precision_id:
 986                     if main_currency.rounding < 10 ** -digits:
 987                         return False
 988         return True
 989
 990     _constraints = [
 991         (_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']),
 992     ]
 993
 994 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: