rewritten from scratch based on erp5_simulation's experimental PaymentRule.py.

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

product/ERP5/Document/PaymentRule.py

@@ -52,115 +52,44 @@ class PaymentRule(Rule):
   receivable_account_type_list = ('asset/receivable', )
   payable_account_type_list = ('liability/payable', )
 
-
-  def _getPaymentConditionList(self, movement):
-    """Returns payment conditions for this movement.
+  def _generatePrevisionList(self, applied_rule, **kw):
     """
-    while 1:
-      delivery_movement = movement.getDeliveryValue()
-      if delivery_movement is not None:
-        explanation = delivery_movement.getExplanationValue()
-        payment_condition_list = explanation.contentValues(
-               filter=dict(portal_type='Payment Condition'))
-        if payment_condition_list:
-          return payment_condition_list
-
-      # 'order' category is deprecated. it is kept for compatibility.
-      order_movement = movement.getOrderValue()
-      if order_movement is not None:
-        explanation = order_movement.getExplanationValue()
-        payment_condition_list = explanation.contentValues(
-               filter=dict(portal_type='Payment Condition'))
-        if payment_condition_list:
-          return payment_condition_list
+    Generate a list of dictionaries, that contain calculated content of
+    current Simulation Movements in applied rule.
+    based on its context (parent movement, delivery, configuration ...)
 
-      movement = movement.getParentValue().getParentValue()
-      if movement.getPortalType() != self.movement_type:
-        LOG('ERP5', INFO, "PaymentRule couldn't find payment condition")
-        return []
-   
-  def _createMovementsForPaymentCondition(self,
-        applied_rule, payment_condition):
-    """Create simulation movements for this payment condition.
+    These previsions are returned as dictionaries.
     """
-    simulation_movement = applied_rule.getParentValue()
-    date = payment_condition.TradeCondition_getDueDate()
-    
-    if payment_condition.getQuantity():
-      quantity = payment_condition.getQuantity()
-    else:
-      ratio = payment_condition.getEfficiency(1)
-      quantity = simulation_movement.getQuantity() * ratio
-
-    edit_dict = dict(
-          causality_value=payment_condition,
-          payment_mode=payment_condition.getPaymentMode(),
-          source=simulation_movement.getSource(),
-          source_section=simulation_movement.getSourceSection(),
-          source_payment=payment_condition.getSourcePayment() or
-                            simulation_movement.getSourcePayment(),
-          destination=simulation_movement.getDestination(),
-          destination_section=simulation_movement.getDestinationSection(),
-          destination_payment=payment_condition.getDestinationPayment() or
-                            simulation_movement.getDestinationPayment(),
-          resource=simulation_movement.getResource(),
-          start_date=date,
-          price=1,
-          quantity= - quantity,)
-    
-    applied_rule.newContent( **edit_dict )
-
-    edit_dict['source'] = self.getSourcePayment()
-    edit_dict['destination'] = self.getDestinationPayment()
-    edit_dict['quantity'] = - edit_dict['quantity']
-    applied_rule.newContent( **edit_dict )
-    
+    prevision_dict_list = []
+    for input_movement, business_path in self \
+        ._getInputMovementAndPathTupleList(applied_rule):
+      if business_path is None:
+        # since Payment Rule does not know what to do without business
+        # path, we return empty list here and creates no simulation
+        # movements.
+        return []
+      # Since we need to consider business_path only for bank movement,
+      # not for payable movement, we pass None as business_path here.
+      kw = self._getExpandablePropertyDict(applied_rule, None,
+                                           business_path)
+      kw['start_date'] = business_path.getExpectedStartDate(input_movement)
+      kw['stop_date'] = business_path.getExpectedStopDate(input_movement)
+      quantity = business_path.getExpectedQuantity(input_movement)
+
+      # one for payable
+      payable_dict = kw.copy()
+      payable_dict.update(dict(quanity=-quantity))
+      prevision_dict_list.append(payable_dict)
+      # one for bank
+      bank_dict = kw.copy()
+      bank_dict.update(dict(quanity=quantity,
+                            source=business_path.getSource(),
+                            destination=business_path.getDestination()))
+      prevision_dict_list.append(bank_dict)
+    return prevision_dict_list
 
   security.declareProtected(Permissions.ModifyPortalContent, 'expand')
   def expand(self, applied_rule, **kw):
     """Expands the current movement downward.
     """
-    my_parent_movement = applied_rule.getParentValue()
-    # generate for source
-    bank_account = self.getDestinationPaymentValue(
-                           portal_type='Account')
-    assert bank_account is not None
-
-    for payment_condition in self._getPaymentConditionList(
-                                          my_parent_movement):
-      payment_condition_url = payment_condition.getRelativeUrl()
-      # look for a movement for this payment condition:
-      corresponding_movement_list = []
-      for simulation_movement in applied_rule.contentValues():
-        if simulation_movement.getCausality() == payment_condition_url:
-          corresponding_movement_list.append(simulation_movement)
-      if not corresponding_movement_list:
-        self._createMovementsForPaymentCondition(applied_rule,
-                                                 payment_condition)
-      else:
-        # TODO: update corresponding_movement_list
-        pass
-    
-    #Rule.expand(self, applied_rule, **kw)
-
-  def test(self, context, tested_base_category_list=None):
-    """Test if this rule apply.
-    """
-
-    # XXX for now disable this rule
-    return False
-
-    if context.getParentValue()\
-        .getSpecialiseValue().getPortalType() == 'Payment Rule':
-      return False
-
-    for account in ( context.getSourceValue(portal_type='Account'),
-        context.getDestinationValue(portal_type='Account')):
-      if account is not None:
-        account_type = account.getAccountType()
-        if account_type in self.receivable_account_type_list or \
-            account_type in self.payable_account_type_list:
-          return True
-
-    return False
-
+    return Rule._expand(self, applied_rule, **kw)