addons/product/product.py

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