Commit c57d5e46 authored by Kazuhiko Shiozaki's avatar Kazuhiko Shiozaki

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
parent c9821c5e
......@@ -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)
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment