From 63558aa4ab56d35d24ed79d36cb4400492515f1b Mon Sep 17 00:00:00 2001
From: Bertrand Chenal <bch@b2ck.com>
Date: Fri, 11 Jul 2008 00:27:42 +0200
Subject: [PATCH 1/3] Fix : allow to delete cancelled moves

---
 move.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/move.py b/move.py
index 079a07d429..bdfe730e25 100644
--- a/move.py
+++ b/move.py
@@ -297,9 +297,9 @@ class Move(OSV):
 
     def unlink(self, cursor, user, ids, context=None):
         for move in self.browse(cursor, user, ids, context=context):
-            if move.state != 'draft':
+            if move.state not in  ('draft', 'cancel'):
                 raise ExceptORM('UserError',
-                        'You can only delete draft moves!')
+                        'You can only delete draft or cancelled moves!')
         return super(Move, self).unlink(cursor, user, ids, context=context)
 
 Move()

From c3a1dddec792b839679b42c4260346220aa4b52e Mon Sep 17 00:00:00 2001
From: Bertrand Chenal <bch@b2ck.com>
Date: Fri, 11 Jul 2008 00:28:56 +0200
Subject: [PATCH 2/3] Added expected on inventory line, improved inventory
 update.

---
 inventory.py  | 136 +++++++++++++++++++++++++-------------------------
 inventory.xml |   9 ++--
 2 files changed, 73 insertions(+), 72 deletions(-)

diff --git a/inventory.py b/inventory.py
index 2f8508e016..c8d92d29b0 100644
--- a/inventory.py
+++ b/inventory.py
@@ -18,7 +18,7 @@ class Inventory(OSV):
     location = fields.Many2One(
         'stock.location', 'Location', required=True,
         domain="[('type', '=', 'storage')]", states=STATES)
-    date = fields.DateTime('Date', readonly=True)
+    date = fields.Date('Date',)
     lost_found = fields.Many2One(
         'stock.location', 'Lost and Found', required=True,
         domain="[('type', '=', 'lost_found')]", states=STATES)
@@ -50,7 +50,7 @@ class Inventory(OSV):
         return 'open'
 
     def default_date(self, cursor, user, context=None):
-        return datetime.datetime.today()
+        return datetime.date.today()
 
     def default_company(self, cursor, user, context=None):
         if context.get('company'):
@@ -88,29 +88,16 @@ class Inventory(OSV):
         location_ids = []
         inv_by_loc = {}
 
-        for inventory in inventories:
-            location_ids.append(inventory.location.id)
-            inv_by_loc[inventory.location.id] = inventory.id
-        raw_data = product_obj.raw_products_by_location(cursor, user,
-                location_ids, context=context)
-
-        indexed_data = {}
-        for location, product, uom, qty in raw_data:
-            indexed_data.setdefault(location,{})[(product, uom)] = qty
-
         for inventory in inventories:
             if inventory.state != 'open':
                 continue
             moves = []
-            location_data = indexed_data.get(inventory.location.id, {})
             for line in inventory.lines:
-                key = (line.product.id, line.uom.id)
-                expected_qty = location_data.get(key, 0.0)
-                delta_qty = line.quantity - expected_qty
-                location_data[key] = 0
-
-                from_location = inventory.lost_found.id
-                to_location = inventory.location.id
+                delta_qty = line.expected_quantity - line.quantity
+                if delta_qty == 0.0:
+                    continue
+                from_location = inventory.location.id
+                to_location = inventory.lost_found.id
                 if delta_qty < 0:
                     (from_location, to_location, delta_qty) = \
                         (to_location, from_location, -delta_qty)
@@ -125,31 +112,11 @@ class Inventory(OSV):
                     'state': 'done',
                     }, context=context)
                 moves.append(move_id)
-            # Create move for all missing products
-            for (product, uom), qty in location_data.iteritems():
-                if qty == 0:
-                    continue
-                from_location = inventory.location.id
-                to_location = inventory.lost_found.id
-                if qty < 0:
-                    (from_location, to_location, qty) = \
-                        (to_location, from_location, -qty)
 
-                move_id = move_obj.create(cursor, user, {
-                    'from_location': from_location,
-                    'to_location': to_location,
-                    'quantity': qty,
-                    'product': product,
-                    'uom': uom,
-                    'company': inventory.company.id,
-                    'state': 'done',
+            self.write(cursor, user, ids, {
+                    'date': datetime.date.today(),
+                    'moves': [('add', x) for x in moves],
                     }, context=context)
-                moves.append(move_id)
-
-        return self.write(cursor, user, ids, {
-            'date': datetime.datetime.today(),
-            'moves': [('add', x) for x in moves],
-            }, context=context)
 
     def write(self, cursor, user, ids, vals, context=None):
         if 'state' in vals:
@@ -172,6 +139,8 @@ class InventoryLine(OSV):
     product = fields.Many2One(
         'product.product', 'Product', required=True, on_change=['product'])
     uom = fields.Many2One('product.uom', 'Uom', required=True, select=1)
+    expected_quantity = fields.Float(
+        'Expected Quantity', digits=(12, 6), readonly=True)
     quantity = fields.Float('Quantity', digits=(12, 6))
     inventory = fields.Many2One('stock.inventory', 'Inventory')
 
@@ -211,36 +180,65 @@ class CompleteInventory(Wizard):
         line_obj = self.pool.get('stock.inventory.line')
         inventory_obj = self.pool.get('stock.inventory')
         product_obj = self.pool.get('product.product')
+        uom_obj = self.pool.get('product.uom')
         inventories = inventory_obj.browse(cursor, user, data['ids'],
                 context=context)
-        location_ids = []
-        inv_by_loc = {}
-        for inventory in inventories:
-            location_ids.append(inventory.location.id)
-            inv_by_loc[inventory.location.id] = inventory.id
-
-        pbl =  product_obj.products_by_location(
-            cursor, user, location_ids, context=context)
-        indexed_data = {}
-        for line in pbl:
-            indexed_data.setdefault(line['location'], []).append(
-                (line['product'], line['uom'], line['quantity']))
 
         for inventory in inventories:
-            products = [line.product.id for line in inventory.lines]
-            for (product, uom, qty) in indexed_data.get(inventory.location.id,[]):
-                # Skip products already in the inventory:
-                if product in products:
-                    continue
-                if qty <= 0.0:
-                    qty = 0
-                line_obj.create(
-                    cursor, user,
-                    {'product': product,
-                     'uom': uom,
-                     'quantity': qty,
-                     'inventory': inventory.id,},
+            # Compute product quantities
+            if inventory.date:
+                context = context.copy()
+                context['forecast_date'] = inventory.date
+                pbl = product_obj.products_by_location(
+                    cursor, user, [inventory.location.id], forecast=True,
                     context=context)
-        return {}
+            else:
+                pbl = product_obj.products_by_location(
+                    cursor, user, [inventory.location.id], context=context)
+            # Index some data
+            uom_by_id = {}
+            for uom in uom_obj.browse(
+                cursor, user, [line['uom'] for line in pbl], context=context):
+                uom_by_id[uom.id] = uom
+            product_qty = {}
+            for line in pbl:
+                product_qty[line['product']] = (line['quantity'],
+                                                uom_by_id[line['uom']])
+            # Update existing lines
+            for line in inventory.lines:
+                if line.product.id in product_qty:
+                    quantity, uom = product_qty[line.product.id]
+                    del product_qty[line.product.id]
+                    # if nothing as changed, continue
+                    if line.quantity == line.expected_quantity == quantity \
+                            and line.uom.id == uom.id:
+                        continue
+                    values = {'expected_quantity': quantity,
+                              'uom': uom.id}
+                    # update also quantity field if not edited
+                    if line.quantity == line.expected_quantity:
+                        values['quantity'] = quantity
+                else:
+                    values = {'expected_quantity': 0.0,}
+                    if line.quantity == line.expected_quantity:
+                        values['quantity'] = 0
 
+
+                line_obj.write(
+                    cursor, user, line.id, values, context=context)
+
+            # Create lines if needed
+            for product in product_qty:
+                quantity, uom = product_qty[product]
+                values = {
+                    'product': product,
+                    'expected_quantity': quantity,
+                    'quantity': quantity,
+                    'uom': uom.id,
+                    'inventory': inventory.id,
+                    }
+                line_obj.create(
+                    cursor, user, values, context=context)
+
+        return {}
 CompleteInventory()
diff --git a/inventory.xml b/inventory.xml
index 2e0ed18d63..da3a46fc29 100644
--- a/inventory.xml
+++ b/inventory.xml
@@ -87,13 +87,15 @@
             <field name="type">form</field>
             <field name="arch" type="xml">
                 <![CDATA[
-                    <form string="Inventory Line" col="6">
+                    <form string="Inventory Line" col="4">
                         <label name="product"/>
                         <field name="product"/>
-                        <label name="quantity"/>
-                        <field name="quantity"/>
                         <label name="uom"/>
                         <field name="uom"/>
+                        <label name="expected_quantity"/>
+                        <field name="expected_quantity"/>
+                        <label name="quantity"/>
+                        <field name="quantity"/>
                         <label name="inventory"/>
                         <field name="inventory"/>
                     </form>
@@ -107,6 +109,7 @@
                 <![CDATA[
                     <tree string="Inventory Lines" editable="bottom">
                         <field name="product" select="1"/>
+                        <field name="expected_quantity"/>
                         <field name="quantity" select="2"/>
                         <field name="uom" select="2"/>
                     </tree>

From e6c6b15a1d97ef16dfb0c09d332eb2fa9cb4ed67 Mon Sep 17 00:00:00 2001
From: Bertrand Chenal <bch@b2ck.com>
Date: Fri, 11 Jul 2008 23:20:17 +0200
Subject: [PATCH 3/3] Improved stock computation behaviour

---
 inventory.py |   6 +--
 location.py  |  29 ++++++-------
 location.xml |   4 +-
 product.py   | 115 +++++++++++++++++++++++++++++++--------------------
 product.xml  |   4 +-
 5 files changed, 93 insertions(+), 65 deletions(-)

diff --git a/inventory.py b/inventory.py
index c8d92d29b0..3ea8e3bc88 100644
--- a/inventory.py
+++ b/inventory.py
@@ -18,7 +18,7 @@ class Inventory(OSV):
     location = fields.Many2One(
         'stock.location', 'Location', required=True,
         domain="[('type', '=', 'storage')]", states=STATES)
-    date = fields.Date('Date',)
+    date = fields.Date('Date')
     lost_found = fields.Many2One(
         'stock.location', 'Lost and Found', required=True,
         domain="[('type', '=', 'lost_found')]", states=STATES)
@@ -188,9 +188,9 @@ class CompleteInventory(Wizard):
             # Compute product quantities
             if inventory.date:
                 context = context.copy()
-                context['forecast_date'] = inventory.date
+                context['stock_date'] = inventory.date
                 pbl = product_obj.products_by_location(
-                    cursor, user, [inventory.location.id], forecast=True,
+                    cursor, user, [inventory.location.id],
                     context=context)
             else:
                 pbl = product_obj.products_by_location(
diff --git a/location.py b/location.py
index 9f4541f6ed..f5e7889d09 100644
--- a/location.py
+++ b/location.py
@@ -2,6 +2,7 @@
 "Wharehouse"
 from trytond.osv import fields, OSV
 from trytond.wizard import Wizard, WizardOSV
+import datetime
 
 STATES = {
     'readonly': "not active",
@@ -86,14 +87,13 @@ class Location(OSV):
             return dict([(i,0) for i in ids])
         product_obj = self.pool.get('product.product')
         all_ids = self.search(cursor, user, [('parent', 'child_of', ids)])
-        if name == 'forecast_quantity':
-            pbl = product_obj.products_by_location(
-                cursor, user, location_ids=all_ids,
-                product_ids=[context['product']], forecast=True, context=context)
-        else:
-            pbl = product_obj.products_by_location(
-                cursor, user, location_ids=all_ids,
-                product_ids=[context['product']], context=context)
+        if name != 'forecast_quantity' and context.get('stock_date'):
+            if context['stock_date'] != datetime.date.today():
+                context = context.copy()
+                del context['stock_date']
+        pbl = product_obj.products_by_location(
+            cursor, user, location_ids=all_ids,
+            product_ids=[context['product']], context=context)
         qty_by_ltn = dict([(i['location'], i['quantity']) for i in pbl])
         to_compute = dict.fromkeys(all_ids, True)
         locations = self.browse(cursor, user, all_ids, context=context)
@@ -141,14 +141,14 @@ class Party(OSV):
 Party()
 
 
-class ChooseForecatsDateInit(WizardOSV):
-    _name = 'stock.location_forecast_date.init'
+class ChooseStockDateInit(WizardOSV):
+    _name = 'stock.location_stock_date.init'
     forecast_date = fields.Date(
         'Forecast Date', help='Allow to compute expected '\
             'stock quantities for this date.\n'\
             '* An empty value is an infinite date in the future.\n'\
             '* A date in the past will provide historical values.')
-ChooseForecatsDateInit()
+ChooseStockDateInit()
 
 
 class OpenProduct(Wizard):
@@ -158,7 +158,7 @@ class OpenProduct(Wizard):
         'init': {
             'result': {
                 'type': 'form',
-                'object': 'stock.location_forecast_date.init',
+                'object': 'stock.location_stock_date.init',
                 'state': [
                     ('end', 'Cancel', 'tryton-cancel'),
                     ('open', 'Open', 'tryton-ok', True),
@@ -186,9 +186,10 @@ class OpenProduct(Wizard):
                 context=context)
         res = act_window_obj.read(cursor, user, model_data.db_id, context=context)
 
-        context = {'locations': data['ids']}
+        if context == None: context = {}
+        context['locations'] = data['ids']
         if data['form']['forecast_date']:
-            context['forecast_date'] = data['form']['forecast_date']
+            context['stock_date'] = data['form']['forecast_date']
         res['context'] = str(context)
 
         return res
diff --git a/location.xml b/location.xml
index 041c0d0469..9c2197372c 100644
--- a/location.xml
+++ b/location.xml
@@ -170,8 +170,8 @@
             <field name="type">lost_found</field>
         </record>
 
-        <record model="ir.ui.view" id="location_forecast_date_init_view_form">
-            <field name="model">stock.location_forecast_date.init</field>
+        <record model="ir.ui.view" id="location_stock_date_init_view_form">
+            <field name="model">stock.location_stock_date.init</field>
             <field name="type">form</field>
             <field name="arch" type="xml">
                 <![CDATA[
diff --git a/product.py b/product.py
index 6fdf4943c9..5da62203c7 100644
--- a/product.py
+++ b/product.py
@@ -20,14 +20,13 @@ class Product(OSV):
         location_ids = self.pool.get('stock.location').search(
             cursor, user, [('parent', 'child_of', context['locations'])],
             context=context)
-        if name == 'forecast_quantity':
-            pbl = self.products_by_location(
-                cursor, user, location_ids=location_ids, product_ids=ids,
-                forecast=True, context=context)
-        else:
-            pbl = self.products_by_location(
-                cursor, user, location_ids=location_ids, product_ids=ids,
-                context=context)
+        if name != 'forecast_quantity' and context.get('stock_date'):
+            if context['stock_date'] != datetime.date.today():
+                context = context.copy()
+                context['stock_date'] = datetime.date.today()
+        pbl = self.products_by_location(
+            cursor, user, location_ids=location_ids, product_ids=ids,
+            context=context)
         res = {}
         for product_id in ids:
             res[product_id] = 0.0
@@ -39,7 +38,7 @@ class Product(OSV):
         res = True
         for field, operator, operand in domain:
             value = line.get(field)
-            if not value:
+            if value == None:
                 return False
             if operator not in ("=", ">=", "<=", ">", "<", "!="):
                 return False
@@ -56,26 +55,32 @@ class Product(OSV):
             context=context)
         if name == 'forecast_quantity':
             pbl = self.products_by_location(
-                cursor, user, location_ids=location_ids, forecast=True,
-                context=context)
+                cursor, user, location_ids=location_ids,
+                skip_zero=False, context=context)
             for line in pbl:
                 line['forecast_quantity'] = line['quantity']
                 del line['quantity']
         else:
+            if context.get('stock_date'):
+                if context['stock_date'] != datetime.date.today():
+                    context = context.copy()
+                    del context['stock_date']
             pbl = self.products_by_location(
-                cursor, user, location_ids=location_ids, context=context)
-
+                cursor, user, location_ids=location_ids,
+                skip_zero=False, context=context)
         res= [line['product'] for line in pbl \
                     if self._eval_domain(line, domain)]
         return [('id', 'in', res)]
 
 
     def raw_products_by_location(self, cursor, user, location_ids,
-            product_ids=None, forecast=False, context=None):
+            product_ids=None,  context=None):
         """
         Return a list like : [(location, product, uom, qty)] for each
         location and product given as argument. Null qty are not
-        returned and the tuple (location, product,uom) is unique.
+        returned and the tuple (location, product,uom) is unique. The
+        key stock_date in context can be used to compute stock for
+        other date than today.
         """
         if not location_ids:
             return []
@@ -83,8 +88,8 @@ class Product(OSV):
         rule_obj = self.pool.get('ir.rule')
         move_query, move_val = rule_obj.domain_get(cursor, user, 'stock.move')
 
-        if forecast and not (context.get('forecast_date') and \
-                context['forecast_date'] < datetime.date.today()):
+        if context.get('stock_date') and \
+                context['stock_date'] > datetime.date.today():
             in_states = ['done', 'assigned', 'draft']
             out_states = ['done', 'assigned', 'draft']
         else:
@@ -121,15 +126,15 @@ class Product(OSV):
                 ",".join(["%s" for i in product_ids]) + ")"
             where_vals += product_ids
 
-        if forecast and context.get('forecast_date'):
-            where_clause += ' AND ('\
-                '(effective_date IS NULL '\
-                'AND ( planned_date <= %s or planned_date IS NULL)) '\
-                'OR effective_date <= %s'\
-                ')'
-            where_date = [context['forecast_date'],context['forecast_date']]
+        where_clause += ' AND ('\
+            '(effective_date IS NULL '\
+            'AND ( planned_date <= %s or planned_date IS NULL)) '\
+            'OR effective_date <= %s'\
+            ')'
+        if context.get('stock_date'):
+            where_date = [context['stock_date'], context['stock_date']]
         else:
-            where_date = []
+            where_date = [datetime.date.today(), datetime.date.today()]
         cursor.execute(select_clause % (
             ",".join(["%s" for i in in_states]), where_clause,
             ",".join(["%s" for i in out_states]), where_clause),
@@ -139,8 +144,14 @@ class Product(OSV):
         return cursor.fetchall()
 
     def products_by_location(self, cursor, user, location_ids,
-                            product_ids=None, forecast=False, context=None):
-
+                            product_ids=None, skip_zero=True, context=None):
+        """
+        Return a list like : [{location: 1, product: 1, uom: 1, qty:
+        2}] for each location and product given as argument. The key
+        stock_date in context can be used to compute stock for other
+        date than today. If skip_zero, list item with quantity equal
+        to zero are not returned.
+        """
         uom_obj = self.pool.get("product.uom")
         product_obj = self.pool.get("product.product")
 
@@ -149,27 +160,42 @@ class Product(OSV):
 
         if not product_ids:
             product_ids = product_obj.search(cursor, user, [], context=context)
+        else:
+            product_ids = product_ids[:]
 
         uom_ids = uom_obj.search(cursor, user, [], context=context)
         uom_by_id = dict((x.id, x) for x in uom_obj.browse(
                 cursor, user, uom_ids, context=context))
-        default_uom = dict((x.id, x.default_uom) for x in product_obj.browse(
+        default_uom = dict((p.id, p.default_uom) for p in product_obj.browse(
                 cursor, user, product_ids, context=context))
 
-        res = {}
+        res_dict = {}
         for line in self.raw_products_by_location(
-            cursor, user, location_ids, product_ids, forecast=forecast,
-            context=context):
+            cursor, user, location_ids, product_ids, context=context):
             location, product, uom, quantity= line
             key = (location, product, default_uom[product].id)
-            res.setdefault(key, 0.0)
-            res[key] += uom_obj.compute_qty(
-                cursor, user, uom_by_id[uom], quantity, default_uom[product],
-                context=context)
-        return [{'location': key[0],
-                 'product':key[1],
+            res_dict.setdefault(key, 0.0)
+            res_dict[key] += uom_obj.compute_qty(
+                cursor, user, uom_by_id[uom], quantity,
+                default_uom[product], context=context)
+            # Remove seen products from product_ids
+            if key[1] in product_ids:
+                product_ids.remove(key[1])
+
+        res = [{'location': key[0],
+                 'product': key[1],
                  'uom': key[2],
-                 'quantity': val} for key, val in res.iteritems()]
+                 'quantity': val} for key, val in res_dict.iteritems()]
+        # Complete result with missing products if asked
+        if not skip_zero:
+            for location_id in location_ids:
+                for product_id in product_ids:
+                    res.append({'location': location_id,
+                               'product': product_id,
+                               'uom': default_uom[product_id].id,
+                               'quantity': 0.0})
+
+        return res
 
     def view_header_get(self, cursor, user, value, view_type='form',
             context=None):
@@ -183,14 +209,14 @@ class Product(OSV):
 Product()
 
 
-class ChooseForecatsDateInit(WizardOSV):
-    _name = 'stock.product_forecast_date.init'
+class ChooseStockDateInit(WizardOSV):
+    _name = 'stock.product_stock_date.init'
     forecast_date = fields.Date(
         'Forecast Date', help='Allow to compute expected '\
             'stock quantities for this date.\n'\
             '* An empty value is an infinite date in the future.\n'\
             '* A date in the past will provide historical values.')
-ChooseForecatsDateInit()
+ChooseStockDateInit()
 
 class OpenLocation(Wizard):
     'Products by Locations'
@@ -199,7 +225,7 @@ class OpenLocation(Wizard):
         'init': {
             'result': {
                 'type': 'form',
-                'object': 'stock.product_forecast_date.init',
+                'object': 'stock.product_stock_date.init',
                 'state': [
                     ('end', 'Cancel', 'tryton-cancel'),
                     ('open', 'Open', 'tryton-ok', True),
@@ -227,9 +253,10 @@ class OpenLocation(Wizard):
                 context=context)
         res = act_window_obj.read(cursor, user, model_data.db_id, context=context)
 
-        context = {'product': data['id']}
+        if context == None: context = {}
+        context['product'] = data['id']
         if data['form']['forecast_date']:
-            context['forecast_date'] = data['form']['forecast_date']
+            context['stock_date'] = data['form']['forecast_date']
         res['context'] = str(context)
 
         return res
diff --git a/product.xml b/product.xml
index d878b62229..08cb3618d9 100644
--- a/product.xml
+++ b/product.xml
@@ -57,8 +57,8 @@
             <field name="action" ref="wizard_open_location"/>
         </record>
 
-        <record model="ir.ui.view" id="product_forecast_date_init_view_form">
-            <field name="model">product_forecast_date.init</field>
+        <record model="ir.ui.view" id="product_stock_date_init_view_form">
+            <field name="model">product_stock_date.init</field>
             <field name="type">form</field>
             <field name="arch" type="xml">
                 <![CDATA[