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