addons/stock/stock.py

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