diff --git a/product/ERP5/Document/PaymentRule.py b/product/ERP5/Document/PaymentRule.py index fb9b043cf7929ca73991d84c4cfba14ad1caff57..fb8742533155b26ea8d493a5f252ab84d6694488 100644 --- a/product/ERP5/Document/PaymentRule.py +++ b/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 ) + 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 - edit_dict['source'] = self.getSourcePayment() - edit_dict['destination'] = self.getDestinationPayment() - edit_dict['quantity'] = - edit_dict['quantity'] - applied_rule.newContent( **edit_dict ) - - 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)