addons/stock/stock.py

   1 ##############################################################################
   2 #
   3 #    OpenERP, Open Source Management Solution
   4 #    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
   5 #
   6 #    This program is free software: you can redistribute it and/or modify
   7 #    it under the terms of the GNU Affero General Public License as
   8 #    published by the Free Software Foundation, either version 3 of the
   9 #    License, or (at your option) any later version.
  10 #
  11 #    This program is distributed in the hope that it will be useful,
  12 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 #    GNU Affero General Public License for more details.
  15 #
  16 #    You should have received a copy of the GNU Affero General Public License
  17 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 #
  19 ##############################################################################
  20
  21 from datetime import datetime
  22 from dateutil.relativedelta import relativedelta
  23 import time
  24 from operator import itemgetter
  25 from itertools import groupby
  26
  27 from osv import fields, osv
  28 from tools.translate import _
  29 import netsvc
  30 import tools
  31 from tools import float_compare
  32 import decimal_precision as dp
  33 import logging
  34
  35
  36 #----------------------------------------------------------
  37 # Incoterms
  38 #----------------------------------------------------------
  39 class stock_incoterms(osv.osv):
  40     _name = "stock.incoterms"
  41     _description = "Incoterms"
  42     _columns = {
  43         'name': fields.char('Name', size=64, required=True, help="Incoterms are series of sales terms.They are used to divide transaction costs and responsibilities between buyer and seller and reflect state-of-the-art transportation practices."),
  44         'code': fields.char('Code', size=3, required=True, help="Code for Incoterms"),
  45         'active': fields.boolean('Active', help="By unchecking the active field, you may hide an INCOTERM without deleting it."),
  46     }
  47     _defaults = {
  48         'active': True,
  49     }
  50
  51 stock_incoterms()
  52
  53 class stock_journal(osv.osv):
  54     _name = "stock.journal"
  55     _description = "Stock Journal"
  56     _columns = {
  57         'name': fields.char('Stock Journal', size=32, required=True),
  58         'user_id': fields.many2one('res.users', 'Responsible'),
  59     }
  60     _defaults = {
  61         'user_id': lambda s, c, u, ctx: u
  62     }
  63
  64 stock_journal()
  65
  66 #----------------------------------------------------------
  67 # Stock Location
  68 #----------------------------------------------------------
  69 class stock_location(osv.osv):
  70     _name = "stock.location"
  71     _description = "Location"
  72     _parent_name = "location_id"
  73     _parent_store = True
  74     _parent_order = 'posz,name'
  75     _order = 'parent_left'
  76
  77     def name_get(self, cr, uid, ids, context=None):
  78         res = []
  79         if context is None:
  80             context = {}
  81         if not len(ids):
  82             return []
  83         reads = self.read(cr, uid, ids, ['name','location_id'], context=context)
  84         for record in reads:
  85             name = record['name']
  86             if context.get('full',False):
  87                 if record['location_id']:
  88                     name = record['location_id'][1] + ' / ' + name
  89                 res.append((record['id'], name))
  90             else:
  91                 res.append((record['id'], name))
  92         return res
  93
  94     def _complete_name(self, cr, uid, ids, name, args, context=None):
  95         """ Forms complete name of location from parent location to child location.
  96         @return: Dictionary of values
  97         """
  98         def _get_one_full_name(location, level=4):
  99             if location.location_id:
 100                 parent_path = _get_one_full_name(location.location_id, level-1) + "/"
 101             else:
 102                 parent_path = ''
 103             return parent_path + location.name
 104         res = {}
 105         for m in self.browse(cr, uid, ids, context=context):
 106             res[m.id] = _get_one_full_name(m)
 107         return res
 108
 109
 110     def _product_value(self, cr, uid, ids, field_names, arg, context=None):
 111         """Computes stock value (real and virtual) for a product, as well as stock qty (real and virtual).
 112         @param field_names: Name of field
 113         @return: Dictionary of values
 114         """
 115         prod_id = context and context.get('product_id', False)
 116
 117         if not prod_id:
 118             return dict([(i, {}.fromkeys(field_names, 0.0)) for i in ids])
 119
 120         product_product_obj = self.pool.get('product.product')
 121
 122         cr.execute('select distinct product_id, location_id from stock_move where location_id in %s', (tuple(ids), ))
 123         dict1 = cr.dictfetchall()
 124         cr.execute('select distinct product_id, location_dest_id as location_id from stock_move where location_dest_id in %s', (tuple(ids), ))
 125         dict2 = cr.dictfetchall()
 126         res_products_by_location = sorted(dict1+dict2, key=itemgetter('location_id'))
 127         products_by_location = dict((k, [v['product_id'] for v in itr]) for k, itr in groupby(res_products_by_location, itemgetter('location_id')))
 128
 129         result = dict([(i, {}.fromkeys(field_names, 0.0)) for i in ids])
 130         result.update(dict([(i, {}.fromkeys(field_names, 0.0)) for i in list(set([aaa['location_id'] for aaa in res_products_by_location]))]))
 131
 132         currency_id = self.pool.get('res.users').browse(cr, uid, uid).company_id.currency_id.id
 133         currency_obj = self.pool.get('res.currency')
 134         currency = currency_obj.browse(cr, uid, currency_id, context=context)
 135         for loc_id, product_ids in products_by_location.items():
 136             if prod_id:
 137                 product_ids = [prod_id]
 138             c = (context or {}).copy()
 139             c['location'] = loc_id
 140             for prod in product_product_obj.browse(cr, uid, product_ids, context=c):
 141                 for f in field_names:
 142                     if f == 'stock_real':
 143                         if loc_id not in result:
 144                             result[loc_id] = {}
 145                         result[loc_id][f] += prod.qty_available
 146                     elif f == 'stock_virtual':
 147                         result[loc_id][f] += prod.virtual_available
 148                     elif f == 'stock_real_value':
 149                         amount = prod.qty_available * prod.standard_price
 150                         amount = currency_obj.round(cr, uid, currency, amount)
 151                         result[loc_id][f] += amount
 152                     elif f == 'stock_virtual_value':
 153                         amount = prod.virtual_available * prod.standard_price
 154                         amount = currency_obj.round(cr, uid, currency, amount)
 155                         result[loc_id][f] += amount
 156         return result
 157
 158     _columns = {
 159         'name': fields.char('Location Name', size=64, required=True, translate=True),
 160         'active': fields.boolean('Active', help="By unchecking the active field, you may hide a location without deleting it."),
 161         'usage': fields.selection([('supplier', 'Supplier Location'), ('view', 'View'), ('internal', 'Internal Location'), ('customer', 'Customer Location'), ('inventory', 'Inventory'), ('procurement', 'Procurement'), ('production', 'Production'), ('transit', 'Transit Location for Inter-Companies Transfers')], 'Location Type', required=True,
 162                  help="""* Supplier Location: Virtual location representing the source location for products coming from your suppliers
 163                        \n* View: Virtual location used to create a hierarchical structures for your warehouse, aggregating its child locations ; can't directly contain products
 164                        \n* Internal Location: Physical locations inside your own warehouses,
 165                        \n* Customer Location: Virtual location representing the destination location for products sent to your customers
 166                        \n* Inventory: Virtual location serving as counterpart for inventory operations used to correct stock levels (Physical inventories)
 167                        \n* Procurement: Virtual location serving as temporary counterpart for procurement operations when the source (supplier or production) is not known yet. This location should be empty when the procurement scheduler has finished running.
 168                        \n* Production: Virtual counterpart location for production operations: this location consumes the raw material and produces finished products
 169                       """, select = True),
 170          # temporarily removed, as it's unused: 'allocation_method': fields.selection([('fifo', 'FIFO'), ('lifo', 'LIFO'), ('nearest', 'Nearest')], 'Allocation Method', required=True),
 171         'complete_name': fields.function(_complete_name, type='char', size=256, string="Location Name", store=True),
 172
 173         'stock_real': fields.function(_product_value, type='float', string='Real Stock', multi="stock"),
 174         'stock_virtual': fields.function(_product_value, type='float', string='Virtual Stock', multi="stock"),
 175
 176         'location_id': fields.many2one('stock.location', 'Parent Location', select=True, ondelete='cascade'),
 177         'child_ids': fields.one2many('stock.location', 'location_id', 'Contains'),
 178
 179         'chained_journal_id': fields.many2one('stock.journal', 'Chaining Journal',help="Inventory Journal in which the chained move will be written, if the Chaining Type is not Transparent (no journal is used if left empty)"),
 180         'chained_location_id': fields.many2one('stock.location', 'Chained Location If Fixed'),
 181         'chained_location_type': fields.selection([('none', 'None'), ('customer', 'Customer'), ('fixed', 'Fixed Location')],
 182             'Chained Location Type', required=True,
 183             help="Determines whether this location is chained to another location, i.e. any incoming product in this location \n" \
 184                 "should next go to the chained location. The chained location is determined according to the type :"\
 185                 "\n* None: No chaining at all"\
 186                 "\n* Customer: The chained location will be taken from the Customer Location field on the Partner form of the Partner that is specified in the Picking list of the incoming products." \
 187                 "\n* Fixed Location: The chained location is taken from the next field: Chained Location if Fixed." \
 188                 ),
 189         'chained_auto_packing': fields.selection(
 190             [('auto', 'Automatic Move'), ('manual', 'Manual Operation'), ('transparent', 'Automatic No Step Added')],
 191             'Chaining Type',
 192             required=True,
 193             help="This is used only if you select a chained location type.\n" \
 194                 "The 'Automatic Move' value will create a stock move after the current one that will be "\
 195                 "validated automatically. With 'Manual Operation', the stock move has to be validated "\
 196                 "by a worker. With 'Automatic No Step Added', the location is replaced in the original move."
 197             ),
 198         'chained_picking_type': fields.selection([('out', 'Sending Goods'), ('in', 'Getting Goods'), ('internal', 'Internal')], 'Shipping Type', help="Shipping Type of the Picking List that will contain the chained move (leave empty to automatically detect the type based on the source and destination locations)."),
 199         'chained_company_id': fields.many2one('res.company', 'Chained Company', help='The company the Picking List containing the chained move will belong to (leave empty to use the default company determination rules'),
 200         'chained_delay': fields.integer('Chaining Lead Time',help="Delay between original move and chained move in days"),
 201         'address_id': fields.many2one('res.partner.address', 'Location Address',help="Address of  customer or supplier."),
 202         'icon': fields.selection(tools.icons, 'Icon', size=64,help="Icon show in  hierarchical tree view"),
 203
 204         'comment': fields.text('Additional Information'),
 205         'posx': fields.integer('Corridor (X)',help="Optional localization details, for information purpose only"),
 206         'posy': fields.integer('Shelves (Y)', help="Optional localization details, for information purpose only"),
 207         'posz': fields.integer('Height (Z)', help="Optional localization details, for information purpose only"),
 208
 209         'parent_left': fields.integer('Left Parent', select=1),
 210         'parent_right': fields.integer('Right Parent', select=1),
 211         'stock_real_value': fields.function(_product_value, type='float', string='Real Stock Value', multi="stock", digits_compute=dp.get_precision('Account')),
 212         'stock_virtual_value': fields.function(_product_value, type='float', string='Virtual Stock Value', multi="stock", digits_compute=dp.get_precision('Account')),
 213         'company_id': fields.many2one('res.company', 'Company', select=1, help='Let this field empty if this location is shared between all companies'),
 214         'scrap_location': fields.boolean('Scrap Location', help='Check this box to allow using this location to put scrapped/damaged goods.'),
 215         'valuation_in_account_id': fields.many2one('account.account', 'Stock Valuation Account (Incoming)', domain = [('type','=','other')],
 216                                                    help="Used for real-time inventory valuation. When set on a virtual location (non internal type), "
 217                                                         "this account will be used to hold the value of products being moved from an internal location "
 218                                                         "into this location, instead of the generic Stock Output Account set on the product. "
 219                                                         "This has no effect for internal locations."),
 220         'valuation_out_account_id': fields.many2one('account.account', 'Stock Valuation Account (Outgoing)', domain = [('type','=','other')],
 221                                                    help="Used for real-time inventory valuation. When set on a virtual location (non internal type), "
 222                                                         "this account will be used to hold the value of products being moved out of this location "
 223                                                         "and into an internal location, instead of the generic Stock Output Account set on the product. "
 224                                                         "This has no effect for internal locations."),
 225     }
 226     _defaults = {
 227         'active': True,
 228         'usage': 'internal',
 229         'chained_location_type': 'none',
 230         'chained_auto_packing': 'manual',
 231         'company_id': lambda self, cr, uid, c: self.pool.get('res.company')._company_default_get(cr, uid, 'stock.location', context=c),
 232         'posx': 0,
 233         'posy': 0,
 234         'posz': 0,
 235         'icon': False,
 236         'scrap_location': False,
 237     }
 238
 239     def chained_location_get(self, cr, uid, location, partner=None, product=None, context=None):
 240         """ Finds chained location
 241         @param location: Location id
 242         @param partner: Partner id
 243         @param product: Product id
 244         @return: List of values
 245         """
 246         result = None
 247         if location.chained_location_type == 'customer':
 248             if partner:
 249                 result = partner.property_stock_customer
 250         elif location.chained_location_type == 'fixed':
 251             result = location.chained_location_id
 252         if result:
 253             return result, location.chained_auto_packing, location.chained_delay, location.chained_journal_id and location.chained_journal_id.id or False, location.chained_company_id and location.chained_company_id.id or False, location.chained_picking_type
 254         return result
 255
 256     def picking_type_get(self, cr, uid, from_location, to_location, context=None):
 257         """ Gets type of picking.
 258         @param from_location: Source location
 259         @param to_location: Destination location
 260         @return: Location type
 261         """
 262         result = 'internal'
 263         if (from_location.usage=='internal') and (to_location and to_location.usage in ('customer', 'supplier')):
 264             result = 'out'
 265         elif (from_location.usage in ('supplier', 'customer')) and (to_location.usage == 'internal'):
 266             result = 'in'
 267         return result
 268
 269     def _product_get_all_report(self, cr, uid, ids, product_ids=False, context=None):
 270         return self._product_get_report(cr, uid, ids, product_ids, context, recursive=True)
 271
 272     def _product_get_report(self, cr, uid, ids, product_ids=False,
 273             context=None, recursive=False):
 274         """ Finds the product quantity and price for particular location.
 275         @param product_ids: Ids of product
 276         @param recursive: True or False
 277         @return: Dictionary of values
 278         """
 279         if context is None:
 280             context = {}
 281         product_obj = self.pool.get('product.product')
 282         # Take the user company and pricetype
 283         context['currency_id'] = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id.id
 284
 285         # To be able to offer recursive or non-recursive reports we need to prevent recursive quantities by default
 286         context['compute_child'] = False
 287
 288         if not product_ids:
 289             product_ids = product_obj.search(cr, uid, [], context={'active_test': False})
 290
 291         products = product_obj.browse(cr, uid, product_ids, context=context)
 292         products_by_uom = {}
 293         products_by_id = {}
 294         for product in products:
 295             products_by_uom.setdefault(product.uom_id.id, [])
 296             products_by_uom[product.uom_id.id].append(product)
 297             products_by_id.setdefault(product.id, [])
 298             products_by_id[product.id] = product
 299
 300         result = {}
 301         result['product'] = []
 302         for id in ids:
 303             quantity_total = 0.0
 304             total_price = 0.0
 305             for uom_id in products_by_uom.keys():
 306                 fnc = self._product_get
 307                 if recursive:
 308                     fnc = self._product_all_get
 309                 ctx = context.copy()
 310                 ctx['uom'] = uom_id
 311                 qty = fnc(cr, uid, id, [x.id for x in products_by_uom[uom_id]],
 312                         context=ctx)
 313                 for product_id in qty.keys():
 314                     if not qty[product_id]:
 315                         continue
 316                     product = products_by_id[product_id]
 317                     quantity_total += qty[product_id]
 318
 319                     # Compute based on pricetype
 320                     # Choose the right filed standard_price to read
 321                     amount_unit = product.price_get('standard_price', context=context)[product.id]
 322                     price = qty[product_id] * amount_unit
 323
 324                     total_price += price
 325                     result['product'].append({
 326                         'price': amount_unit,
 327                         'prod_name': product.name,
 328                         'code': product.default_code, # used by lot_overview_all report!
 329                         'variants': product.variants or '',
 330                         'uom': product.uom_id.name,
 331                         'prod_qty': qty[product_id],
 332                         'price_value': price,
 333                     })
 334         result['total'] = quantity_total
 335         result['total_price'] = total_price
 336         return result
 337
 338     def _product_get_multi_location(self, cr, uid, ids, product_ids=False, context=None,
 339                                     states=['done'], what=('in', 'out')):
 340         """
 341         @param product_ids: Ids of product
 342         @param states: List of states
 343         @param what: Tuple of
 344         @return:
 345         """
 346         product_obj = self.pool.get('product.product')
 347         if context is None:
 348             context = {}
 349         context.update({
 350             'states': states,
 351             'what': what,
 352             'location': ids
 353         })
 354         return product_obj.get_product_available(cr, uid, product_ids, context=context)
 355
 356     def _product_get(self, cr, uid, id, product_ids=False, context=None, states=['done']):
 357         """
 358         @param product_ids:
 359         @param states:
 360         @return:
 361         """
 362         ids = id and [id] or []
 363         return self._product_get_multi_location(cr, uid, ids, product_ids, context=context, states=states)
 364
 365     def _product_all_get(self, cr, uid, id, product_ids=False, context=None, states=['done']):
 366         # build the list of ids of children of the location given by id
 367         ids = id and [id] or []
 368         location_ids = self.search(cr, uid, [('location_id', 'child_of', ids)])
 369         return self._product_get_multi_location(cr, uid, location_ids, product_ids, context, states)
 370
 371     def _product_virtual_get(self, cr, uid, id, product_ids=False, context=None, states=['done']):
 372         return self._product_all_get(cr, uid, id, product_ids, context, ['confirmed', 'waiting', 'assigned', 'done'])
 373
 374     def _product_reserve(self, cr, uid, ids, product_id, product_qty, context=None, lock=False):
 375         """
 376         Attempt to find a quantity ``product_qty`` (in the product's default uom or the uom passed in ``context``) of product ``product_id``
 377         in locations with id ``ids`` and their child locations. If ``lock`` is True, the stock.move lines
 378         of product with id ``product_id`` in the searched location will be write-locked using Postgres's
 379         "FOR UPDATE NOWAIT" option until the transaction is committed or rolled back, to prevent reservin
 380         twice the same products.
 381         If ``lock`` is True and the lock cannot be obtained (because another transaction has locked some of
 382         the same stock.move lines), a log line will be output and False will be returned, as if there was
 383         not enough stock.
 384
 385         :param product_id: Id of product to reserve
 386         :param product_qty: Quantity of product to reserve (in the product's default uom or the uom passed in ``context``)
 387         :param lock: if True, the stock.move lines of product with id ``product_id`` in all locations (and children locations) with ``ids`` will
 388                      be write-locked using postgres's "FOR UPDATE NOWAIT" option until the transaction is committed or rolled back. This is
 389                      to prevent reserving twice the same products.
 390         :param context: optional context dictionary: if a 'uom' key is present it will be used instead of the default product uom to
 391                         compute the ``product_qty`` and in the return value.
 392         :return: List of tuples in the form (qty, location_id) with the (partial) quantities that can be taken in each location to
 393                  reach the requested product_qty (``qty`` is expressed in the default uom of the product), of False if enough
 394                  products could not be found, or the lock could not be obtained (and ``lock`` was True).
 395         """
 396         result = []
 397         amount = 0.0
 398         if context is None:
 399             context = {}
 400         uom_obj = self.pool.get('product.uom')
 401         uom_rounding = self.pool.get('product.product').browse(cr, uid, product_id, context=context).uom_id.rounding
 402         if context.get('uom'):
 403             uom_rounding = uom_obj.browse(cr, uid, context.get('uom'), context=context).rounding
 404         for id in self.search(cr, uid, [('location_id', 'child_of', ids)]):
 405             if lock:
 406                 try:
 407                     # Must lock with a separate select query because FOR UPDATE can't be used with
 408                     # aggregation/group by's (when individual rows aren't identifiable).
 409                     # We use a SAVEPOINT to be able to rollback this part of the transaction without
 410                     # failing the whole transaction in case the LOCK cannot be acquired.
 411                     cr.execute("SAVEPOINT stock_location_product_reserve")
 412                     cr.execute("""SELECT id FROM stock_move
 413                                   WHERE product_id=%s AND
 414                                           (
 415                                             (location_dest_id=%s AND
 416                                              location_id<>%s AND
 417                                              state='done')
 418                                             OR
 419                                             (location_id=%s AND
 420                                              location_dest_id<>%s AND
 421                                              state in ('done', 'assigned'))
 422                                           )
 423                                   FOR UPDATE of stock_move NOWAIT""", (product_id, id, id, id, id), log_exceptions=False)
 424                 except Exception:
 425                     # Here it's likely that the FOR UPDATE NOWAIT failed to get the LOCK,
 426                     # so we ROLLBACK to the SAVEPOINT to restore the transaction to its earlier
 427                     # state, we return False as if the products were not available, and log it:
 428                     cr.execute("ROLLBACK TO stock_location_product_reserve")
 429                     logger = logging.getLogger('stock.location')
 430                     logger.warn("Failed attempt to reserve %s x product %s, likely due to another transaction already in progress. Next attempt is likely to work. Detailed error available at DEBUG level.", product_qty, product_id)
 431                     logger.debug("Trace of the failed product reservation attempt: ", exc_info=True)
 432                     return False
 433
 434             # XXX TODO: rewrite this with one single query, possibly even the quantity conversion
 435             cr.execute("""SELECT product_uom, sum(product_qty) AS product_qty
 436                           FROM stock_move
 437                           WHERE location_dest_id=%s AND
 438                                 location_id<>%s AND
 439                                 product_id=%s AND
 440                                 state='done'
 441                           GROUP BY product_uom
 442                        """,
 443                        (id, id, product_id))
 444             results = cr.dictfetchall()
 445             cr.execute("""SELECT product_uom,-sum(product_qty) AS product_qty
 446                           FROM stock_move
 447                           WHERE location_id=%s AND
 448                                 location_dest_id<>%s AND
 449                                 product_id=%s AND
 450                                 state in ('done', 'assigned')
 451                           GROUP BY product_uom
 452                        """,
 453                        (id, id, product_id))
 454             results += cr.dictfetchall()
 455
 456             total = 0.0
 457             results2 = 0.0
 458             for r in results:
 459                 amount = uom_obj._compute_qty(cr, uid, r['product_uom'], r['product_qty'], context.get('uom', False))
 460                 results2 += amount
 461                 total += amount
 462
 463             if total <= 0.0:
 464                 continue
 465
 466             amount = results2
 467             compare_qty = float_compare(amount, 0, precision_rounding=uom_rounding)
 468             if compare_qty == 1:
 469                 if amount > min(total, product_qty):
 470                     amount = min(product_qty, total)
 471                 result.append((amount, id))
 472                 product_qty -= amount
 473                 total -= amount
 474                 if product_qty <= 0.0:
 475                     return result
 476                 if total <= 0.0:
 477                     continue
 478         return False
 479
 480 stock_location()
 481
 482
 483 class stock_tracking(osv.osv):
 484     _name = "stock.tracking"
 485     _description = "Packs"
 486
 487     def checksum(sscc):
 488         salt = '31' * 8 + '3'
 489         sum = 0
 490         for sscc_part, salt_part in zip(sscc, salt):
 491             sum += int(sscc_part) * int(salt_part)
 492         return (10 - (sum % 10)) % 10
 493     checksum = staticmethod(checksum)
 494
 495     def make_sscc(self, cr, uid, context=None):
 496         sequence = self.pool.get('ir.sequence').get(cr, uid, 'stock.lot.tracking')
 497         try:
 498             return sequence + str(self.checksum(sequence))
 499         except Exception:
 500             return sequence
 501
 502     _columns = {
 503         'name': fields.char('Pack Reference', size=64, required=True, select=True, help="By default, the pack reference is generated following the sscc standard. (Serial number + 1 check digit)"),
 504         'active': fields.boolean('Active', help="By unchecking the active field, you may hide a pack without deleting it."),
 505         'serial': fields.char('Additional Reference', size=64, select=True, help="Other reference or serial number"),
 506         'move_ids': fields.one2many('stock.move', 'tracking_id', 'Moves for this pack', readonly=True),
 507         'date': fields.datetime('Creation Date', required=True),
 508     }
 509     _defaults = {
 510         'active': 1,
 511         'name': make_sscc,
 512         'date': lambda *a: time.strftime('%Y-%m-%d %H:%M:%S'),
 513     }
 514
 515     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=100):
 516         if not args:
 517             args = []
 518         ids = self.search(cr, user, [('serial', '=', name)]+ args, limit=limit, context=context)
 519         ids += self.search(cr, user, [('name', operator, name)]+ args, limit=limit, context=context)
 520         return self.name_get(cr, user, ids, context)
 521
 522     def name_get(self, cr, uid, ids, context=None):
 523         if not len(ids):
 524             return []
 525         res = [(r['id'], r['name']+' ['+(r['serial'] or '')+']') for r in self.read(cr, uid, ids, ['name', 'serial'], context)]
 526         return res
 527
 528     def unlink(self, cr, uid, ids, context=None):
 529         raise osv.except_osv(_('Error'), _('You can not remove a lot line !'))
 530
 531     def action_traceability(self, cr, uid, ids, context={}):
 532         """ It traces the information of a product
 533         @param self: The object pointer.
 534         @param cr: A database cursor
 535         @param uid: ID of the user currently logged in
 536         @param ids: List of IDs selected
 537         @param context: A standard dictionary
 538         @return: A dictionary of values
 539         """
 540         value={}
 541         value=self.pool.get('action.traceability').action_traceability(cr,uid,ids,context)
 542         return value
 543 stock_tracking()
 544
 545 #----------------------------------------------------------
 546 # Stock Picking
 547 #----------------------------------------------------------
 548 class stock_picking(osv.osv):
 549     _name = "stock.picking"
 550     _description = "Picking List"
 551
 552     def _set_maximum_date(self, cr, uid, ids, name, value, arg, context=None):
 553         """ Calculates planned date if it is greater than 'value'.
 554         @param name: Name of field
 555         @param value: Value of field
 556         @param arg: User defined argument
 557         @return: True or False
 558         """
 559         if not value:
 560             return False
 561         if isinstance(ids, (int, long)):
 562             ids = [ids]
 563         for pick in self.browse(cr, uid, ids, context=context):
 564             sql_str = """update stock_move set
 565                     date='%s'
 566                 where
 567                     picking_id=%d """ % (value, pick.id)
 568
 569             if pick.max_date:
 570                 sql_str += " and (date='" + pick.max_date + "' or date>'" + value + "')"
 571             cr.execute(sql_str)
 572         return True
 573
 574     def _set_minimum_date(self, cr, uid, ids, name, value, arg, context=None):
 575         """ Calculates planned date if it is less than 'value'.
 576         @param name: Name of field
 577         @param value: Value of field
 578         @param arg: User defined argument
 579         @return: True or False
 580         """
 581         if not value:
 582             return False
 583         if isinstance(ids, (int, long)):
 584             ids = [ids]
 585         for pick in self.browse(cr, uid, ids, context=context):
 586             sql_str = """update stock_move set
 587                     date='%s'
 588                 where
 589                     picking_id=%s """ % (value, pick.id)
 590             if pick.min_date:
 591                 sql_str += " and (date='" + pick.min_date + "' or date<'" + value + "')"
 592             cr.execute(sql_str)
 593         return True
 594
 595     def get_min_max_date(self, cr, uid, ids, field_name, arg, context=None):
 596         """ Finds minimum and maximum dates for picking.
 597         @return: Dictionary of values
 598         """
 599         res = {}
 600         for id in ids:
 601             res[id] = {'min_date': False, 'max_date': False}
 602         if not ids:
 603             return res
 604         cr.execute("""select
 605                 picking_id,
 606                 min(date_expected),
 607                 max(date_expected)
 608             from
 609                 stock_move
 610             where
 611                 picking_id IN %s
 612             group by
 613                 picking_id""",(tuple(ids),))
 614         for pick, dt1, dt2 in cr.fetchall():
 615             res[pick]['min_date'] = dt1
 616             res[pick]['max_date'] = dt2
 617         return res
 618
 619     def create(self, cr, user, vals, context=None):
 620         if ('name' not in vals) or (vals.get('name')=='/'):
 621             seq_obj_name =  'stock.picking.' + vals['type']
 622             vals['name'] = self.pool.get('ir.sequence').get(cr, user, seq_obj_name)
 623         new_id = super(stock_picking, self).create(cr, user, vals, context)
 624         return new_id
 625
 626     _columns = {
 627         'name': fields.char('Reference', size=64, select=True),
 628         'origin': fields.char('Origin', size=64, help="Reference of the document that produced this picking.", select=True),
 629         'backorder_id': fields.many2one('stock.picking', 'Back Order of', help="If this picking was split this field links to the picking that contains the other part that has been processed already.", select=True),
 630         'type': fields.selection([('out', 'Sending Goods'), ('in', 'Getting Goods'), ('internal', 'Internal')], 'Shipping Type', required=True, select=True, help="Shipping type specify, goods coming in or going out."),
 631         'note': fields.text('Notes'),
 632         'stock_journal_id': fields.many2one('stock.journal','Stock Journal', select=True),
 633         'location_id': fields.many2one('stock.location', 'Location', help="Keep empty if you produce at the location where the finished products are needed." \
 634                 "Set a location if you produce at a fixed location. This can be a partner location " \
 635                 "if you subcontract the manufacturing operations.", select=True),
 636         'location_dest_id': fields.many2one('stock.location', 'Dest. Location',help="Location where the system will stock the finished products.", select=True),
 637         'move_type': fields.selection([('direct', 'Partial Delivery'), ('one', 'All at once')], 'Delivery Method', required=True, help="It specifies goods to be delivered all at once or by direct delivery"),
 638         'state': fields.selection([
 639             ('draft', 'New'),
 640             ('auto', 'Waiting Another Operation'),
 641             ('confirmed', 'Waiting Availability'),
 642             ('assigned', 'Ready to Process'),
 643             ('done', 'Done'),
 644             ('cancel', 'Cancelled'),
 645             ], 'State', readonly=True, select=True,
 646             help="* Draft: not confirmed yet and will not be scheduled until confirmed\n"\
 647                  "* Confirmed: still waiting for the availability of products\n"\
 648                  "* Available: products reserved, simply waiting for confirmation.\n"\
 649                  "* Waiting: waiting for another move to proceed before it becomes automatically available (e.g. in Make-To-Order flows)\n"\
 650                  "* Done: has been processed, can't be modified or cancelled anymore\n"\
 651                  "* Cancelled: has been cancelled, can't be confirmed anymore"),
 652         'min_date': fields.function(get_min_max_date, fnct_inv=_set_minimum_date, multi="min_max_date",
 653                  store=True, type='datetime', string='Expected Date', select=1, help="Expected date for the picking to be processed"),
 654         'date': fields.datetime('Order Date', help="Date of Order", select=True),
 655         'date_done': fields.datetime('Date Done', help="Date of Completion"),
 656         'max_date': fields.function(get_min_max_date, fnct_inv=_set_maximum_date, multi="min_max_date",
 657                  store=True, type='datetime', string='Max. Expected Date', select=2),
 658         'move_lines': fields.one2many('stock.move', 'picking_id', 'Internal Moves', states={'done': [('readonly', True)], 'cancel': [('readonly', True)]}),
 659         'auto_picking': fields.boolean('Auto-Picking'),
 660         'address_id': fields.many2one('res.partner.address', 'Address', help="Address of partner"),
 661         'partner_id': fields.related('address_id','partner_id',type='many2one',relation='res.partner',string='Partner',store=True),
 662         'invoice_state': fields.selection([
 663             ("invoiced", "Invoiced"),
 664             ("2binvoiced", "To Be Invoiced"),
 665             ("none", "Not Applicable")], "Invoice Control",
 666             select=True, required=True, readonly=True, states={'draft': [('readonly', False)]}),
 667         'company_id': fields.many2one('res.company', 'Company', required=True, select=True),
 668     }
 669     _defaults = {
 670         'name': lambda self, cr, uid, context: '/',
 671         'state': 'draft',
 672         'move_type': 'direct',
 673         'type': 'in',
 674         'invoice_state': 'none',
 675         'date': lambda *a: time.strftime('%Y-%m-%d %H:%M:%S'),
 676         'company_id': lambda self, cr, uid, c: self.pool.get('res.company')._company_default_get(cr, uid, 'stock.picking', context=c)
 677     }
 678     _sql_constraints = [
 679         ('name_uniq', 'unique(name, company_id)', 'Reference must be unique per Company!'),
 680     ]
 681
 682     def action_process(self, cr, uid, ids, context=None):
 683         if context is None: context = {}
 684         context = dict(context, active_ids=ids, active_model=self._name)
 685         partial_id = self.pool.get("stock.partial.picking").create(cr, uid, {}, context=context)
 686         return {
 687             'name':_("Products to Process"),
 688             'view_mode': 'form',
 689             'view_id': False,
 690             'view_type': 'form',
 691             'res_model': 'stock.partial.picking',
 692             'res_id': partial_id,
 693             'type': 'ir.actions.act_window',
 694             'nodestroy': True,
 695             'target': 'new',
 696             'domain': '[]',
 697             'context': context,
 698         }
 699
 700     def copy(self, cr, uid, id, default=None, context=None):
 701         if default is None:
 702             default = {}
 703         default = default.copy()
 704         picking_obj = self.browse(cr, uid, id, context=context)
 705         move_obj=self.pool.get('stock.move')
 706         if ('name' not in default) or (picking_obj.name=='/'):
 707             seq_obj_name =  'stock.picking.' + picking_obj.type
 708             default['name'] = self.pool.get('ir.sequence').get(cr, uid, seq_obj_name)
 709             default['origin'] = ''
 710             default['backorder_id'] = False
 711         if picking_obj.invoice_state == 'invoiced':
 712             default['invoice_state'] = '2binvoiced'
 713         res=super(stock_picking, self).copy(cr, uid, id, default, context)
 714         if res:
 715             picking_obj = self.browse(cr, uid, res, context=context)
 716             for move in picking_obj.move_lines:
 717                 move_obj.write(cr, uid, [move.id], {'tracking_id': False,'prodlot_id':False, 'move_history_ids2': [(6, 0, [])], 'move_history_ids': [(6, 0, [])]})
 718         return res
 719
 720     def onchange_partner_in(self, cr, uid, context=None, partner_id=None):
 721         return {}
 722
 723     def action_explode(self, cr, uid, moves, context=None):
 724         return moves
 725
 726     def action_confirm(self, cr, uid, ids, context=None):
 727         """ Confirms picking.
 728         @return: True
 729         """
 730         self.write(cr, uid, ids, {'state': 'confirmed'})
 731         todo = []
 732         for picking in self.browse(cr, uid, ids, context=context):
 733             for r in picking.move_lines:
 734                 if r.state == 'draft':
 735                     todo.append(r.id)
 736
 737         self.log_picking(cr, uid, ids, context=context)
 738
 739         todo = self.action_explode(cr, uid, todo, context)
 740         if len(todo):
 741             self.pool.get('stock.move').action_confirm(cr, uid, todo, context=context)
 742         return True
 743
 744     def test_auto_picking(self, cr, uid, ids):
 745         # TODO: Check locations to see if in the same location ?
 746         return True
 747
 748     def action_assign(self, cr, uid, ids, *args):
 749         """ Changes state of picking to available if all moves are confirmed.
 750         @return: True
 751         """
 752         for pick in self.browse(cr, uid, ids):
 753             move_ids = [x.id for x in pick.move_lines if x.state == 'confirmed']
 754             if not move_ids:
 755                 raise osv.except_osv(_('Warning !'),_('Not enough stock, unable to reserve the products.'))
 756             self.pool.get('stock.move').action_assign(cr, uid, move_ids)
 757         return True
 758
 759     def force_assign(self, cr, uid, ids, *args):
 760         """ Changes state of picking to available if moves are confirmed or waiting.
 761         @return: True
 762         """
 763         wf_service = netsvc.LocalService("workflow")
 764         for pick in self.browse(cr, uid, ids):
 765             move_ids = [x.id for x in pick.move_lines if x.state in ['confirmed','waiting']]
 766             self.pool.get('stock.move').force_assign(cr, uid, move_ids)
 767             wf_service.trg_write(uid, 'stock.picking', pick.id, cr)
 768         return True
 769
 770     def draft_force_assign(self, cr, uid, ids, *args):
 771         """ Confirms picking directly from draft state.
 772         @return: True
 773         """
 774         wf_service = netsvc.LocalService("workflow")
 775         for pick in self.browse(cr, uid, ids):
 776             if not pick.move_lines:
 777                 raise osv.except_osv(_('Error !'),_('You can not process picking without stock moves'))
 778             wf_service.trg_validate(uid, 'stock.picking', pick.id,
 779                 'button_confirm', cr)
 780         return True
 781
 782     def draft_validate(self, cr, uid, ids, context=None):
 783         """ Validates picking directly from draft state.
 784         @return: True
 785         """
 786         wf_service = netsvc.LocalService("workflow")
 787         self.draft_force_assign(cr, uid, ids)
 788         for pick in self.browse(cr, uid, ids, context=context):
 789             move_ids = [x.id for x in pick.move_lines]
 790             self.pool.get('stock.move').force_assign(cr, uid, move_ids)
 791             wf_service.trg_write(uid, 'stock.picking', pick.id, cr)
 792         return self.action_process(
 793             cr, uid, ids, context=context)
 794     def cancel_assign(self, cr, uid, ids, *args):
 795         """ Cancels picking and moves.
 796         @return: True
 797         """
 798         wf_service = netsvc.LocalService("workflow")
 799         for pick in self.browse(cr, uid, ids):
 800             move_ids = [x.id for x in pick.move_lines]
 801             self.pool.get('stock.move').cancel_assign(cr, uid, move_ids)
 802             wf_service.trg_write(uid, 'stock.picking', pick.id, cr)
 803         return True
 804
 805     def action_assign_wkf(self, cr, uid, ids, context=None):
 806         """ Changes picking state to assigned.
 807         @return: True
 808         """
 809         self.write(cr, uid, ids, {'state': 'assigned'})
 810         self.log_picking(cr, uid, ids, context=context)
 811         return True
 812
 813     def test_finished(self, cr, uid, ids):
 814         """ Tests whether the move is in done or cancel state or not.
 815         @return: True or False
 816         """
 817         move_ids = self.pool.get('stock.move').search(cr, uid, [('picking_id', 'in', ids)])
 818         for move in self.pool.get('stock.move').browse(cr, uid, move_ids):
 819             if move.state not in ('done', 'cancel'):
 820
 821                 if move.product_qty != 0.0:
 822                     return False
 823                 else:
 824                     move.write({'state': 'done'})
 825         return True
 826
 827     def test_assigned(self, cr, uid, ids):
 828         """ Tests whether the move is in assigned state or not.
 829         @return: True or False
 830         """
 831         ok = True
 832         for pick in self.browse(cr, uid, ids):
 833             mt = pick.move_type
 834             for move in pick.move_lines:
 835                 if (move.state in ('confirmed', 'draft')) and (mt == 'one'):
 836                     return False
 837                 if (mt == 'direct') and (move.state == 'assigned') and (move.product_qty):
 838                     return True
 839                 ok = ok and (move.state in ('cancel', 'done', 'assigned'))
 840         return ok
 841
 842     def action_cancel(self, cr, uid, ids, context=None):
 843         """ Changes picking state to cancel.
 844         @return: True
 845         """
 846         for pick in self.browse(cr, uid, ids, context=context):
 847             ids2 = [move.id for move in pick.move_lines]
 848             self.pool.get('stock.move').action_cancel(cr, uid, ids2, context)
 849         self.write(cr, uid, ids, {'state': 'cancel', 'invoice_state': 'none'})
 850         self.log_picking(cr, uid, ids, context=context)
 851         return True
 852
 853     #
 854     # TODO: change and create a move if not parents
 855     #
 856     def action_done(self, cr, uid, ids, context=None):
 857         """ Changes picking state to done.
 858         @return: True
 859         """
 860         self.write(cr, uid, ids, {'state': 'done', 'date_done': time.strftime('%Y-%m-%d %H:%M:%S')})
 861         return True
 862
 863     def action_move(self, cr, uid, ids, context=None):
 864         """ Changes move state to assigned.
 865         @return: True
 866         """
 867         for pick in self.browse(cr, uid, ids, context=context):
 868             todo = []
 869             for move in pick.move_lines:
 870                 if move.state == 'draft':
 871                     self.pool.get('stock.move').action_confirm(cr, uid, [move.id],
 872                         context=context)
 873                     todo.append(move.id)
 874                 elif move.state in ('assigned','confirmed'):
 875                     todo.append(move.id)
 876             if len(todo):
 877                 self.pool.get('stock.move').action_done(cr, uid, todo,
 878                         context=context)
 879         return True
 880
 881     def get_currency_id(self, cr, uid, picking):
 882         return False
 883
 884     def _get_payment_term(self, cr, uid, picking):
 885         """ Gets payment term from partner.
 886         @return: Payment term
 887         """
 888         partner = picking.address_id.partner_id
 889         return partner.property_payment_term and partner.property_payment_term.id or False
 890
 891     def _get_address_invoice(self, cr, uid, picking):
 892         """ Gets invoice address of a partner
 893         @return {'contact': address, 'invoice': address} for invoice
 894         """
 895         partner_obj = self.pool.get('res.partner')
 896         partner = picking.address_id.partner_id
 897         return partner_obj.address_get(cr, uid, [partner.id],
 898                 ['contact', 'invoice'])
 899
 900     def _get_comment_invoice(self, cr, uid, picking):
 901         """
 902         @return: comment string for invoice
 903         """
 904         return picking.note or ''
 905
 906     def _get_price_unit_invoice(self, cr, uid, move_line, type, context=None):
 907         """ Gets price unit for invoice
 908         @param move_line: Stock move lines
 909         @param type: Type of invoice
 910         @return: The price unit for the move line
 911         """
 912         if context is None:
 913             context = {}
 914
 915         if type in ('in_invoice', 'in_refund'):
 916             # Take the user company and pricetype
 917             context['currency_id'] = move_line.company_id.currency_id.id
 918             amount_unit = move_line.product_id.price_get('standard_price', context=context)[move_line.product_id.id]
 919             return amount_unit
 920         else:
 921             return move_line.product_id.list_price
 922
 923     def _get_discount_invoice(self, cr, uid, move_line):
 924         '''Return the discount for the move line'''
 925         return 0.0
 926
 927     def _get_taxes_invoice(self, cr, uid, move_line, type):
 928         """ Gets taxes on invoice
 929         @param move_line: Stock move lines
 930         @param type: Type of invoice
 931         @return: Taxes Ids for the move line
 932         """
 933         if type in ('in_invoice', 'in_refund'):
 934             taxes = move_line.product_id.supplier_taxes_id
 935         else:
 936             taxes = move_line.product_id.taxes_id
 937
 938         if move_line.picking_id and move_line.picking_id.address_id and move_line.picking_id.address_id.partner_id:
 939             return self.pool.get('account.fiscal.position').map_tax(
 940                 cr,
 941                 uid,
 942                 move_line.picking_id.address_id.partner_id.property_account_position,
 943                 taxes
 944             )
 945         else:
 946             return map(lambda x: x.id, taxes)
 947
 948     def _get_account_analytic_invoice(self, cr, uid, picking, move_line):
 949         return False
 950
 951     def _invoice_line_hook(self, cr, uid, move_line, invoice_line_id):
 952         '''Call after the creation of the invoice line'''
 953         return
 954
 955     def _invoice_hook(self, cr, uid, picking, invoice_id):
 956         '''Call after the creation of the invoice'''
 957         return
 958
 959     def _get_invoice_type(self, pick):
 960         src_usage = dest_usage = None
 961         inv_type = None
 962         if pick.invoice_state == '2binvoiced':
 963             if pick.move_lines:
 964                 src_usage = pick.move_lines[0].location_id.usage
 965                 dest_usage = pick.move_lines[0].location_dest_id.usage
 966             if pick.type == 'out' and dest_usage == 'supplier':
 967                 inv_type = 'in_refund'
 968             elif pick.type == 'out' and dest_usage == 'customer':
 969                 inv_type = 'out_invoice'
 970             elif pick.type == 'in' and src_usage == 'supplier':
 971                 inv_type = 'in_invoice'
 972             elif pick.type == 'in' and src_usage == 'customer':
 973                 inv_type = 'out_refund'
 974             else:
 975                 inv_type = 'out_invoice'
 976         return inv_type
 977
 978     def action_invoice_create(self, cr, uid, ids, journal_id=False,
 979             group=False, type='out_invoice', context=None):
 980         """ Creates invoice based on the invoice state selected for picking.
 981         @param journal_id: Id of journal
 982         @param group: Whether to create a group invoice or not
 983         @param type: Type invoice to be created
 984         @return: Ids of created invoices for the pickings
 985         """
 986         if context is None:
 987             context = {}
 988
 989         invoice_obj = self.pool.get('account.invoice')
 990         invoice_line_obj = self.pool.get('account.invoice.line')
 991         address_obj = self.pool.get('res.partner.address')
 992         invoices_group = {}
 993         res = {}
 994         inv_type = type
 995         for picking in self.browse(cr, uid, ids, context=context):
 996             if picking.invoice_state != '2binvoiced':
 997                 continue
 998             partner =  picking.address_id and picking.address_id.partner_id
 999             if not partner:
1000                 raise osv.except_osv(_('Error, no partner !'),
1001                     _('Please put a partner on the picking list if you want to generate invoice.'))
1002
1003             if not inv_type:
1004                 inv_type = self._get_invoice_type(picking)
1005
1006             if inv_type in ('out_invoice', 'out_refund'):
1007                 account_id = partner.property_account_receivable.id
1008             else:
1009                 account_id = partner.property_account_payable.id
1010             address_contact_id, address_invoice_id = \
1011                     self._get_address_invoice(cr, uid, picking).values()
1012             address = address_obj.browse(cr, uid, address_contact_id, context=context)
1013
1014             comment = self._get_comment_invoice(cr, uid, picking)
1015             if group and partner.id in invoices_group:
1016                 invoice_id = invoices_group[partner.id]
1017                 invoice = invoice_obj.browse(cr, uid, invoice_id)
1018                 invoice_vals = {
1019                     'name': (invoice.name or '') + ', ' + (picking.name or ''),
1020                     'origin': (invoice.origin or '') + ', ' + (picking.name or '') + (picking.origin and (':' + picking.origin) or ''),
1021                     'comment': (comment and (invoice.comment and invoice.comment+"\n"+comment or comment)) or (invoice.comment and invoice.comment or ''),
1022                     'date_invoice':context.get('date_inv',False),
1023                     'user_id':uid
1024                 }
1025                 invoice_obj.write(cr, uid, [invoice_id], invoice_vals, context=context)
1026             else:
1027                 invoice_vals = {
1028                     'name': picking.name,
1029                     'origin': (picking.name or '') + (picking.origin and (':' + picking.origin) or ''),
1030                     'type': inv_type,
1031                     'account_id': account_id,
1032                     'partner_id': address.partner_id.id,
1033                     'address_invoice_id': address_invoice_id,
1034                     'address_contact_id': address_contact_id,
1035                     'comment': comment,
1036                     'payment_term': self._get_payment_term(cr, uid, picking),
1037                     'fiscal_position': partner.property_account_position.id,
1038                     'date_invoice': context.get('date_inv',False),
1039                     'company_id': picking.company_id.id,
1040                     'user_id':uid
1041                 }
1042                 cur_id = self.get_currency_id(cr, uid, picking)
1043                 if cur_id:
1044                     invoice_vals['currency_id'] = cur_id
1045                 if journal_id:
1046                     invoice_vals['journal_id'] = journal_id
1047                 invoice_id = invoice_obj.create(cr, uid, invoice_vals,
1048                         context=context)
1049                 invoices_group[partner.id] = invoice_id
1050             res[picking.id] = invoice_id
1051             for move_line in picking.move_lines:
1052                 if move_line.state == 'cancel':
1053                     continue
1054                 origin = move_line.picking_id.name or ''
1055                 if move_line.picking_id.origin:
1056                     origin += ':' + move_line.picking_id.origin
1057                 if group:
1058                     name = (picking.name or '') + '-' + move_line.name
1059                 else:
1060                     name = move_line.name
1061
1062                 if inv_type in ('out_invoice', 'out_refund'):
1063                     account_id = move_line.product_id.product_tmpl_id.\
1064                             property_account_income.id
1065                     if not account_id:
1066                         account_id = move_line.product_id.categ_id.\
1067                                 property_account_income_categ.id
1068                 else:
1069                     account_id = move_line.product_id.product_tmpl_id.\
1070                             property_account_expense.id
1071                     if not account_id:
1072                         account_id = move_line.product_id.categ_id.\
1073                                 property_account_expense_categ.id
1074
1075                 price_unit = self._get_price_unit_invoice(cr, uid,
1076                         move_line, inv_type)
1077                 discount = self._get_discount_invoice(cr, uid, move_line)
1078                 tax_ids = self._get_taxes_invoice(cr, uid, move_line, inv_type)
1079                 account_analytic_id = self._get_account_analytic_invoice(cr, uid, picking, move_line)
1080
1081                 #set UoS if it's a sale and the picking doesn't have one
1082                 uos_id = move_line.product_uos and move_line.product_uos.id or False
1083                 if not uos_id and inv_type in ('out_invoice', 'out_refund'):
1084                     uos_id = move_line.product_uom.id
1085
1086                 account_id = self.pool.get('account.fiscal.position').map_account(cr, uid, partner.property_account_position, account_id)
1087                 invoice_line_id = invoice_line_obj.create(cr, uid, {
1088                     'name': name,
1089                     'origin': origin,
1090                     'invoice_id': invoice_id,
1091                     'uos_id': uos_id,
1092                     'product_id': move_line.product_id.id,
1093                     'account_id': account_id,
1094                     'price_unit': price_unit,
1095                     'discount': discount,
1096                     'quantity': move_line.product_uos_qty or move_line.product_qty,
1097                     'invoice_line_tax_id': [(6, 0, tax_ids)],
1098                     'account_analytic_id': account_analytic_id,
1099                 }, context=context)
1100                 self._invoice_line_hook(cr, uid, move_line, invoice_line_id)
1101
1102             invoice_obj.button_compute(cr, uid, [invoice_id], context=context,
1103                     set_total=(inv_type in ('in_invoice', 'in_refund')))
1104             self.write(cr, uid, [picking.id], {
1105                 'invoice_state': 'invoiced',
1106                 }, context=context)
1107             self._invoice_hook(cr, uid, picking, invoice_id)
1108         self.write(cr, uid, res.keys(), {
1109             'invoice_state': 'invoiced',
1110             }, context=context)
1111         return res
1112
1113     def test_done(self, cr, uid, ids, context=None):
1114         """ Test whether the move lines are done or not.
1115         @return: True or False
1116         """
1117         ok = False
1118         for pick in self.browse(cr, uid, ids, context=context):
1119             if not pick.move_lines:
1120                 return True
1121             for move in pick.move_lines:
1122                 if move.state not in ('cancel','done'):
1123                     return False
1124                 if move.state=='done':
1125                     ok = True
1126         return ok
1127
1128     def test_cancel(self, cr, uid, ids, context=None):
1129         """ Test whether the move lines are canceled or not.
1130         @return: True or False
1131         """
1132         for pick in self.browse(cr, uid, ids, context=context):
1133             for move in pick.move_lines:
1134                 if move.state not in ('cancel',):
1135                     return False
1136         return True
1137
1138     def allow_cancel(self, cr, uid, ids, context=None):
1139         for pick in self.browse(cr, uid, ids, context=context):
1140             if not pick.move_lines:
1141                 return True
1142             for move in pick.move_lines:
1143                 if move.state == 'done':
1144                     raise osv.except_osv(_('Error'), _('You cannot cancel picking because stock move is in done state !'))
1145         return True
1146     def unlink(self, cr, uid, ids, context=None):
1147         move_obj = self.pool.get('stock.move')
1148         if context is None:
1149             context = {}
1150         for pick in self.browse(cr, uid, ids, context=context):
1151             if pick.state in ['done','cancel']:
1152                 raise osv.except_osv(_('Error'), _('You cannot remove the picking which is in %s state !')%(pick.state,))
1153             else:
1154                 ids2 = [move.id for move in pick.move_lines]
1155                 ctx = context.copy()
1156                 ctx.update({'call_unlink':True})
1157                 if pick.state != 'draft':
1158                     #Cancelling the move in order to affect Virtual stock of product
1159                     move_obj.action_cancel(cr, uid, ids2, ctx)
1160                 #Removing the move
1161                 move_obj.unlink(cr, uid, ids2, ctx)
1162
1163         return super(stock_picking, self).unlink(cr, uid, ids, context=context)
1164
1165     # FIXME: needs refactoring, this code is partially duplicated in stock_move.do_partial()!
1166     def do_partial(self, cr, uid, ids, partial_datas, context=None):
1167         """ Makes partial picking and moves done.
1168         @param partial_datas : Dictionary containing details of partial picking
1169                           like partner_id, address_id, delivery_date,
1170                           delivery moves with product_id, product_qty, uom
1171         @return: Dictionary of values
1172         """
1173         if context is None:
1174             context = {}
1175         else:
1176             context = dict(context)
1177         res = {}
1178         move_obj = self.pool.get('stock.move')
1179         product_obj = self.pool.get('product.product')
1180         currency_obj = self.pool.get('res.currency')
1181         uom_obj = self.pool.get('product.uom')
1182         sequence_obj = self.pool.get('ir.sequence')
1183         wf_service = netsvc.LocalService("workflow")
1184         for pick in self.browse(cr, uid, ids, context=context):
1185             new_picking = None
1186             complete, too_many, too_few = [], [], []
1187             move_product_qty = {}
1188             prodlot_ids = {}
1189             product_avail = {}
1190             for move in pick.move_lines:
1191                 if move.state in ('done', 'cancel'):
1192                     continue
1193                 partial_data = partial_datas.get('move%s'%(move.id), {})
1194                 product_qty = partial_data.get('product_qty',0.0)
1195                 move_product_qty[move.id] = product_qty
1196                 product_uom = partial_data.get('product_uom',False)
1197                 product_price = partial_data.get('product_price',0.0)
1198                 product_currency = partial_data.get('product_currency',False)
1199                 prodlot_id = partial_data.get('prodlot_id')
1200                 prodlot_ids[move.id] = prodlot_id
1201                 if move.product_qty == product_qty:
1202                     complete.append(move)
1203                 elif move.product_qty > product_qty:
1204                     too_few.append(move)
1205                 else:
1206                     too_many.append(move)
1207
1208                 # Average price computation
1209                 if (pick.type == 'in') and (move.product_id.cost_method == 'average'):
1210                     product = product_obj.browse(cr, uid, move.product_id.id)
1211                     move_currency_id = move.company_id.currency_id.id
1212                     context['currency_id'] = move_currency_id
1213                     qty = uom_obj._compute_qty(cr, uid, product_uom, product_qty, product.uom_id.id)
1214
1215                     if product.id in product_avail:
1216                         product_avail[product.id] += qty
1217                     else:
1218                         product_avail[product.id] = product.qty_available
1219
1220                     if qty > 0:
1221                         new_price = currency_obj.compute(cr, uid, product_currency,
1222                                 move_currency_id, product_price)
1223                         new_price = uom_obj._compute_price(cr, uid, product_uom, new_price,
1224                                 product.uom_id.id)
1225                         if product.qty_available <= 0:
1226                             new_std_price = new_price
1227                         else:
1228                             # Get the standard price
1229                             amount_unit = product.price_get('standard_price', context=context)[product.id]
1230                             new_std_price = ((amount_unit * product_avail[product.id])\
1231                                 + (new_price * qty))/(product_avail[product.id] + qty)
1232                         # Write the field according to price type field
1233                         product_obj.write(cr, uid, [product.id], {'standard_price': new_std_price})
1234
1235                         # Record the values that were chosen in the wizard, so they can be
1236                         # used for inventory valuation if real-time valuation is enabled.
1237                         move_obj.write(cr, uid, [move.id],
1238                                 {'price_unit': product_price,
1239                                  'price_currency_id': product_currency})
1240
1241
1242             for move in too_few:
1243                 product_qty = move_product_qty[move.id]
1244
1245                 if not new_picking:
1246                     new_picking = self.copy(cr, uid, pick.id,
1247                             {
1248                                 'name': sequence_obj.get(cr, uid, 'stock.picking.%s'%(pick.type)),
1249                                 'move_lines' : [],
1250                                 'state':'draft',
1251                             })
1252                 if product_qty != 0:
1253                     defaults = {
1254                             'product_qty' : product_qty,
1255                             'product_uos_qty': product_qty, #TODO: put correct uos_qty
1256                             'picking_id' : new_picking,
1257                             'state': 'assigned',
1258                             'move_dest_id': False,
1259                             'price_unit': move.price_unit,
1260                     }
1261                     prodlot_id = prodlot_ids[move.id]
1262                     if prodlot_id:
1263                         defaults.update(prodlot_id=prodlot_id)
1264                     move_obj.copy(cr, uid, move.id, defaults)
1265
1266                 move_obj.write(cr, uid, [move.id],
1267                         {
1268                             'product_qty' : move.product_qty - product_qty,
1269                             'product_uos_qty':move.product_qty - product_qty, #TODO: put correct uos_qty
1270                         })
1271
1272             if new_picking:
1273                 move_obj.write(cr, uid, [c.id for c in complete], {'picking_id': new_picking})
1274             for move in complete:
1275                 if prodlot_ids.get(move.id):
1276                     move_obj.write(cr, uid, [move.id], {'prodlot_id': prodlot_ids[move.id]})
1277             for move in too_many:
1278                 product_qty = move_product_qty[move.id]
1279                 defaults = {
1280                     'product_qty' : product_qty,
1281                     'product_uos_qty': product_qty, #TODO: put correct uos_qty
1282                 }
1283                 prodlot_id = prodlot_ids.get(move.id)
1284                 if prodlot_ids.get(move.id):
1285                     defaults.update(prodlot_id=prodlot_id)
1286                 if new_picking:
1287                     defaults.update(picking_id=new_picking)
1288                 move_obj.write(cr, uid, [move.id], defaults)
1289
1290
1291             # At first we confirm the new picking (if necessary)
1292             if new_picking:
1293                 wf_service.trg_validate(uid, 'stock.picking', new_picking, 'button_confirm', cr)
1294                 # Then we finish the good picking
1295                 self.write(cr, uid, [pick.id], {'backorder_id': new_picking})
1296                 self.action_move(cr, uid, [new_picking])
1297                 wf_service.trg_validate(uid, 'stock.picking', new_picking, 'button_done', cr)
1298                 wf_service.trg_write(uid, 'stock.picking', pick.id, cr)
1299                 delivered_pack_id = new_picking
1300             else:
1301                 self.action_move(cr, uid, [pick.id])
1302                 wf_service.trg_validate(uid, 'stock.picking', pick.id, 'button_done', cr)
1303                 delivered_pack_id = pick.id
1304
1305             delivered_pack = self.browse(cr, uid, delivered_pack_id, context=context)
1306             res[pick.id] = {'delivered_picking': delivered_pack.id or False}
1307
1308         return res
1309
1310     def log_picking(self, cr, uid, ids, context=None):
1311         """ This function will create log messages for picking.
1312         @param cr: the database cursor
1313         @param uid: the current user's ID for security checks,
1314         @param ids: List of Picking Ids
1315         @param context: A standard dictionary for contextual values
1316         """
1317         if context is None:
1318             context = {}
1319         data_obj = self.pool.get('ir.model.data')
1320         for pick in self.browse(cr, uid, ids, context=context):
1321             msg=''
1322             if pick.auto_picking:
1323                 continue
1324             type_list = {
1325                 'out':_("Delivery Order"),
1326                 'in':_('Reception'),
1327                 'internal': _('Internal picking'),
1328             }
1329             view_list = {
1330                 'out': 'view_picking_out_form',
1331                 'in': 'view_picking_in_form',
1332                 'internal': 'view_picking_form',
1333             }
1334             message = type_list.get(pick.type, _('Document')) + " '" + (pick.name or '?') + "' "
1335             if pick.min_date:
1336                 msg= _(' for the ')+ datetime.strptime(pick.min_date, '%Y-%m-%d %H:%M:%S').strftime('%m/%d/%Y')
1337             state_list = {
1338                 'confirmed': _('is scheduled %s.') % msg,
1339                 'assigned': _('is ready to process.'),
1340                 'cancel': _('is cancelled.'),
1341                 'done': _('is done.'),
1342                 'auto': _('is waiting.'),
1343                 'draft': _('is in draft state.'),
1344             }
1345             res = data_obj.get_object_reference(cr, uid, 'stock', view_list.get(pick.type, 'view_picking_form'))
1346             context.update({'view_id': res and res[1] or False})
1347             message += state_list[pick.state]
1348             self.log(cr, uid, pick.id, message, context=context)
1349         return True
1350
1351 stock_picking()
1352
1353 class stock_production_lot(osv.osv):
1354
1355     def name_get(self, cr, uid, ids, context=None):
1356         if not ids:
1357             return []
1358         reads = self.read(cr, uid, ids, ['name', 'prefix', 'ref'], context)
1359         res = []
1360         for record in reads:
1361             name = record['name']
1362             prefix = record['prefix']
1363             if prefix:
1364                 name = prefix + '/' + name
1365             if record['ref']:
1366                 name = '%s [%s]' % (name, record['ref'])
1367             res.append((record['id'], name))
1368         return res
1369
1370     def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=100):
1371         args = args or []
1372         ids = []
1373         if name:
1374             ids = self.search(cr, uid, [('prefix', '=', name)] + args, limit=limit, context=context)
1375             if not ids:
1376                 ids = self.search(cr, uid, [('name', operator, name)] + args, limit=limit, context=context)
1377         else:
1378             ids = self.search(cr, uid, args, limit=limit, context=context)
1379         return self.name_get(cr, uid, ids, context)
1380
1381     _name = 'stock.production.lot'
1382     _description = 'Production lot'
1383
1384     def _get_stock(self, cr, uid, ids, field_name, arg, context=None):
1385         """ Gets stock of products for locations
1386         @return: Dictionary of values
1387         """
1388         if context is None:
1389             context = {}
1390         if 'location_id' not in context:
1391             locations = self.pool.get('stock.location').search(cr, uid, [('usage', '=', 'internal')], context=context)
1392         else:
1393             locations = context['location_id'] and [context['location_id']] or []
1394
1395         if isinstance(ids, (int, long)):
1396             ids = [ids]
1397
1398         res = {}.fromkeys(ids, 0.0)
1399         if locations:
1400             cr.execute('''select
1401                     prodlot_id,
1402                     sum(qty)
1403                 from
1404                     stock_report_prodlots
1405                 where
1406                     location_id IN %s and prodlot_id IN %s group by prodlot_id''',(tuple(locations),tuple(ids),))
1407             res.update(dict(cr.fetchall()))
1408
1409         return res
1410
1411     def _stock_search(self, cr, uid, obj, name, args, context=None):
1412         """ Searches Ids of products
1413         @return: Ids of locations
1414         """
1415         locations = self.pool.get('stock.location').search(cr, uid, [('usage', '=', 'internal')])
1416         cr.execute('''select
1417                 prodlot_id,
1418                 sum(qty)
1419             from
1420                 stock_report_prodlots
1421             where
1422                 location_id IN %s group by prodlot_id
1423             having  sum(qty) '''+ str(args[0][1]) + str(args[0][2]),(tuple(locations),))
1424         res = cr.fetchall()
1425         ids = [('id', 'in', map(lambda x: x[0], res))]
1426         return ids
1427
1428     _columns = {
1429         'name': fields.char('Production Lot', size=64, required=True, help="Unique production lot, will be displayed as: PREFIX/SERIAL [INT_REF]"),
1430         'ref': fields.char('Internal Reference', size=256, help="Internal reference number in case it differs from the manufacturer's serial number"),
1431         'prefix': fields.char('Prefix', size=64, help="Optional prefix to prepend when displaying this serial number: PREFIX/SERIAL [INT_REF]"),
1432         'product_id': fields.many2one('product.product', 'Product', required=True, domain=[('type', '<>', 'service')]),
1433         'date': fields.datetime('Creation Date', required=True),
1434         'stock_available': fields.function(_get_stock, fnct_search=_stock_search, type="float", string="Available", select=True,
1435             help="Current quantity of products with this Production Lot Number available in company warehouses",
1436             digits_compute=dp.get_precision('Product UoM')),
1437         'revisions': fields.one2many('stock.production.lot.revision', 'lot_id', 'Revisions'),
1438         'company_id': fields.many2one('res.company', 'Company', select=True),
1439         'move_ids': fields.one2many('stock.move', 'prodlot_id', 'Moves for this production lot', readonly=True),
1440     }
1441     _defaults = {
1442         'date': lambda *a: time.strftime('%Y-%m-%d %H:%M:%S'),
1443         'name': lambda x, y, z, c: x.pool.get('ir.sequence').get(y, z, 'stock.lot.serial'),
1444         'product_id': lambda x, y, z, c: c.get('product_id', False),
1445     }
1446     _sql_constraints = [
1447         ('name_ref_uniq', 'unique (name, ref)', 'The combination of serial number and internal reference must be unique !'),
1448     ]
1449     def action_traceability(self, cr, uid, ids, context=None):
1450         """ It traces the information of a product
1451         @param self: The object pointer.
1452         @param cr: A database cursor
1453         @param uid: ID of the user currently logged in
1454         @param ids: List of IDs selected
1455         @param context: A standard dictionary
1456         @return: A dictionary of values
1457         """
1458         value=self.pool.get('action.traceability').action_traceability(cr,uid,ids,context)
1459         return value
1460 stock_production_lot()
1461
1462 class stock_production_lot_revision(osv.osv):
1463     _name = 'stock.production.lot.revision'
1464     _description = 'Production lot revisions'
1465
1466     _columns = {
1467         'name': fields.char('Revision Name', size=64, required=True),
1468         'description': fields.text('Description'),
1469         'date': fields.date('Revision Date'),
1470         'indice': fields.char('Revision Number', size=16),
1471         'author_id': fields.many2one('res.users', 'Author'),
1472         'lot_id': fields.many2one('stock.production.lot', 'Production lot', select=True, ondelete='cascade'),
1473         'company_id': fields.related('lot_id','company_id',type='many2one',relation='res.company',string='Company', store=True, readonly=True),
1474     }
1475
1476     _defaults = {
1477         'author_id': lambda x, y, z, c: z,
1478         'date': time.strftime('%Y-%m-%d'),
1479     }
1480
1481 stock_production_lot_revision()
1482
1483 # ----------------------------------------------------
1484 # Move
1485 # ----------------------------------------------------
1486
1487 #
1488 # Fields:
1489 #   location_dest_id is only used for predicting futur stocks
1490 #
1491 class stock_move(osv.osv):
1492
1493     def _getSSCC(self, cr, uid, context=None):
1494         cr.execute('select id from stock_tracking where create_uid=%s order by id desc limit 1', (uid,))
1495         res = cr.fetchone()
1496         return (res and res[0]) or False
1497     _name = "stock.move"
1498     _description = "Stock Move"
1499     _order = 'date_expected desc, id'
1500     _log_create = False
1501
1502     def action_partial_move(self, cr, uid, ids, context=None):
1503         if context is None: context = {}
1504         if context.get('active_model') != self._name:
1505             context.update(active_ids=ids, active_model=self._name)
1506         partial_id = self.pool.get("stock.partial.move").create(
1507             cr, uid, {}, context=context)
1508         return {
1509             'name':_("Products to Process"),
1510             'view_mode': 'form',
1511             'view_id': False,
1512             'view_type': 'form',
1513             'res_model': 'stock.partial.move',
1514             'res_id': partial_id,
1515             'type': 'ir.actions.act_window',
1516             'nodestroy': True,
1517             'target': 'new',
1518             'domain': '[]',
1519             'context': context
1520         }
1521
1522
1523     def name_get(self, cr, uid, ids, context=None):
1524         res = []
1525         for line in self.browse(cr, uid, ids, context=context):
1526             res.append((line.id, (line.product_id.code or '/')+': '+line.location_id.name+' > '+line.location_dest_id.name))
1527         return res
1528
1529     def _check_tracking(self, cr, uid, ids, context=None):
1530         """ Checks if production lot is assigned to stock move or not.
1531         @return: True or False
1532         """
1533         for move in self.browse(cr, uid, ids, context=context):
1534             if not move.prodlot_id and \
1535                (move.state == 'done' and \
1536                ( \
1537                    (move.product_id.track_production and move.location_id.usage == 'production') or \
1538                    (move.product_id.track_production and move.location_dest_id.usage == 'production') or \
1539                    (move.product_id.track_incoming and move.location_id.usage == 'supplier') or \
1540                    (move.product_id.track_outgoing and move.location_dest_id.usage == 'customer') \
1541                )):
1542                 return False
1543         return True
1544
1545     def _check_product_lot(self, cr, uid, ids, context=None):
1546         """ Checks whether move is done or not and production lot is assigned to that move.
1547         @return: True or False
1548         """
1549         for move in self.browse(cr, uid, ids, context=context):
1550             if move.prodlot_id and move.state == 'done' and (move.prodlot_id.product_id.id != move.product_id.id):
1551                 return False
1552         return True
1553
1554     _columns = {
1555         'name': fields.char('Name', size=250, required=True, select=True),
1556         'priority': fields.selection([('0', 'Not urgent'), ('1', 'Urgent')], 'Priority'),
1557         'create_date': fields.datetime('Creation Date', readonly=True, select=True),
1558         'date': fields.datetime('Date', required=True, select=True, help="Move date: scheduled date until move is done, then date of actual move processing", states={'done': [('readonly', True)]}),
1559         'date_expected': fields.datetime('Scheduled Date', states={'done': [('readonly', True)]},required=True, select=True, help="Scheduled date for the processing of this move"),
1560         'product_id': fields.many2one('product.product', 'Product', required=True, select=True, domain=[('type','<>','service')],states={'done': [('readonly', True)]}),
1561
1562         'product_qty': fields.float('Quantity', digits_compute=dp.get_precision('Product UoM'), required=True,states={'done': [('readonly', True)]}),
1563         'product_uom': fields.many2one('product.uom', 'Unit of Measure', required=True,states={'done': [('readonly', True)]}),
1564         'product_uos_qty': fields.float('Quantity (UOS)', digits_compute=dp.get_precision('Product UoM'), states={'done': [('readonly', True)]}),
1565         'product_uos': fields.many2one('product.uom', 'Product UOS', states={'done': [('readonly', True)]}),
1566         'product_packaging': fields.many2one('product.packaging', 'Packaging', help="It specifies attributes of packaging like type, quantity of packaging,etc."),
1567
1568         'location_id': fields.many2one('stock.location', 'Source Location', required=True, select=True,states={'done': [('readonly', True)]}, help="Sets a location if you produce at a fixed location. This can be a partner location if you subcontract the manufacturing operations."),
1569         'location_dest_id': fields.many2one('stock.location', 'Destination Location', required=True,states={'done': [('readonly', True)]}, select=True, help="Location where the system will stock the finished products."),
1570         'address_id': fields.many2one('res.partner.address', 'Destination Address ', states={'done': [('readonly', True)]}, help="Optional address where goods are to be delivered, specifically used for allotment"),
1571
1572         'prodlot_id': fields.many2one('stock.production.lot', 'Production Lot', states={'done': [('readonly', True)]}, help="Production lot is used to put a serial number on the production", select=True),
1573         'tracking_id': fields.many2one('stock.tracking', 'Pack', select=True, states={'done': [('readonly', True)]}, help="Logistical shipping unit: pallet, box, pack ..."),
1574
1575         'auto_validate': fields.boolean('Auto Validate'),
1576
1577         'move_dest_id': fields.many2one('stock.move', 'Destination Move', help="Optional: next stock move when chaining them", select=True),
1578         'move_history_ids': fields.many2many('stock.move', 'stock_move_history_ids', 'parent_id', 'child_id', 'Move History (child moves)'),
1579         'move_history_ids2': fields.many2many('stock.move', 'stock_move_history_ids', 'child_id', 'parent_id', 'Move History (parent moves)'),
1580         'picking_id': fields.many2one('stock.picking', 'Reference', select=True,states={'done': [('readonly', True)]}),
1581         'note': fields.text('Notes'),
1582         'state': fields.selection([('draft', 'New'), ('waiting', 'Waiting Another Move'), ('confirmed', 'Waiting Availability'), ('assigned', 'Available'), ('done', 'Done'), ('cancel', 'Cancelled')], 'State', readonly=True, select=True,
1583               help='When the stock move is created it is in the \'Draft\' state.\n After that, it is set to \'Not Available\' state if the scheduler did not find the products.\n When products are reserved it is set to \'Available\'.\n When the picking is done the state is \'Done\'.\
1584               \nThe state is \'Waiting\' if the move is waiting for another one.'),
1585         'price_unit': fields.float('Unit Price', digits_compute= dp.get_precision('Account'), help="Technical field used to record the product cost set by the user during a picking confirmation (when average price costing method is used)"),
1586         'price_currency_id': fields.many2one('res.currency', 'Currency for average price', help="Technical field used to record the currency chosen by the user during a picking confirmation (when average price costing method is used)"),
1587         'company_id': fields.many2one('res.company', 'Company', required=True, select=True),
1588         'partner_id': fields.related('picking_id','address_id','partner_id',type='many2one', relation="res.partner", string="Partner", store=True, select=True),
1589         'backorder_id': fields.related('picking_id','backorder_id',type='many2one', relation="stock.picking", string="Back Order", select=True),
1590         'origin': fields.related('picking_id','origin',type='char', size=64, relation="stock.picking", string="Origin", store=True),
1591
1592         # used for colors in tree views:
1593         'scrapped': fields.related('location_dest_id','scrap_location',type='boolean',relation='stock.location',string='Scrapped', readonly=True),
1594     }
1595     def _check_location(self, cr, uid, ids, context=None):
1596         for record in self.browse(cr, uid, ids, context=context):
1597             if (record.state=='done') and (record.location_dest_id.usage == 'view' or record.location_id.usage == 'view'):
1598                 return False
1599         return True
1600
1601     _constraints = [
1602         (_check_tracking,
1603             'You must assign a production lot for this product',
1604             ['prodlot_id']),
1605         (_check_location, 'You can not move products from or to a location of the type view.',
1606             ['location_id','location_dest_id']),
1607         (_check_product_lot,
1608             'You try to assign a lot which is not from the same product',
1609             ['prodlot_id'])]
1610
1611     def _default_location_destination(self, cr, uid, context=None):
1612         """ Gets default address of partner for destination location
1613         @return: Address id or False
1614         """
1615         mod_obj = self.pool.get('ir.model.data')
1616         picking_type = context.get('picking_type')
1617         location_id = False
1618
1619         if context is None:
1620             context = {}
1621         if context.get('move_line', []):
1622             if context['move_line'][0]:
1623                 if isinstance(context['move_line'][0], (tuple, list)):
1624                     location_id = context['move_line'][0][2] and context['move_line'][0][2].get('location_dest_id',False)
1625                 else:
1626                     move_list = self.pool.get('stock.move').read(cr, uid, context['move_line'][0], ['location_dest_id'])
1627                     location_id = move_list and move_list['location_dest_id'][0] or False
1628         elif context.get('address_out_id', False):
1629             property_out = self.pool.get('res.partner.address').browse(cr, uid, context['address_out_id'], context).partner_id.property_stock_customer
1630             location_id = property_out and property_out.id or False
1631         else:
1632             location_xml_id = False
1633             if picking_type == 'in':
1634                 location_xml_id = 'stock_location_stock'
1635             elif picking_type == 'out':
1636                 location_xml_id = 'stock_location_customers'
1637             if location_xml_id:
1638                 location_model, location_id = mod_obj.get_object_reference(cr, uid, 'stock', location_xml_id)
1639         return location_id
1640
1641     def _default_location_source(self, cr, uid, context=None):
1642         """ Gets default address of partner for source location
1643         @return: Address id or False
1644         """
1645         mod_obj = self.pool.get('ir.model.data')
1646         picking_type = context.get('picking_type')
1647         location_id = False
1648
1649         if context is None:
1650             context = {}
1651         if context.get('move_line', []):
1652             try:
1653                 location_id = context['move_line'][0][2]['location_id']
1654             except:
1655                 pass
1656         elif context.get('address_in_id', False):
1657             part_obj_add = self.pool.get('res.partner.address').browse(cr, uid, context['address_in_id'], context=context)
1658             if part_obj_add.partner_id:
1659                 location_id = part_obj_add.partner_id.property_stock_supplier.id
1660         else:
1661             location_xml_id = False
1662             if picking_type == 'in':
1663                 location_xml_id = 'stock_location_suppliers'
1664             elif picking_type == 'out':
1665                 location_xml_id = 'stock_location_stock'
1666             if location_xml_id:
1667                 location_model, location_id = mod_obj.get_object_reference(cr, uid, 'stock', location_xml_id)
1668         return location_id
1669
1670     _defaults = {
1671         'location_id': _default_location_source,
1672         'location_dest_id': _default_location_destination,
1673         'state': 'draft',
1674         'priority': '1',
1675         'product_qty': 1.0,
1676         'scrapped' :  False,
1677         'date': lambda *a: time.strftime('%Y-%m-%d %H:%M:%S'),
1678         'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'stock.move', context=c),
1679         'date_expected': lambda *a: time.strftime('%Y-%m-%d %H:%M:%S'),
1680     }
1681
1682     def write(self, cr, uid, ids, vals, context=None):
1683         if isinstance(ids, (int, long)):
1684             ids = [ids]
1685         if uid != 1:
1686             frozen_fields = set(['product_qty', 'product_uom', 'product_uos_qty', 'product_uos', 'location_id', 'location_dest_id', 'product_id'])
1687             for move in self.browse(cr, uid, ids, context=context):
1688                 if move.state == 'done':
1689                     if frozen_fields.intersection(vals):
1690                         raise osv.except_osv(_('Operation forbidden'),
1691                                              _('Quantities, UoMs, Products and Locations cannot be modified on stock moves that have already been processed (except by the Administrator)'))
1692         return  super(stock_move, self).write(cr, uid, ids, vals, context=context)
1693
1694     def copy(self, cr, uid, id, default=None, context=None):
1695         if default is None:
1696             default = {}
1697         default = default.copy()
1698         default.update({'move_history_ids2': [], 'move_history_ids': []})
1699         return super(stock_move, self).copy(cr, uid, id, default, context=context)
1700
1701     def _auto_init(self, cursor, context=None):
1702         res = super(stock_move, self)._auto_init(cursor, context=context)
1703         cursor.execute('SELECT indexname \
1704                 FROM pg_indexes \
1705                 WHERE indexname = \'stock_move_location_id_location_dest_id_product_id_state\'')
1706         if not cursor.fetchone():
1707             cursor.execute('CREATE INDEX stock_move_location_id_location_dest_id_product_id_state \
1708                     ON stock_move (location_id, location_dest_id, product_id, state)')
1709         return res
1710
1711     def onchange_lot_id(self, cr, uid, ids, prodlot_id=False, product_qty=False,
1712                         loc_id=False, product_id=False, uom_id=False, context=None):
1713         """ On change of production lot gives a warning message.
1714         @param prodlot_id: Changed production lot id
1715         @param product_qty: Quantity of product
1716         @param loc_id: Location id
1717         @param product_id: Product id
1718         @return: Warning message
1719         """
1720         if not prodlot_id or not loc_id:
1721             return {}
1722         ctx = context and context.copy() or {}
1723         ctx['location_id'] = loc_id
1724         ctx.update({'raise-exception': True})
1725         uom_obj = self.pool.get('product.uom')
1726         product_obj = self.pool.get('product.product')
1727         product_uom = product_obj.browse(cr, uid, product_id, context=ctx).uom_id
1728         prodlot = self.pool.get('stock.production.lot').browse(cr, uid, prodlot_id, context=ctx)
1729         location = self.pool.get('stock.location').browse(cr, uid, loc_id, context=ctx)
1730         uom = uom_obj.browse(cr, uid, uom_id, context=ctx)
1731         amount_actual = uom_obj._compute_qty_obj(cr, uid, product_uom, prodlot.stock_available, uom, context=ctx)
1732         warning = {}
1733         if (location.usage == 'internal') and (product_qty > (amount_actual or 0.0)):
1734             warning = {
1735                 'title': _('Insufficient Stock in Lot !'),
1736                 'message': _('You are moving %.2f %s products but only %.2f %s available in this lot.') % (product_qty, uom.name, amount_actual, uom.name)
1737             }
1738         return {'warning': warning}
1739
1740     def onchange_quantity(self, cr, uid, ids, product_id, product_qty,
1741                           product_uom, product_uos):
1742         """ On change of product quantity finds UoM and UoS quantities
1743         @param product_id: Product id
1744         @param product_qty: Changed Quantity of product
1745         @param product_uom: Unit of measure of product
1746         @param product_uos: Unit of sale of product
1747         @return: Dictionary of values
1748         """
1749         result = {
1750                   'product_uos_qty': 0.00
1751           }
1752
1753         if (not product_id) or (product_qty <=0.0):
1754             return {'value': result}
1755
1756         product_obj = self.pool.get('product.product')
1757         uos_coeff = product_obj.read(cr, uid, product_id, ['uos_coeff'])
1758
1759         if product_uos and product_uom and (product_uom != product_uos):
1760             result['product_uos_qty'] = product_qty * uos_coeff['uos_coeff']
1761         else:
1762             result['product_uos_qty'] = product_qty
1763
1764         return {'value': result}
1765
1766     def onchange_uos_quantity(self, cr, uid, ids, product_id, product_uos_qty,
1767                           product_uos, product_uom):
1768         """ On change of product quantity finds UoM and UoS quantities
1769         @param product_id: Product id
1770         @param product_uos_qty: Changed UoS Quantity of product
1771         @param product_uom: Unit of measure of product
1772         @param product_uos: Unit of sale of product
1773         @return: Dictionary of values
1774         """
1775         result = {
1776                   'product_qty': 0.00
1777           }
1778
1779         if (not product_id) or (product_uos_qty <=0.0):
1780             return {'value': result}
1781
1782         product_obj = self.pool.get('product.product')
1783         uos_coeff = product_obj.read(cr, uid, product_id, ['uos_coeff'])
1784
1785         if product_uos and product_uom and (product_uom != product_uos):
1786             result['product_qty'] = product_uos_qty / uos_coeff['uos_coeff']
1787         else:
1788             result['product_qty'] = product_uos_qty
1789
1790         return {'value': result}
1791
1792     def onchange_product_id(self, cr, uid, ids, prod_id=False, loc_id=False,
1793                             loc_dest_id=False, address_id=False):
1794         """ On change of product id, if finds UoM, UoS, quantity and UoS quantity.
1795         @param prod_id: Changed Product id
1796         @param loc_id: Source location id
1797         @param loc_dest_id: Destination location id
1798         @param address_id: Address id of partner
1799         @return: Dictionary of values
1800         """
1801         if not prod_id:
1802             return {}
1803         lang = False
1804         if address_id:
1805             addr_rec = self.pool.get('res.partner.address').browse(cr, uid, address_id)
1806             if addr_rec:
1807                 lang = addr_rec.partner_id and addr_rec.partner_id.lang or False
1808         ctx = {'lang': lang}
1809
1810         product = self.pool.get('product.product').browse(cr, uid, [prod_id], context=ctx)[0]
1811         uos_id  = product.uos_id and product.uos_id.id or False
1812         result = {
1813             'product_uom': product.uom_id.id,
1814             'product_uos': uos_id,
1815             'product_qty': 1.00,
1816             'product_uos_qty' : self.pool.get('stock.move').onchange_quantity(cr, uid, ids, prod_id, 1.00, product.uom_id.id, uos_id)['value']['product_uos_qty']
1817         }
1818         if not ids:
1819             result['name'] = product.partner_ref
1820         if loc_id:
1821             result['location_id'] = loc_id
1822         if loc_dest_id:
1823             result['location_dest_id'] = loc_dest_id
1824         return {'value': result}
1825
1826     def onchange_date(self, cr, uid, ids, date, date_expected, context=None):
1827         """ On change of Scheduled Date gives a Move date.
1828         @param date_expected: Scheduled Date
1829         @param date: Move Date
1830         @return: Move Date
1831         """
1832         if not date_expected:
1833             date_expected = time.strftime('%Y-%m-%d %H:%M:%S')
1834         return {'value':{'date': date_expected}}
1835
1836     def _chain_compute(self, cr, uid, moves, context=None):
1837         """ Finds whether the location has chained location type or not.
1838         @param moves: Stock moves
1839         @return: Dictionary containing destination location with chained location type.
1840         """
1841         result = {}
1842         for m in moves:
1843             dest = self.pool.get('stock.location').chained_location_get(
1844                 cr,
1845                 uid,
1846                 m.location_dest_id,
1847                 m.picking_id and m.picking_id.address_id and m.picking_id.address_id.partner_id,
1848                 m.product_id,
1849                 context
1850             )
1851             if dest:
1852                 if dest[1] == 'transparent':
1853                     newdate = (datetime.strptime(m.date, '%Y-%m-%d %H:%M:%S') + relativedelta(days=dest[2] or 0)).strftime('%Y-%m-%d')
1854                     self.write(cr, uid, [m.id], {
1855                         'date': newdate,
1856                         'location_dest_id': dest[0].id})
1857                     if m.picking_id and (dest[3] or dest[5]):
1858                         self.pool.get('stock.picking').write(cr, uid, [m.picking_id.id], {
1859                             'stock_journal_id': dest[3] or m.picking_id.stock_journal_id.id,
1860                             'type': dest[5] or m.picking_id.type
1861                         }, context=context)
1862                     m.location_dest_id = dest[0]
1863                     res2 = self._chain_compute(cr, uid, [m], context=context)
1864                     for pick_id in res2.keys():
1865                         result.setdefault(pick_id, [])
1866                         result[pick_id] += res2[pick_id]
1867                 else:
1868                     result.setdefault(m.picking_id, [])
1869                     result[m.picking_id].append( (m, dest) )
1870         return result
1871
1872     def _prepare_chained_picking(self, cr, uid, picking_name, picking, picking_type, moves_todo, context=None):
1873         """Prepare the definition (values) to create a new chained picking.
1874
1875            :param str picking_name: desired new picking name
1876            :param browse_record picking: source picking (being chained to)
1877            :param str picking_type: desired new picking type
1878            :param list moves_todo: specification of the stock moves to be later included in this
1879                picking, in the form::
1880
1881                    [[move, (dest_location, auto_packing, chained_delay, chained_journal,
1882                                   chained_company_id, chained_picking_type)],
1883                     ...
1884                    ]
1885
1886                See also :meth:`stock_location.chained_location_get`.
1887         """
1888         res_company = self.pool.get('res.company')
1889         return {
1890                     'name': picking_name,
1891                     'origin': tools.ustr(picking.origin or ''),
1892                     'type': picking_type,
1893                     'note': picking.note,
1894                     'move_type': picking.move_type,
1895                     'auto_picking': moves_todo[0][1][1] == 'auto',
1896                     'stock_journal_id': moves_todo[0][1][3],
1897                     'company_id': moves_todo[0][1][4] or res_company._company_default_get(cr, uid, 'stock.company', context=context),
1898                     'address_id': picking.address_id.id,
1899                     'invoice_state': 'none',
1900                     'date': picking.date,
1901                 }
1902
1903     def _create_chained_picking(self, cr, uid, picking_name, picking, picking_type, moves_todo, context=None):
1904         picking_obj = self.pool.get('stock.picking')
1905         return picking_obj.create(cr, uid, self._prepare_chained_picking(cr, uid, picking_name, picking, picking_type, moves_todo, context=context))
1906
1907     def create_chained_picking(self, cr, uid, moves, context=None):
1908         res_obj = self.pool.get('res.company')
1909         location_obj = self.pool.get('stock.location')
1910         move_obj = self.pool.get('stock.move')
1911         wf_service = netsvc.LocalService("workflow")
1912         new_moves = []
1913         if context is None:
1914             context = {}
1915         seq_obj = self.pool.get('ir.sequence')
1916         for picking, todo in self._chain_compute(cr, uid, moves, context=context).items():
1917             ptype = todo[0][1][5] and todo[0][1][5] or location_obj.picking_type_get(cr, uid, todo[0][0].location_dest_id, todo[0][1][0])
1918             if picking:
1919                 # name of new picking according to its type
1920                 new_pick_name = seq_obj.get(cr, uid, 'stock.picking.' + ptype)
1921                 pickid = self._create_chained_picking(cr, uid, new_pick_name, picking, ptype, todo, context=context)
1922                 # Need to check name of old picking because it always considers picking as "OUT" when created from Sale Order
1923                 old_ptype = location_obj.picking_type_get(cr, uid, picking.move_lines[0].location_id, picking.move_lines[0].location_dest_id)
1924                 if old_ptype != picking.type:
1925                     old_pick_name = seq_obj.get(cr, uid, 'stock.picking.' + old_ptype)
1926                     self.pool.get('stock.picking').write(cr, uid, [picking.id], {'name': old_pick_name}, context=context)
1927             else:
1928                 pickid = False
1929             for move, (loc, dummy, delay, dummy, company_id, ptype) in todo:
1930                 new_id = move_obj.copy(cr, uid, move.id, {
1931                     'location_id': move.location_dest_id.id,
1932                     'location_dest_id': loc.id,
1933                     'date_moved': time.strftime('%Y-%m-%d'),
1934                     'picking_id': pickid,
1935                     'state': 'waiting',
1936                     'company_id': company_id or res_obj._company_default_get(cr, uid, 'stock.company', context=context)  ,
1937                     'move_history_ids': [],
1938                     'date': (datetime.strptime(move.date, '%Y-%m-%d %H:%M:%S') + relativedelta(days=delay or 0)).strftime('%Y-%m-%d'),
1939                     'move_history_ids2': []}
1940                 )
1941                 move_obj.write(cr, uid, [move.id], {
1942                     'move_dest_id': new_id,
1943                     'move_history_ids': [(4, new_id)]
1944                 })
1945                 new_moves.append(self.browse(cr, uid, [new_id])[0])
1946             if pickid:
1947                 wf_service.trg_validate(uid, 'stock.picking', pickid, 'button_confirm', cr)
1948         if new_moves:
1949             new_moves += self.create_chained_picking(cr, uid, new_moves, context)
1950         return new_moves
1951
1952     def action_confirm(self, cr, uid, ids, context=None):
1953         """ Confirms stock move.
1954         @return: List of ids.
1955         """
1956         moves = self.browse(cr, uid, ids, context=context)
1957         self.write(cr, uid, ids, {'state': 'confirmed'})
1958         self.create_chained_picking(cr, uid, moves, context)
1959         return []
1960
1961     def action_assign(self, cr, uid, ids, *args):
1962         """ Changes state to confirmed or waiting.
1963         @return: List of values
1964         """
1965         todo = []
1966         for move in self.browse(cr, uid, ids):
1967             if move.state in ('confirmed', 'waiting'):
1968                 todo.append(move.id)
1969         res = self.check_assign(cr, uid, todo)
1970         return res
1971
1972     def force_assign(self, cr, uid, ids, context=None):
1973         """ Changes the state to assigned.
1974         @return: True
1975         """
1976         self.write(cr, uid, ids, {'state': 'assigned'})
1977         return True
1978
1979     def cancel_assign(self, cr, uid, ids, context=None):
1980         """ Changes the state to confirmed.
1981         @return: True
1982         """
1983         self.write(cr, uid, ids, {'state': 'confirmed'})
1984
1985         # fix for bug lp:707031
1986         # called write of related picking because changing move availability does
1987         # not trigger workflow of picking in order to change the state of picking
1988         wf_service = netsvc.LocalService('workflow')
1989         for move in self.browse(cr, uid, ids, context):
1990             if move.picking_id:
1991                 wf_service.trg_write(uid, 'stock.picking', move.picking_id.id, cr)
1992         return True
1993
1994     #
1995     # Duplicate stock.move
1996     #
1997     def check_assign(self, cr, uid, ids, context=None):
1998         """ Checks the product type and accordingly writes the state.
1999         @return: No. of moves done
2000         """
2001         done = []
2002         count = 0
2003         pickings = {}
2004         if context is None:
2005             context = {}
2006         for move in self.browse(cr, uid, ids, context=context):
2007             if move.product_id.type == 'consu' or move.location_id.usage == 'supplier':
2008                 if move.state in ('confirmed', 'waiting'):
2009                     done.append(move.id)
2010                 pickings[move.picking_id.id] = 1
2011                 continue
2012             if move.state in ('confirmed', 'waiting'):
2013                 # Important: we must pass lock=True to _product_reserve() to avoid race conditions and double reservations
2014                 res = self.pool.get('stock.location')._product_reserve(cr, uid, [move.location_id.id], move.product_id.id, move.product_qty, {'uom': move.product_uom.id}, lock=True)
2015                 if res:
2016                     #_product_available_test depends on the next status for correct functioning
2017                     #the test does not work correctly if the same product occurs multiple times
2018                     #in the same order. This is e.g. the case when using the button 'split in two' of
2019                     #the stock outgoing form
2020                     self.write(cr, uid, [move.id], {'state':'assigned'})
2021                     done.append(move.id)
2022                     pickings[move.picking_id.id] = 1
2023                     r = res.pop(0)
2024                     cr.execute('update stock_move set location_id=%s, product_qty=%s where id=%s', (r[1], r[0], move.id))
2025
2026                     while res:
2027                         r = res.pop(0)
2028                         move_id = self.copy(cr, uid, move.id, {'product_qty': r[0], 'location_id': r[1]})
2029                         done.append(move_id)
2030         if done:
2031             count += len(done)
2032             self.write(cr, uid, done, {'state': 'assigned'})
2033
2034         if count:
2035             for pick_id in pickings:
2036                 wf_service = netsvc.LocalService("workflow")
2037                 wf_service.trg_write(uid, 'stock.picking', pick_id, cr)
2038         return count
2039
2040     def setlast_tracking(self, cr, uid, ids, context=None):
2041         tracking_obj = self.pool.get('stock.tracking')
2042         picking = self.browse(cr, uid, ids, context=context)[0].picking_id
2043         if picking:
2044             last_track = [line.tracking_id.id for line in picking.move_lines if line.tracking_id]
2045             if not last_track:
2046                 last_track = tracking_obj.create(cr, uid, {}, context=context)
2047             else:
2048                 last_track.sort()
2049                 last_track = last_track[-1]
2050             self.write(cr, uid, ids, {'tracking_id': last_track})
2051         return True
2052
2053     #
2054     # Cancel move => cancel others move and pickings
2055     #
2056     def action_cancel(self, cr, uid, ids, context=None):
2057         """ Cancels the moves and if all moves are cancelled it cancels the picking.
2058         @return: True
2059         """
2060         if not len(ids):
2061             return True
2062         if context is None:
2063             context = {}
2064         pickings = {}
2065         for move in self.browse(cr, uid, ids, context=context):
2066             if move.state in ('confirmed', 'waiting', 'assigned', 'draft'):
2067                 if move.picking_id:
2068                     pickings[move.picking_id.id] = True
2069             if move.move_dest_id and move.move_dest_id.state == 'waiting':
2070                 self.write(cr, uid, [move.move_dest_id.id], {'state': 'assigned'})
2071                 if context.get('call_unlink',False) and move.move_dest_id.picking_id:
2072                     wf_service = netsvc.LocalService("workflow")
2073                     wf_service.trg_write(uid, 'stock.picking', move.move_dest_id.picking_id.id, cr)
2074         self.write(cr, uid, ids, {'state': 'cancel', 'move_dest_id': False})
2075         if not context.get('call_unlink',False):
2076             for pick in self.pool.get('stock.picking').browse(cr, uid, pickings.keys()):
2077                 if all(move.state == 'cancel' for move in pick.move_lines):
2078                     self.pool.get('stock.picking').write(cr, uid, [pick.id], {'state': 'cancel'})
2079
2080         wf_service = netsvc.LocalService("workflow")
2081         for id in ids:
2082             wf_service.trg_trigger(uid, 'stock.move', id, cr)
2083         return True
2084
2085     def _get_accounting_data_for_valuation(self, cr, uid, move, context=None):
2086         """
2087         Return the accounts and journal to use to post Journal Entries for the real-time
2088         valuation of the move.
2089
2090         :param context: context dictionary that can explicitly mention the company to consider via the 'force_company' key
2091         :raise: osv.except_osv() is any mandatory account or journal is not defined.
2092         """
2093         product_obj=self.pool.get('product.product')
2094         accounts = product_obj.get_product_accounts(cr, uid, move.product_id.id, context)
2095         if move.location_id.valuation_out_account_id:
2096             acc_src = move.location_id.valuation_out_account_id.id
2097         else:
2098             acc_src = accounts['stock_account_input']
2099
2100         if move.location_dest_id.valuation_in_account_id:
2101             acc_dest = move.location_dest_id.valuation_in_account_id.id
2102         else:
2103             acc_dest = accounts['stock_account_output']
2104
2105         acc_valuation = accounts.get('property_stock_valuation_account_id', False)
2106         journal_id = accounts['stock_journal']
2107
2108         if acc_dest == acc_valuation:
2109             raise osv.except_osv(_('Error!'),  _('Can not create Journal Entry, Output Account defined on this product and Valuation account on category of this product are same.'))
2110
2111         if acc_src == acc_valuation:
2112             raise osv.except_osv(_('Error!'),  _('Can not create Journal Entry, Input Account defined on this product and Valuation account on category of this product are same.'))
2113
2114         if not acc_src:
2115             raise osv.except_osv(_('Error!'),  _('There is no stock input account defined for this product or its category: "%s" (id: %d)') % \
2116                                     (move.product_id.name, move.product_id.id,))
2117         if not acc_dest:
2118             raise osv.except_osv(_('Error!'),  _('There is no stock output account defined for this product or its category: "%s" (id: %d)') % \
2119                                     (move.product_id.name, move.product_id.id,))
2120         if not journal_id:
2121             raise osv.except_osv(_('Error!'), _('There is no journal defined on the product category: "%s" (id: %d)') % \
2122                                     (move.product_id.categ_id.name, move.product_id.categ_id.id,))
2123         if not acc_valuation:
2124             raise osv.except_osv(_('Error!'), _('There is no inventory Valuation account defined on the product category: "%s" (id: %d)') % \
2125                                     (move.product_id.categ_id.name, move.product_id.categ_id.id,))
2126         return journal_id, acc_src, acc_dest, acc_valuation
2127
2128     def _get_reference_accounting_values_for_valuation(self, cr, uid, move, context=None):
2129         """
2130         Return the reference amount and reference currency representing the inventory valuation for this move.
2131         These reference values should possibly be converted before being posted in Journals to adapt to the primary
2132         and secondary currencies of the relevant accounts.
2133         """
2134         product_uom_obj = self.pool.get('product.uom')
2135
2136         # by default the reference currency is that of the move's company
2137         reference_currency_id = move.company_id.currency_id.id
2138
2139         default_uom = move.product_id.uom_id.id
2140         qty = product_uom_obj._compute_qty(cr, uid, move.product_uom.id, move.product_qty, default_uom)
2141
2142         # if product is set to average price and a specific value was entered in the picking wizard,
2143         # we use it
2144         if move.product_id.cost_method == 'average' and move.price_unit:
2145             reference_amount = qty * move.price_unit
2146             reference_currency_id = move.price_currency_id.id or reference_currency_id
2147
2148         # Otherwise we default to the company's valuation price type, considering that the values of the
2149         # valuation field are expressed in the default currency of the move's company.
2150         else:
2151             if context is None:
2152                 context = {}
2153             currency_ctx = dict(context, currency_id = move.company_id.currency_id.id)
2154             amount_unit = move.product_id.price_get('standard_price', context=currency_ctx)[move.product_id.id]
2155             reference_amount = amount_unit * qty or 1.0
2156
2157         return reference_amount, reference_currency_id
2158
2159
2160     def _create_product_valuation_moves(self, cr, uid, move, context=None):
2161         """
2162         Generate the appropriate accounting moves if the product being moves is subject
2163         to real_time valuation tracking, and the source or destination location is
2164         a transit location or is outside of the company.
2165         """
2166         if move.product_id.valuation == 'real_time': # FIXME: product valuation should perhaps be a property?
2167             if context is None:
2168                 context = {}
2169             src_company_ctx = dict(context,force_company=move.location_id.company_id.id)
2170             dest_company_ctx = dict(context,force_company=move.location_dest_id.company_id.id)
2171             account_moves = []
2172             # Outgoing moves (or cross-company output part)
2173             if move.location_id.company_id \
2174                 and (move.location_id.usage == 'internal' and move.location_dest_id.usage != 'internal'\
2175                      or move.location_id.company_id != move.location_dest_id.company_id):
2176                 journal_id, acc_src, acc_dest, acc_valuation = self._get_accounting_data_for_valuation(cr, uid, move, src_company_ctx)
2177                 reference_amount, reference_currency_id = self._get_reference_accounting_values_for_valuation(cr, uid, move, src_company_ctx)
2178                 account_moves += [(journal_id, self._create_account_move_line(cr, uid, move, acc_valuation, acc_dest, reference_amount, reference_currency_id, context))]
2179
2180             # Incoming moves (or cross-company input part)
2181             if move.location_dest_id.company_id \
2182                 and (move.location_id.usage != 'internal' and move.location_dest_id.usage == 'internal'\
2183                      or move.location_id.company_id != move.location_dest_id.company_id):
2184                 journal_id, acc_src, acc_dest, acc_valuation = self._get_accounting_data_for_valuation(cr, uid, move, dest_company_ctx)
2185                 reference_amount, reference_currency_id = self._get_reference_accounting_values_for_valuation(cr, uid, move, src_company_ctx)
2186                 account_moves += [(journal_id, self._create_account_move_line(cr, uid, move, acc_src, acc_valuation, reference_amount, reference_currency_id, context))]
2187
2188             move_obj = self.pool.get('account.move')
2189             for j_id, move_lines in account_moves:
2190                 move_obj.create(cr, uid,
2191                         {
2192                          'journal_id': j_id,
2193                          'line_id': move_lines,
2194                          'ref': move.picking_id and move.picking_id.name})
2195
2196
2197     def action_done(self, cr, uid, ids, context=None):
2198         """ Makes the move done and if all moves are done, it will finish the picking.
2199         @return:
2200         """
2201         picking_ids = []
2202         move_ids = []
2203         wf_service = netsvc.LocalService("workflow")
2204         if context is None:
2205             context = {}
2206
2207         todo = []
2208         for move in self.browse(cr, uid, ids, context=context):
2209             if move.state=="draft":
2210                 todo.append(move.id)
2211         if todo:
2212             self.action_confirm(cr, uid, todo, context=context)
2213             todo = []
2214
2215         for move in self.browse(cr, uid, ids, context=context):
2216             if move.state in ['done','cancel']:
2217                 continue
2218             move_ids.append(move.id)
2219
2220             if move.picking_id:
2221                 picking_ids.append(move.picking_id.id)
2222             if move.move_dest_id.id and (move.state != 'done'):
2223                 self.write(cr, uid, [move.id], {'move_history_ids': [(4, move.move_dest_id.id)]})
2224                 #cr.execute('insert into stock_move_history_ids (parent_id,child_id) values (%s,%s)', (move.id, move.move_dest_id.id))
2225                 if move.move_dest_id.state in ('waiting', 'confirmed'):
2226                     self.force_assign(cr, uid, [move.move_dest_id.id], context=context)
2227                     if move.move_dest_id.picking_id:
2228                         wf_service.trg_write(uid, 'stock.picking', move.move_dest_id.picking_id.id, cr)
2229                     if move.move_dest_id.auto_validate:
2230                         self.action_done(cr, uid, [move.move_dest_id.id], context=context)
2231
2232             self._create_product_valuation_moves(cr, uid, move, context=context)
2233             if move.state not in ('confirmed','done','assigned'):
2234                 todo.append(move.id)
2235
2236         if todo:
2237             self.action_confirm(cr, uid, todo, context=context)
2238
2239         self.write(cr, uid, move_ids, {'state': 'done', 'date': time.strftime('%Y-%m-%d %H:%M:%S')}, context=context)
2240         for id in move_ids:
2241              wf_service.trg_trigger(uid, 'stock.move', id, cr)
2242
2243         for pick_id in picking_ids:
2244             wf_service.trg_write(uid, 'stock.picking', pick_id, cr)
2245
2246         return True
2247
2248     def _create_account_move_line(self, cr, uid, move, src_account_id, dest_account_id, reference_amount, reference_currency_id, context=None):
2249         """
2250         Generate the account.move.line values to post to track the stock valuation difference due to the
2251         processing of the given stock move.
2252         """
2253         # prepare default values considering that the destination accounts have the reference_currency_id as their main currency
2254         partner_id = (move.picking_id.address_id and move.picking_id.address_id.partner_id and move.picking_id.address_id.partner_id.id) or False
2255         debit_line_vals = {
2256                     'name': move.name,
2257                     'product_id': move.product_id and move.product_id.id or False,
2258                     'quantity': move.product_qty,
2259                     'ref': move.picking_id and move.picking_id.name or False,
2260                     'date': time.strftime('%Y-%m-%d'),
2261                     'partner_id': partner_id,
2262                     'debit': reference_amount,
2263                     'account_id': dest_account_id,
2264         }
2265         credit_line_vals = {
2266                     'name': move.name,
2267                     'product_id': move.product_id and move.product_id.id or False,
2268                     'quantity': move.product_qty,
2269                     'ref': move.picking_id and move.picking_id.name or False,
2270                     'date': time.strftime('%Y-%m-%d'),
2271                     'partner_id': partner_id,
2272                     'credit': reference_amount,
2273                     'account_id': src_account_id,
2274         }
2275
2276         # if we are posting to accounts in a different currency, provide correct values in both currencies correctly
2277         # when compatible with the optional secondary currency on the account.
2278         # Financial Accounts only accept amounts in secondary currencies if there's no secondary currency on the account
2279         # or if it's the same as that of the secondary amount being posted.
2280         account_obj = self.pool.get('account.account')
2281         src_acct, dest_acct = account_obj.browse(cr, uid, [src_account_id, dest_account_id], context=context)
2282         src_main_currency_id = src_acct.company_id.currency_id.id
2283         dest_main_currency_id = dest_acct.company_id.currency_id.id
2284         cur_obj = self.pool.get('res.currency')
2285         if reference_currency_id != src_main_currency_id:
2286             # fix credit line:
2287             credit_line_vals['credit'] = cur_obj.compute(cr, uid, reference_currency_id, src_main_currency_id, reference_amount, context=context)
2288             if (not src_acct.currency_id) or src_acct.currency_id.id == reference_currency_id:
2289                 credit_line_vals.update(currency_id=reference_currency_id, amount_currency=reference_amount)
2290         if reference_currency_id != dest_main_currency_id:
2291             # fix debit line:
2292             debit_line_vals['debit'] = cur_obj.compute(cr, uid, reference_currency_id, dest_main_currency_id, reference_amount, context=context)
2293             if (not dest_acct.currency_id) or dest_acct.currency_id.id == reference_currency_id:
2294                 debit_line_vals.update(currency_id=reference_currency_id, amount_currency=reference_amount)
2295
2296         return [(0, 0, debit_line_vals), (0, 0, credit_line_vals)]
2297
2298     def unlink(self, cr, uid, ids, context=None):
2299         if context is None:
2300             context = {}
2301         ctx = context.copy()
2302         for move in self.browse(cr, uid, ids, context=context):
2303             if move.state != 'draft' and not ctx.get('call_unlink',False):
2304                 raise osv.except_osv(_('UserError'),
2305                         _('You can only delete draft moves.'))
2306         return super(stock_move, self).unlink(
2307             cr, uid, ids, context=ctx)
2308
2309     # _create_lot function is not used anywhere
2310     def _create_lot(self, cr, uid, ids, product_id, prefix=False):
2311         """ Creates production lot
2312         @return: Production lot id
2313         """
2314         prodlot_obj = self.pool.get('stock.production.lot')
2315         prodlot_id = prodlot_obj.create(cr, uid, {'prefix': prefix, 'product_id': product_id})
2316         return prodlot_id
2317
2318     def action_scrap(self, cr, uid, ids, quantity, location_id, context=None):
2319         """ Move the scrap/damaged product into scrap location
2320         @param cr: the database cursor
2321         @param uid: the user id
2322         @param ids: ids of stock move object to be scrapped
2323         @param quantity : specify scrap qty
2324         @param location_id : specify scrap location
2325         @param context: context arguments
2326         @return: Scraped lines
2327         """
2328         if quantity <= 0:
2329             raise osv.except_osv(_('Warning!'), _('Please provide a positive quantity to scrap!'))
2330         res = []
2331         for move in self.browse(cr, uid, ids, context=context):
2332             move_qty = move.product_qty
2333             uos_qty = quantity / move_qty * move.product_uos_qty
2334             default_val = {
2335                 'product_qty': quantity,
2336                 'product_uos_qty': uos_qty,
2337                 'state': move.state,
2338                 'scrapped' : True,
2339                 'location_dest_id': location_id,
2340                 'tracking_id': move.tracking_id.id,
2341                 'prodlot_id': move.prodlot_id.id,
2342             }
2343             if move.location_id.usage <> 'internal':
2344                 default_val.update({'location_id': move.location_dest_id.id})
2345             new_move = self.copy(cr, uid, move.id, default_val)
2346
2347             res += [new_move]
2348             product_obj = self.pool.get('product.product')
2349             for (id, name) in product_obj.name_get(cr, uid, [move.product_id.id]):
2350                 self.log(cr, uid, move.id, "%s x %s %s" % (quantity, name, _("were scrapped")))
2351
2352         self.action_done(cr, uid, res, context=context)
2353         return res
2354
2355     # action_split function is not used anywhere
2356     def action_split(self, cr, uid, ids, quantity, split_by_qty=1, prefix=False, with_lot=True, context=None):
2357         """ Split Stock Move lines into production lot which specified split by quantity.
2358         @param cr: the database cursor
2359         @param uid: the user id
2360         @param ids: ids of stock move object to be splited
2361         @param split_by_qty : specify split by qty
2362         @param prefix : specify prefix of production lot
2363         @param with_lot : if true, prodcution lot will assign for split line otherwise not.
2364         @param context: context arguments
2365         @return: Splited move lines
2366         """
2367
2368         if context is None:
2369             context = {}
2370         if quantity <= 0:
2371             raise osv.except_osv(_('Warning!'), _('Please provide Proper Quantity !'))
2372
2373         res = []
2374
2375         for move in self.browse(cr, uid, ids, context=context):
2376             if split_by_qty <= 0 or quantity == 0:
2377                 return res
2378
2379             uos_qty = split_by_qty / move.product_qty * move.product_uos_qty
2380
2381             quantity_rest = quantity % split_by_qty
2382             uos_qty_rest = split_by_qty / move.product_qty * move.product_uos_qty
2383
2384             update_val = {
2385                 'product_qty': split_by_qty,
2386                 'product_uos_qty': uos_qty,
2387             }
2388             for idx in range(int(quantity//split_by_qty)):
2389                 if not idx and move.product_qty<=quantity:
2390                     current_move = move.id
2391                 else:
2392                     current_move = self.copy(cr, uid, move.id, {'state': move.state})
2393                 res.append(current_move)
2394                 if with_lot:
2395                     update_val['prodlot_id'] = self._create_lot(cr, uid, [current_move], move.product_id.id)
2396
2397                 self.write(cr, uid, [current_move], update_val)
2398
2399
2400             if quantity_rest > 0:
2401                 idx = int(quantity//split_by_qty)
2402                 update_val['product_qty'] = quantity_rest
2403                 update_val['product_uos_qty'] = uos_qty_rest
2404                 if not idx and move.product_qty<=quantity:
2405                     current_move = move.id
2406                 else:
2407                     current_move = self.copy(cr, uid, move.id, {'state': move.state})
2408
2409                 res.append(current_move)
2410
2411
2412                 if with_lot:
2413                     update_val['prodlot_id'] = self._create_lot(cr, uid, [current_move], move.product_id.id)
2414
2415                 self.write(cr, uid, [current_move], update_val)
2416         return res
2417
2418     def action_consume(self, cr, uid, ids, quantity, location_id=False, context=None):
2419         """ Consumed product with specific quatity from specific source location
2420         @param cr: the database cursor
2421         @param uid: the user id
2422         @param ids: ids of stock move object to be consumed
2423         @param quantity : specify consume quantity
2424         @param location_id : specify source location
2425         @param context: context arguments
2426         @return: Consumed lines
2427         """
2428         if context is None:
2429             context = {}
2430         if quantity <= 0:
2431             raise osv.except_osv(_('Warning!'), _('Please provide Proper Quantity !'))
2432         res = []
2433         for move in self.browse(cr, uid, ids, context=context):
2434             move_qty = move.product_qty
2435             if move_qty <= 0:
2436                 raise osv.except_osv(_('Error!'), _('Can not consume a move with negative or zero quantity !'))
2437             quantity_rest = move.product_qty
2438             quantity_rest -= quantity
2439             uos_qty_rest = quantity_rest / move_qty * move.product_uos_qty
2440             if quantity_rest <= 0:
2441                 quantity_rest = 0
2442                 uos_qty_rest = 0
2443                 quantity = move.product_qty
2444
2445             uos_qty = quantity / move_qty * move.product_uos_qty
2446
2447             if quantity_rest > 0:
2448                 default_val = {
2449                     'product_qty': quantity,
2450                     'product_uos_qty': uos_qty,
2451                     'state': move.state,
2452                     'location_id': location_id or move.location_id.id,
2453                 }
2454                 current_move = self.copy(cr, uid, move.id, default_val)
2455                 res += [current_move]
2456                 update_val = {}
2457                 update_val['product_qty'] = quantity_rest
2458                 update_val['product_uos_qty'] = uos_qty_rest
2459                 self.write(cr, uid, [move.id], update_val)
2460
2461             else:
2462                 quantity_rest = quantity
2463                 uos_qty_rest =  uos_qty
2464                 res += [move.id]
2465                 update_val = {
2466                         'product_qty' : quantity_rest,
2467                         'product_uos_qty' : uos_qty_rest,
2468                         'location_id': location_id or move.location_id.id
2469                 }
2470                 self.write(cr, uid, [move.id], update_val)
2471
2472             product_obj = self.pool.get('product.product')
2473             for new_move in self.browse(cr, uid, res, context=context):
2474                 for (id, name) in product_obj.name_get(cr, uid, [new_move.product_id.id]):
2475                     message = _("Product  '%s' is consumed with '%s' quantity.") %(name, new_move.product_qty)
2476                     self.log(cr, uid, new_move.id, message)
2477         self.action_done(cr, uid, res, context=context)
2478
2479         return res
2480
2481     # FIXME: needs refactoring, this code is partially duplicated in stock_picking.do_partial()!
2482     def do_partial(self, cr, uid, ids, partial_datas, context=None):
2483         """ Makes partial pickings and moves done.
2484         @param partial_datas: Dictionary containing details of partial picking
2485                           like partner_id, address_id, delivery_date, delivery
2486                           moves with product_id, product_qty, uom
2487         """
2488         res = {}
2489         picking_obj = self.pool.get('stock.picking')
2490         product_obj = self.pool.get('product.product')
2491         currency_obj = self.pool.get('res.currency')
2492         uom_obj = self.pool.get('product.uom')
2493         wf_service = netsvc.LocalService("workflow")
2494
2495         if context is None:
2496             context = {}
2497
2498         complete, too_many, too_few = [], [], []
2499         move_product_qty = {}
2500         prodlot_ids = {}
2501         for move in self.browse(cr, uid, ids, context=context):
2502             if move.state in ('done', 'cancel'):
2503                 continue
2504             partial_data = partial_datas.get('move%s'%(move.id), False)
2505             assert partial_data, _('Missing partial picking data for move #%s') % (move.id)
2506             product_qty = partial_data.get('product_qty',0.0)
2507             move_product_qty[move.id] = product_qty
2508             product_uom = partial_data.get('product_uom',False)
2509             product_price = partial_data.get('product_price',0.0)
2510             product_currency = partial_data.get('product_currency',False)
2511             prodlot_ids[move.id] = partial_data.get('prodlot_id')
2512             if move.product_qty == product_qty:
2513                 complete.append(move)
2514             elif move.product_qty > product_qty:
2515                 too_few.append(move)
2516             else:
2517                 too_many.append(move)
2518
2519             # Average price computation
2520             if (move.picking_id.type == 'in') and (move.product_id.cost_method == 'average'):
2521                 product = product_obj.browse(cr, uid, move.product_id.id)
2522                 move_currency_id = move.company_id.currency_id.id
2523                 context['currency_id'] = move_currency_id
2524                 qty = uom_obj._compute_qty(cr, uid, product_uom, product_qty, product.uom_id.id)
2525                 if qty > 0:
2526                     new_price = currency_obj.compute(cr, uid, product_currency,
2527                             move_currency_id, product_price)
2528                     new_price = uom_obj._compute_price(cr, uid, product_uom, new_price,
2529                             product.uom_id.id)
2530                     if product.qty_available <= 0:
2531                         new_std_price = new_price
2532                     else:
2533                         # Get the standard price
2534                         amount_unit = product.price_get('standard_price', context=context)[product.id]
2535                         new_std_price = ((amount_unit * product.qty_available)\
2536                             + (new_price * qty))/(product.qty_available + qty)
2537
2538                     product_obj.write(cr, uid, [product.id],{'standard_price': new_std_price})
2539
2540                     # Record the values that were chosen in the wizard, so they can be
2541                     # used for inventory valuation if real-time valuation is enabled.
2542                     self.write(cr, uid, [move.id],
2543                                 {'price_unit': product_price,
2544                                  'price_currency_id': product_currency,
2545                                 })
2546
2547         for move in too_few:
2548             product_qty = move_product_qty[move.id]
2549             if product_qty != 0:
2550                 defaults = {
2551                             'product_qty' : product_qty,
2552                             'product_uos_qty': product_qty,
2553                             'picking_id' : move.picking_id.id,
2554                             'state': 'assigned',
2555                             'move_dest_id': False,
2556                             'price_unit': move.price_unit,
2557                             }
2558                 prodlot_id = prodlot_ids[move.id]
2559                 if prodlot_id:
2560                     defaults.update(prodlot_id=prodlot_id)
2561                 new_move = self.copy(cr, uid, move.id, defaults)
2562                 complete.append(self.browse(cr, uid, new_move))
2563             self.write(cr, uid, [move.id],
2564                     {
2565                         'product_qty' : move.product_qty - product_qty,
2566                         'product_uos_qty':move.product_qty - product_qty,
2567                     })
2568
2569
2570         for move in too_many:
2571             self.write(cr, uid, [move.id],
2572                     {
2573                         'product_qty': move.product_qty,
2574                         'product_uos_qty': move.product_qty,
2575                     })
2576             complete.append(move)
2577
2578         for move in complete:
2579             if prodlot_ids.get(move.id):
2580                 self.write(cr, uid, [move.id],{'prodlot_id': prodlot_ids.get(move.id)})
2581             self.action_done(cr, uid, [move.id], context=context)
2582             if  move.picking_id.id :
2583                 # TOCHECK : Done picking if all moves are done
2584                 cr.execute("""
2585                     SELECT move.id FROM stock_picking pick
2586                     RIGHT JOIN stock_move move ON move.picking_id = pick.id AND move.state = %s
2587                     WHERE pick.id = %s""",
2588                             ('done', move.picking_id.id))
2589                 res = cr.fetchall()
2590                 if len(res) == len(move.picking_id.move_lines):
2591                     picking_obj.action_move(cr, uid, [move.picking_id.id])
2592                     wf_service.trg_validate(uid, 'stock.picking', move.picking_id.id, 'button_done', cr)
2593
2594         return [move.id for move in complete]
2595
2596 stock_move()
2597
2598 class stock_inventory(osv.osv):
2599     _name = "stock.inventory"
2600     _description = "Inventory"
2601     _columns = {
2602         'name': fields.char('Inventory Reference', size=64, required=True, readonly=True, states={'draft': [('readonly', False)]}),
2603         'date': fields.datetime('Creation Date', required=True, readonly=True, states={'draft': [('readonly', False)]}),
2604         'date_done': fields.datetime('Date done'),
2605         'inventory_line_id': fields.one2many('stock.inventory.line', 'inventory_id', 'Inventories', states={'done': [('readonly', True)]}),
2606         'move_ids': fields.many2many('stock.move', 'stock_inventory_move_rel', 'inventory_id', 'move_id', 'Created Moves'),
2607         'state': fields.selection( (('draft', 'Draft'), ('done', 'Done'), ('confirm','Confirmed'),('cancel','Cancelled')), 'State', readonly=True, select=True),
2608         'company_id': fields.many2one('res.company', 'Company', required=True, select=True, readonly=True, states={'draft':[('readonly',False)]}),
2609
2610     }
2611     _defaults = {
2612         'date': lambda *a: time.strftime('%Y-%m-%d %H:%M:%S'),
2613         'state': 'draft',
2614         'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'stock.inventory', context=c)
2615     }
2616
2617     def _inventory_line_hook(self, cr, uid, inventory_line, move_vals):
2618         """ Creates a stock move from an inventory line
2619         @param inventory_line:
2620         @param move_vals:
2621         @return:
2622         """
2623         return self.pool.get('stock.move').create(cr, uid, move_vals)
2624
2625     def action_done(self, cr, uid, ids, context=None):
2626         """ Finish the inventory
2627         @return: True
2628         """
2629         if context is None:
2630             context = {}
2631         move_obj = self.pool.get('stock.move')
2632         for inv in self.browse(cr, uid, ids, context=context):
2633             move_obj.action_done(cr, uid, [x.id for x in inv.move_ids], context=context)
2634             self.write(cr, uid, [inv.id], {'state':'done', 'date_done': time.strftime('%Y-%m-%d %H:%M:%S')}, context=context)
2635         return True
2636
2637     def action_confirm(self, cr, uid, ids, context=None):
2638         """ Confirm the inventory and writes its finished date
2639         @return: True
2640         """
2641         if context is None:
2642             context = {}
2643         # to perform the correct inventory corrections we need analyze stock location by
2644         # location, never recursively, so we use a special context
2645         product_context = dict(context, compute_child=False)
2646
2647         location_obj = self.pool.get('stock.location')
2648         for inv in self.browse(cr, uid, ids, context=context):
2649             move_ids = []
2650             for line in inv.inventory_line_id:
2651                 pid = line.product_id.id
2652                 product_context.update(uom=line.product_uom.id, date=inv.date, prodlot_id=line.prod_lot_id.id)
2653                 amount = location_obj._product_get(cr, uid, line.location_id.id, [pid], product_context)[pid]
2654
2655                 change = line.product_qty - amount
2656                 lot_id = line.prod_lot_id.id
2657                 if change:
2658                     location_id = line.product_id.product_tmpl_id.property_stock_inventory.id
2659                     value = {
2660                         'name': 'INV:' + str(line.inventory_id.id) + ':' + line.inventory_id.name,
2661                         'product_id': line.product_id.id,
2662                         'product_uom': line.product_uom.id,
2663                         'prodlot_id': lot_id,
2664                         'date': inv.date,
2665                     }
2666                     if change > 0:
2667                         value.update( {
2668                             'product_qty': change,
2669                             'location_id': location_id,
2670                             'location_dest_id': line.location_id.id,
2671                         })
2672                     else:
2673                         value.update( {
2674                             'product_qty': -change,
2675                             'location_id': line.location_id.id,
2676                             'location_dest_id': location_id,
2677                         })
2678                     move_ids.append(self._inventory_line_hook(cr, uid, line, value))
2679             message = _("Inventory '%s' is done.") %(inv.name)
2680             self.log(cr, uid, inv.id, message)
2681             self.write(cr, uid, [inv.id], {'state': 'confirm', 'move_ids': [(6, 0, move_ids)]})
2682         return True
2683
2684     def action_cancel_draft(self, cr, uid, ids, context=None):
2685         """ Cancels the stock move and change inventory state to draft.
2686         @return: True
2687         """
2688         for inv in self.browse(cr, uid, ids, context=context):
2689             self.pool.get('stock.move').action_cancel(cr, uid, [x.id for x in inv.move_ids], context=context)
2690             self.write(cr, uid, [inv.id], {'state':'draft'}, context=context)
2691         return True
2692
2693     def action_cancel_inventary(self, cr, uid, ids, context=None):
2694         """ Cancels both stock move and inventory
2695         @return: True
2696         """
2697         move_obj = self.pool.get('stock.move')
2698         account_move_obj = self.pool.get('account.move')
2699         for inv in self.browse(cr, uid, ids, context=context):
2700             move_obj.action_cancel(cr, uid, [x.id for x in inv.move_ids], context=context)
2701             for move in inv.move_ids:
2702                  account_move_ids = account_move_obj.search(cr, uid, [('name', '=', move.name)])
2703                  if account_move_ids:
2704                      account_move_data_l = account_move_obj.read(cr, uid, account_move_ids, ['state'], context=context)
2705                      for account_move in account_move_data_l:
2706                          if account_move['state'] == 'posted':
2707                              raise osv.except_osv(_('UserError'),
2708                                                   _('In order to cancel this inventory, you must first unpost related journal entries.'))
2709                          account_move_obj.unlink(cr, uid, [account_move['id']], context=context)
2710             self.write(cr, uid, [inv.id], {'state': 'cancel'}, context=context)
2711         return True
2712
2713 stock_inventory()
2714
2715 class stock_inventory_line(osv.osv):
2716     _name = "stock.inventory.line"
2717     _description = "Inventory Line"
2718     _rec_name = "inventory_id"
2719     _columns = {
2720         'inventory_id': fields.many2one('stock.inventory', 'Inventory', ondelete='cascade', select=True),
2721         'location_id': fields.many2one('stock.location', 'Location', required=True),
2722         'product_id': fields.many2one('product.product', 'Product', required=True, select=True),
2723         'product_uom': fields.many2one('product.uom', 'Product UOM', required=True),
2724         'product_qty': fields.float('Quantity', digits_compute=dp.get_precision('Product UoM')),
2725         'company_id': fields.related('inventory_id','company_id',type='many2one',relation='res.company',string='Company',store=True, select=True, readonly=True),
2726         'prod_lot_id': fields.many2one('stock.production.lot', 'Production Lot', domain="[('product_id','=',product_id)]"),
2727         'state': fields.related('inventory_id','state',type='char',string='State',readonly=True),
2728     }
2729
2730     def on_change_product_id(self, cr, uid, ids, location_id, product, uom=False, to_date=False):
2731         """ Changes UoM and name if product_id changes.
2732         @param location_id: Location id
2733         @param product: Changed product_id
2734         @param uom: UoM product
2735         @return:  Dictionary of changed values
2736         """
2737         if not product:
2738             return {'value': {'product_qty': 0.0, 'product_uom': False}}
2739         obj_product = self.pool.get('product.product').browse(cr, uid, product)
2740         uom = uom or obj_product.uom_id.id
2741         amount = self.pool.get('stock.location')._product_get(cr, uid, location_id, [product], {'uom': uom, 'to_date': to_date, 'compute_child': False})[product]
2742         result = {'product_qty': amount, 'product_uom': uom}
2743         return {'value': result}
2744
2745 stock_inventory_line()
2746
2747 #----------------------------------------------------------
2748 # Stock Warehouse
2749 #----------------------------------------------------------
2750 class stock_warehouse(osv.osv):
2751     _name = "stock.warehouse"
2752     _description = "Warehouse"
2753     _columns = {
2754         'name': fields.char('Name', size=128, required=True, select=True),
2755         'company_id': fields.many2one('res.company', 'Company', required=True, select=True),
2756         'partner_address_id': fields.many2one('res.partner.address', 'Owner Address'),
2757         'lot_input_id': fields.many2one('stock.location', 'Location Input', required=True, domain=[('usage','<>','view')]),
2758         'lot_stock_id': fields.many2one('stock.location', 'Location Stock', required=True, domain=[('usage','=','internal')]),
2759         'lot_output_id': fields.many2one('stock.location', 'Location Output', required=True, domain=[('usage','<>','view')]),
2760     }
2761     _defaults = {
2762         'company_id': lambda self, cr, uid, c: self.pool.get('res.company')._company_default_get(cr, uid, 'stock.inventory', context=c),
2763     }
2764
2765 stock_warehouse()
2766
2767 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: