modify reindexation way so that we can defined the way we want to

reindex by a script specifying request parameter and properties used


git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@17489 20353a03-c40f-0410-a6d1-a30d3c3de9de

product/ERP5/Document/Inventory.py

@@ -70,6 +70,23 @@ class Inventory(Delivery):
     """
     return self.immediateReindexObject(**kw)
 
+  # method used to build category list that willbe set on tmp line
+  def appendToCategoryListFromUid(self, category_list, uid, base_category):
+    object_list = [x.getObject() for x in self.portal_catalog(uid=uid)]
+    if len(object_list):
+      category_list.append("%s/%s" %(base_category, object_list[0].getRelativeUrl()))
+
+  def appendToCategoryList(self, category_list, value, base_category):
+    category_list.append("%s/%s" %(base_category, value))
+  
+  def splitAndExtendToCategoryList(self, category_list, value, *args, **kw):
+    if value is not None:
+      value_list = value.split('\n')
+    else:
+      value_list = []
+    category_list.extend(value_list)
+
+
   def immediateReindexObject(self, temp_constructor=None, **kw):
     """
     Rewrite reindexObject so that we can insert lines in stock table
@@ -93,129 +110,184 @@ class Inventory(Delivery):
             connection_id = method.connection_id
             break
 
-    resource_and_variation_dict = {}
-    stock_object_list = []
-    stock_append = stock_object_list.append
+    default_inventory_calculation_list = ({ "inventory_params" : {"node" : self.getDestination(),
+                                                                          "group_by_sub_variation" : 1,
+                                                                          "group_by_variation" : 1,
+                                                                          "group_by_resource" : 1,
+                                                                          },
+                                            "list_method" : "getMovementList",
+                                            "first_level" : ({'key' : 'resource_relative_url',
+                                                             'getter' : 'getResource',
+                                                              'setter' : ("appendToCategoryList", "resource")},
+                                                             {'key' : 'variation_text',
+                                                              'getter' : 'getVariationText',
+                                                              'setter' : "splitAndExtendToCategoryList"},
+                                                             ),
+                                            "second_level" : ({'key' : 'sub_variation_text',
+                                                               'getter' : 'getSubVariationText',
+                                                               'setter' : "splitAndExtendToCategoryList"},
+                                                              ),
+                                            },
+                                          )
+
+    method = self._getTypeBasedMethod('getDefaultInventoryCalculationList')    
+    if method is not None:
+      default_inventory_calculation_list = method()
+      
+
     if temp_constructor is None:
       from Products.ERP5Type.Document import newTempDeliveryLine
       temp_constructor = newTempDeliveryLine
-    start_date = self.getStartDate()
-    node = self.getDestination()
+    stop_date = self.getStopDate()
+
+    stock_object_list = []
+    stock_append = stock_object_list.append
+
+    for inventory_calculation_dict in default_inventory_calculation_list:
+
       # build a dict containing all inventory for this node 
       # group by resource/variation and then subvariation
       current_inventory_list = \
           self.getPortalObject().portal_simulation.getInventoryList(        
-                to_date=start_date,
-                node=node,
+                  to_date=stop_date,
                   simulation_state=self.getPortalCurrentInventoryStateList(),
-                group_by_sub_variation=1,
-                group_by_variation=1,
-                group_by_resource=1,
                   connection_id=connection_id,
+                  **inventory_calculation_dict['inventory_params']
           )
       current_inventory_dict = {}
-    current_inventory_key_id_list = ('resource_relative_url', 'variation_text')
+      current_inventory_key_id_list = [x["key"] for x in inventory_calculation_dict['first_level']]
       for line in current_inventory_list:
-      current_inventory_key = [line[x] for x in current_inventory_key_id_list]
-      for x in xrange(len(current_inventory_key)):
-        if current_inventory_key[x] is None:
-          current_inventory_key[x] = ""
-      current_inventory_key = tuple(current_inventory_key)
+        current_inventory_key = tuple(
+          [line[x] for x in current_inventory_key_id_list])
+        if current_inventory_key[1] is None:
+          # To be consistent
+          current_inventory_key = (current_inventory_key[0], "")
+
+        if inventory_calculation_dict.has_key("second_level"):
+          # two level of variation
           try:
             current_inventory_by_sub_variation = \
                 current_inventory_dict[current_inventory_key]
           except KeyError:
             current_inventory_by_sub_variation = \
                 current_inventory_dict[current_inventory_key] = {}
-      current_inventory_by_sub_variation[line['sub_variation_text']] = \
-            line['total_quantity']
-
-    def getCurrentInventoryBySubVariation(**criterion_dict):
-      current_inventory_key = tuple(
-          [criterion_dict[x] for x in current_inventory_key_id_list])
-      return current_inventory_dict.get(current_inventory_key, {})
+          second_level_key_id_list = [x['key'] for x in inventory_calculation_dict['second_level']]
+          second_level_key = tuple([line[x] for x in second_level_key_id_list])
+          current_inventory_by_sub_variation[second_level_key] = line['total_quantity']
+        else:
+          # only one level of variation
+          current_inventory_dict[current_inventory_key] = line['total_quantity']
 
       # Browse all movements on inventory and create diff line when necessary
       not_used_inventory_dict = {}
       inventory_id = self.getId()
-    for movement in self.getMovementList():
+      list_method = inventory_calculation_dict['list_method']      
+      method = getattr(self, list_method)      
+      for movement in method():
         if movement.getResourceValue() is not None and \
             movement.getQuantity() not in (None, ''):
-        resource_path =  movement.getResource()
-        variation_text = movement.getVariationText()
+
           movement_quantity = movement.getQuantity()
-        destination_payment_path = movement.getDestinationPayment()          
-        resource_and_variation_key = (resource_path, variation_text)
-        inventory_by_subvariation_dict = getCurrentInventoryBySubVariation(
-                          resource_relative_url=resource_path,
-                          variation_text=variation_text)
-        movement_sub_variation_text = movement.getSubVariationText()
-        # Check wath is the quantity difference
-        if movement_sub_variation_text in \
-                              inventory_by_subvariation_dict.keys():
-          total_quantity = inventory_by_subvariation_dict.pop(
-                          movement_sub_variation_text)
+          # construct key to retrieve inventory into dict
+          getter_list = [x['getter'] for x in inventory_calculation_dict['first_level']]
+          key_list = []
+          for getter in getter_list:
+            method = getattr(movement, getter, None)
+            if method is not None:
+              key_list.append(method())
+          inventory_value = current_inventory_dict.get(tuple(key_list), 0)
+          second_key_list = []
+          if inventory_calculation_dict.has_key('second_level'):
+            if inventory_value == 0:
+              inventory_value = {}
+            # two level
+            second_getter_list = [x['getter'] for x in inventory_calculation_dict['second_level']]
+            for getter in second_getter_list:
+              method = getattr(movement, getter, None)
+              if method is not None:
+                second_key_list.append(method())
+              second_key_list = tuple(second_key_list)
+              if inventory_value.has_key(second_key_list):
+                total_quantity = inventory_value.pop(second_key_list)
                 # Put remaining subvariation in a dict to know which one 
                 # to removed at end
-          not_used_inventory_dict[resource_and_variation_key] = \
-                            inventory_by_subvariation_dict
+                not_used_inventory_dict[tuple(key_list)] = inventory_value
                 diff_quantity = movement_quantity - total_quantity
               else:
                 # Inventory for new resource/variation/sub_variation
                 diff_quantity = movement_quantity
                 # Put remaining subvariation in a dict to know which one 
                 # to removed at end
-          not_used_inventory_dict[resource_and_variation_key] = \
-                                        inventory_by_subvariation_dict
+                not_used_inventory_dict[tuple(key_list)] = inventory_value
+          else:
+            # we got the quantity from first level key
+            diff_quantity = movement_quantity - inventory_value
               
           # Create tmp movement with only diff between inventory
           # and previous stock values
           if diff_quantity != 0:
             kwd = {'uid': movement.getUid(),
-                 'start_date': start_date}
-          if variation_text is not None:
-            variation_list = variation_text.split('\n')
-          else:
-            variation_list = []
-          category_list = self.getCategoryList()
-          sub_variation_list = []
-          if movement_sub_variation_text is not None:
-            sub_variation_list = movement_sub_variation_text.split('\n')
+                   'start_date': stop_date}
+
+            # create the tmp line and set category on it
             temp_delivery_line = temp_constructor(self,
                                                   inventory_id)
             kwd['quantity'] = diff_quantity
-          category_list.append('resource/%s' % resource_path)
-          category_list.append(
-              'destination_payment/%s' % destination_payment_path)
-          category_list.extend(variation_list)
-          category_list.extend(sub_variation_list)
+            category_list = self.getCategoryList()            
+
+            setter_list = [x['setter'] for x in inventory_calculation_dict['first_level']]
+            if inventory_calculation_dict.has_key("second_level"):
+              setter_list.extend([x['setter'] for x in inventory_calculation_dict['second_level']])
+            value_list = list(key_list) + list(second_key_list)
+            for x in xrange(len(setter_list)):
+              value = value_list[x]
+              setter = setter_list[x]
+              base_category = ""
+              if isinstance(setter, (tuple, list)):
+                base_category = setter[1]
+                setter = setter[0]
+              method = getattr(self, setter, None)
+              if method is not None:
+                method(category_list, value, base_category)
+
             kwd['category_list'] = category_list
             temp_delivery_line.edit(**kwd)
             stock_append(temp_delivery_line)
 
       # Now create line to remove some subvariation text not present 
       # in new inventory
+      if len(not_used_inventory_dict):
         inventory_uid = self.getUid()
-    for resource_and_variation_key in not_used_inventory_dict.keys():
-      inventory_by_subvariation_dict = \
-          not_used_inventory_dict[resource_and_variation_key]
-      for sub_variation_text in inventory_by_subvariation_dict.keys():
-        category_list = self.getCategoryList()
-        quantity = inventory_by_subvariation_dict[sub_variation_text]
-        resource_path, variation_text = resource_and_variation_key
+        for first_level_key in not_used_inventory_dict.keys():
+          inventory_value = \
+              not_used_inventory_dict[tuple(first_level_key)]
+          for second_level_key in inventory_value.keys():
+            diff_quantity = - inventory_value[tuple(second_level_key)]
+
             kwd = {'uid': inventory_uid,
-               'start_date': start_date}
-        if variation_text is not None:
-          variation_list = variation_text.split('\n')
-        else:
-          variation_list = []                
-        sub_variation_list = sub_variation_text.split('\n')
-        diff_quantity = - quantity                    
-        temp_delivery_line = temp_constructor(self, inventory_id)
+                   'start_date': stop_date}
+
+            # create the tmp line and set category on it
+            temp_delivery_line = temp_constructor(self,
+                                                  inventory_id)
             kwd['quantity'] = diff_quantity
-        category_list.append('resource/%s' % resource_path)
-        category_list.extend(variation_list)
-        category_list.extend(sub_variation_list)
+            category_list = self.getCategoryList()            
+
+            setter_list = [x['setter'] for x in inventory_calculation_dict['first_level']]
+            if inventory_calculation_dict.has_key("second_level"):
+              setter_list.extend([x['setter'] for x in inventory_calculation_dict['second_level']])
+            value_list = list(first_level_key) + list(second_level_key)
+            for x in xrange(len(setter_list)):
+              value = value_list[x]
+              setter = setter_list[x]
+              base_category = ""
+              if isinstance(setter, (tuple, list)):
+                base_category = setter[1]
+                setter = setter[0]
+              method = getattr(self, setter, None)
+              if method is not None:
+                method(category_list, value, base_category)
+
             kwd['category_list'] = category_list
             temp_delivery_line.edit(**kwd)
             stock_append(temp_delivery_line)
@@ -225,12 +297,8 @@ class Inventory(Delivery):
     self.portal_catalog.catalogObjectList(object_list,
                                           sql_catalog_id = sql_catalog_id,
                                           disable_archive=disable_archive)
-    if len(stock_object_list)==0:
-      # Make sure to remove all lines
-      from Products.ERP5Type.Document import newTempBase
-      stock_append(temp_constructor(self, inventory_id, uid=inventory_uid))
+
     self.portal_catalog.catalogObjectList(
            stock_object_list, method_id_list=('z_catalog_stock_list', ),
            sql_catalog_id = sql_catalog_id,
            disable_cache=1, check_uid=0, disable_archive=disable_archive)
-