SimulationMovement.py 34.4 KB
Newer Older
1
# -*- coding: utf-8 -*-
Jean-Paul Smets's avatar
Jean-Paul Smets committed
2 3 4
##############################################################################
#
# Copyright (c) 2002 Nexedi SARL and Contributors. All Rights Reserved.
5
#                    Jean-Paul Smets-Solanes <jp@nexedi.com>
Jean-Paul Smets's avatar
Jean-Paul Smets committed
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
#
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsability of assessing all potential
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
# garantees and support are strongly adviced to contract a Free Software
# Service Company
#
# This program is Free Software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#
##############################################################################

30
import transaction
31
import zope.interface
Jean-Paul Smets's avatar
Jean-Paul Smets committed
32 33 34
from AccessControl import ClassSecurityInfo
from Products.CMFCore.utils import getToolByName

35
from Products.ERP5Type import Permissions, PropertySheet, interfaces
36
from Products.ERP5Type.TransactionalVariable import getTransactionalVariable
Jean-Paul Smets's avatar
Jean-Paul Smets committed
37

38
from Products.ERP5.Document.Movement import Movement
Jean-Paul Smets's avatar
Jean-Paul Smets committed
39

40
from zLOG import LOG, WARNING
Jean-Paul Smets's avatar
Jean-Paul Smets committed
41

42 43
from Acquisition import aq_base

44
from Products.ERP5.Document.AppliedRule import TREE_DELIVERED_CACHE_KEY, TREE_DELIVERED_CACHE_ENABLED
45
from Products.ERP5.mixin.property_recordable import PropertyRecordableMixin
46
from Products.ERP5.mixin.explainable import ExplainableMixin
47

Jean-Paul Smets's avatar
Jean-Paul Smets committed
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
# XXX Do we need to create groups ? (ie. confirm group include confirmed, getting_ready and ready

parent_to_movement_simulation_state = {
  'cancelled'        : 'cancelled',
  'draft'            : 'draft',
  'auto_planned'     : 'auto_planned',
  'planned'          : 'planned',
  'ordered'          : 'planned',
  'confirmed'        : 'planned',
  'getting_ready'    : 'planned',
  'ready'            : 'planned',
  'started'          : 'planned',
  'stopped'          : 'planned',
  'delivered'        : 'planned',
  'invoiced'         : 'planned',
}

65
class SimulationMovement(PropertyRecordableMixin, Movement, ExplainableMixin):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
  """
      Simulation movements belong to a simulation workflow which includes
      the following steps

      - planned

      - ordered

      - confirmed (the movement is now confirmed in qty or date)

      - started (the movement has started)

      - stopped (the movement is now finished)

      - delivered (the movement is now archived in a delivery)

      The simulation worklow uses some variables, which are
      set by the template

      - is_order_required

      - is_delivery_required


      XX
      - is_problem_checking_required ?

      Other flag
      (forzen flag)

      NEW: we do not use DCWorklow so that the simulation process
      can be as much as possible independent of a Zope / CMF implementation.
  """
  meta_type = 'ERP5 Simulation Movement'
  portal_type = 'Simulation Movement'

  # Declarative security
  security = ClassSecurityInfo()
104
  security.declareObjectProtected(Permissions.AccessContentsInformation)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
105 106 107 108 109 110 111 112 113 114

  # Declarative properties
  property_sheets = ( PropertySheet.Base
                    , PropertySheet.SimpleItem
                    , PropertySheet.CategoryCore
                    , PropertySheet.Amount
                    , PropertySheet.Task
                    , PropertySheet.Arrow
                    , PropertySheet.Movement
                    , PropertySheet.Simulation
115 116 117
                    # Need industrial_phase
                    , PropertySheet.TransformedResource
                    , PropertySheet.AppliedRule
118
                    , PropertySheet.ItemAggregation
119
                    , PropertySheet.Reference
Jean-Paul Smets's avatar
Jean-Paul Smets committed
120
                    )
121

122 123 124
  # Declarative interfaces
  zope.interface.implements(interfaces.IPropertyRecordable, )

125 126 127
  def tpValues(self) :
    """ show the content in the left pane of the ZMI """
    return self.objectValues()
128

Jean-Paul Smets's avatar
Jean-Paul Smets committed
129
  # Price should be acquired
130 131
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getPrice')
132
  def getPrice(self, default=None, context=None, REQUEST=None, **kw):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
133 134
    """
    """
135
    return self._baseGetPrice(default) # Call the price method
Jean-Paul Smets's avatar
Jean-Paul Smets committed
136

137 138
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getCausalityState')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
139 140 141 142
  def getCausalityState(self):
    """
      Returns the current state in causality
    """
143
    return getattr(aq_base(self), 'causality_state', 'solved')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
144

145 146
  security.declareProtected( Permissions.ModifyPortalContent,
                             'setCausalityState')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
147 148 149 150 151 152
  def setCausalityState(self, value):
    """
      Change causality state
    """
    self.causality_state = value

153 154
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getSimulationState')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
155
  def getSimulationState(self, id_only=1):
156
    """Returns the current state in simulation
Jean-Paul Smets's avatar
Jean-Paul Smets committed
157

158 159 160 161 162
      Inherit from delivery or parent (using a conversion table to make orders
      planned when parent is confirmed).
      
      In the case of simulation coming from an item, the simulation state is
      delegated to the item.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
163 164 165 166 167 168

      XXX: movements in zero stock rule can not acquire simulation state
    """
    delivery = self.getDeliveryValue()
    if delivery is not None:
      return delivery.getSimulationState()
169
    # 'order' category is deprecated. it is kept for compatibility.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
170 171 172
    order = self.getOrderValue()
    if order is not None:
      return order.getSimulationState()
173

174
    parent = self.getParentValue()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
175
    try:
176
      try:
177
        parent_state = parent.getSimulationState()
178
      except AttributeError:
179
        item = parent.getCausalityValue(
180 181 182 183
                portal_type=self.getPortalItemTypeList())
        if interfaces.IExpandableItem.providedBy(item):
          return item.getSimulationMovementSimulationState(self)
        raise
Jean-Paul Smets's avatar
Jean-Paul Smets committed
184
      return parent_to_movement_simulation_state[parent_state]
185
    except (KeyError, AttributeError):
186 187
      LOG('SimulationMovement.getSimulationState', WARNING,
          'Could not acquire simulation state from %s'
188
          % self.getRelativeUrl(), error=True)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
189 190
      return None

191 192 193 194 195 196 197 198 199
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getTranslatedSimulationStateTitle')
  def getTranslatedSimulationStateTitle(self):
    """Returns translated simulation state title, for user interface, such as
    stock browser.
    """
    delivery = self.getDeliveryValue()
    if delivery is not None:
      return delivery.getTranslatedSimulationStateTitle()
200
    # 'order' category is deprecated. it is kept for compatibility.
201 202 203 204 205 206 207 208 209
    order = self.getOrderValue()
    if order is not None:
      return order.getTranslatedSimulationStateTitle()
    # The simulation_state of a simulation movement is calculated by a
    # mapping, there's no reliable way of getting the translated title from a
    # simulation state ID, so we just return the state ID because we got
    # nothing better to return.
    return self.getSimulationState()

210 211 212
  security.declareProtected(Permissions.AccessContentsInformation,
                            'isCompleted')
  def isCompleted(self):
213 214 215
    """Lookup business path and, if any, return True whenever
    simulation_state is in of completed state list defined on business path
    """
216
    # only available in BPM, so fail totally in case of working without BPM
217 218 219
    business_link =  self.getCausalityValue(
                         portal_type=self.getPortalBusinessLinkTypeList())
    if business_link is None:
220
      return False
221
    return self.getSimulationState() in business_link.getCompletedStateList()
222 223 224 225 226 227 228

  security.declareProtected(Permissions.AccessContentsInformation,
                            'isFrozen')
  def isFrozen(self):
    """Lookup business path and, if any, return True whenever
    simulation_state is in one of the frozen states defined on business path
    """
229 230
    if self._baseGetFrozen():
      return True
231 232 233
    business_link =  self.getCausalityValue(
                         portal_type=self.getPortalBusinessLinkTypeList())
    if business_link is None:
234 235 236 237 238 239
      # Legacy support - this should never happen
      # XXX-JPS ADD WARNING
      if self.getSimulationState() in ('stopped', 'delivered', 'cancelled'):
        return True
      if self._baseIsFrozen() == 0:
        self._baseSetFrozen(None)
240
      return False
241
    return self.getSimulationState() in business_link.getFrozenStateList()
242

243 244
  security.declareProtected( Permissions.AccessContentsInformation,
                            'isAccountable')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
245 246 247
  def isAccountable(self):
    """
      Returns 1 if this needs to be accounted
248 249 250
      Some Simulation movement corresponds to non accountable movements,
      the parent applied rule decide wether this movement is accountable
      or not.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
251
    """
252
    return self.getParentValue().isAccountable(self)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
253 254 255 256 257


  #######################################################
  # Causality Workflow Methods

258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
  security.declareProtected(Permissions.ModifyPortalContent, 'calculate')
  def calculate(self):
    """Move related delivery in 'calculating' state by activity

    Activity to update causality state is delayed until all related simulation
    movement are reindexed.
    This method should be only called by
    simulation_movement_causality_interaction_workflow.
    """
    delivery = self.getDeliveryValue()
    if delivery is not None:
      delivery = delivery.getRootDeliveryValue()
      tv = getTransactionalVariable()
      path = self.getPath()
      delivery_path = delivery.getPath()
      key = 'SimulationMovement.calculate', delivery_path
      try:
        tv[key].append(path)
      except KeyError:
        tv[key] = [path]
        def before_commit():
          method_id_list = ('immediateReindexObject',
                            'recursiveImmediateReindexObject')
          tag = delivery_path + '_calculate'
          delivery.activate(tag=tag).Delivery_calculate(activate_kw=
            {'after_path_and_method_id': (tv[key], method_id_list)})
          tv[key] = None # disallow further calls to 'calculate'
        transaction.get().addBeforeCommitHook(before_commit)

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
  security.declarePrivate('_getSuccessorTradePhaseList')
  def _getSuccessorTradePhaseList(self):
    """
    Get the list of future trade_phase categories from this simulation
    movement according to the related business process
    """
    # XXX-Leo this method could be smaller if (one or more of):
    #  * Simulation Movements had trade_state instead of trade_phase categories,
    #  * .asComposedDocument() also included the causality Business Link,
    #  * BusinessLink objects had a '.getSucessorTradePhaseList' method (accepting
    #      a context parameter for predicate checking).
    #  * .getBusinessLinkValueList() accepted a predecessor_link parameter,
    #  * some of the work below was done by a Business Process method,
    portal = self.getPortalObject()
    business_process = self.asComposedDocument()
    business_link_type_list = portal.getPortalBusinessLinkTypeList()
    business_link = self.getCausalityValue(portal_type=business_link_type_list)
    if business_link is None:
      # XXX-Leo we could just return self.getTradePhaseList() for
      # backward compatibility
      from Products.ERP5Type.Errors import SimulationError
Leonardo Rochael Almeida's avatar
Leonardo Rochael Almeida committed
308 309
      raise SimulationError('No Business Link Causality for %r. Cannot enumerate successor trade_phases.' % 
                            (self,))
310 311 312 313 314 315 316 317 318 319 320 321
    # from this Business Process, get the Business Links which
    # predecessor state match the successor state of our Business Link
    # causality
    successor_trade_state = business_link.getSuccessor()
    successor_link_list = business_process.getBusinessLinkValueList(
      context=self,
      predecessor=successor_trade_state)
    successor_trade_phase_list = [link.getTradePhase()
                                  for link in successor_link_list]

    return successor_trade_phase_list

322 323 324
  security.declarePrivate('_asSuccessorContext')
  def _asSuccessorContext(self):
    """ Returns a version of self with future trade phases
325 326 327 328
    """
    successor_trade_phase_list = self._getSuccessorTradePhaseList()
    context = self.asContext()
    context.edit(trade_phase_list=successor_trade_phase_list)
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
    return context

  security.declarePrivate('_checkSuccessorContext')
  def _checkSuccessorContext(self):
    # XXX turn this into a decorator?
    if not (self.isTempObject() and
            'trade_phase_list' in self._v_modified_property_dict):
      raise RuntimeError(
        'Method should only be called on self._asSuccessorContext()'
      )
 
  security.declarePrivate('_isSuccessorContext')
  def _isRuleStillApplicable(self, rule):
    self._checkSuccessorContext()
    return rule.test(self)

  security.declarePrivate('_getApplicableRuleList')
  def _getApplicableRuleList(self):
    """ Search rules that match this movement
    """
    self._checkSuccessorContext()
    portal_rules = self.getPortalObject().portal_rules
351 352 353
    # XXX-Leo: According to JP, the 'version' search below is wrong and
    # should be replaced by a check that there are not two rules with the
    # same reference that can be returned.
354
    return portal_rules.searchRuleList(self,
355 356 357
                                       sort_on='version',
                                       sort_order='descending')

Jean-Paul Smets's avatar
Jean-Paul Smets committed
358
  security.declareProtected(Permissions.ModifyPortalContent, 'expand')
359
  def expand(self, **kw):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
360
    """
361 362 363 364 365 366 367 368 369
    Checks all existing applied rules and make sure they still apply.
    Checks for other possible rules and starts expansion process (instanciates
    applied rules and calls expand on them).

    First get all applicable rules,
    then, delete all applied rules that no longer match and are not linked to
    a delivery,
    finally, apply new rules if no rule with the same type is already applied.
    """
370
    tv = getTransactionalVariable()
371 372 373 374 375 376 377 378 379
    cache = tv.setdefault(TREE_DELIVERED_CACHE_KEY, {})
    cache_enabled = cache.get(TREE_DELIVERED_CACHE_ENABLED, 0)

    # enable cache
    if not cache_enabled:
      cache[TREE_DELIVERED_CACHE_ENABLED] = 1

    applied_rule_dict = {}
    applicable_rule_dict = {}
380 381
    successor_self = self._asSuccessorContext()
    for rule in successor_self._getApplicableRuleList():
382 383
      reference = rule.getReference()
      if reference:
384 385
        # XXX-Leo: We should complain loudly if there is more than one
        # applicable rule per reference. It indicates a configuration error.
386
        applicable_rule_dict.setdefault(reference, rule)
387

388
    for applied_rule in list(self.objectValues()):
389
      rule = applied_rule.getSpecialiseValue()
390 391 392 393 394
      # check if applied rule is already expanded, or if its portal
      # rule is still applicable to this Simulation Movement with
      # successor trade_phases
      if (successor_self._isRuleStillApplicable(rule) or
          applied_rule._isTreeDelivered()):
395
        applied_rule_dict[rule.getReference()] = applied_rule
396
      else:
397
        self._delObject(applied_rule.getId())
398

399
    for reference, rule in applicable_rule_dict.iteritems():
400
      if reference not in applied_rule_dict:
401
        applied_rule = rule.constructNewAppliedRule(self, **kw)
402
        applied_rule_dict[reference] = applied_rule
403 404 405 406

    self.setCausalityState('expanded')
    # expand
    for applied_rule in applied_rule_dict.itervalues():
407
      applied_rule.expand(**kw)
408 409 410 411 412 413 414

    # disable and clear cache
    if not cache_enabled:
      try:
        del tv[TREE_DELIVERED_CACHE_KEY]
      except KeyError:
        pass
Jean-Paul Smets's avatar
Jean-Paul Smets committed
415 416 417 418 419 420 421 422 423 424

  security.declareProtected(Permissions.ModifyPortalContent, 'diverge')
  def diverge(self):
    """
       -> new status -> diverged

       Movements which diverge can not be expanded
    """
    self.setCausalityState('diverged')

425 426 427 428 429
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getExplanationValue')
  def getExplanationValue(self):
    """Returns the delivery if any or the order related to the root
    applied rule if any.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
430
    """
431 432
    delivery_value = self.getDeliveryValue()
    if delivery_value is None:
433
      # If the parent is not an Applied Rule, self does not have the method.
434 435
      getRootAppliedRule = getattr(self, 'getRootAppliedRule', None)
      if getRootAppliedRule is None:
436
        return None
437
      ra = getRootAppliedRule()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
438 439
      order = ra.getCausalityValue()
      if order is not None:
440
        return order
Jean-Paul Smets's avatar
Jean-Paul Smets committed
441 442
      else:
        # Ex. zero stock rule
443
        return ra
Jean-Paul Smets's avatar
Jean-Paul Smets committed
444
    else:
445 446
      explanation_value = delivery_value
      portal = self.getPortalObject()
Sebastien Robin's avatar
Sebastien Robin committed
447 448
      delivery_type_list = self.getPortalDeliveryTypeList() \
              + self.getPortalOrderTypeList()
449 450
      while explanation_value.getPortalType() not in delivery_type_list and \
          explanation_value != portal:
451
            explanation_value = explanation_value.getParentValue()
452
      if explanation_value != portal:
453
        return explanation_value
454

Jean-Paul Smets's avatar
Jean-Paul Smets committed
455
  # Deliverability / orderability
456 457
  security.declareProtected( Permissions.AccessContentsInformation,
                             'isOrderable')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
458
  def isOrderable(self):
459 460
    # the value of this method is no longer used.
    return True
Jean-Paul Smets's avatar
Jean-Paul Smets committed
461

462 463
  getOrderable = isOrderable

464 465
  security.declareProtected( Permissions.AccessContentsInformation,
                             'isDeliverable')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
466
  def isDeliverable(self):
467 468
    # the value of this method is no longer used.
    return True
Jean-Paul Smets's avatar
Jean-Paul Smets committed
469

470
  getDeliverable = isDeliverable
471

Kazuhiko Shiozaki's avatar
Kazuhiko Shiozaki committed
472 473 474
  security.declareProtected( Permissions.AccessContentsInformation,
                             'isDeletable')
  def isDeletable(self):
Nicolas Dumazet's avatar
Nicolas Dumazet committed
475
    return not self.isFrozen() and not self._isTreeDelivered()
Kazuhiko Shiozaki's avatar
Kazuhiko Shiozaki committed
476

477
  # Simulation Dates - acquire target dates
478 479
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getOrderStartDate')
480
  def getOrderStartDate(self):
481
    # 'order' category is deprecated. it is kept for compatibility.
482 483 484
    order_value = self.getOrderValue()
    if order_value is not None:
      return order_value.getStartDate()
485 486 487
    delivery_value = self.getDeliveryValue()
    if delivery_value is not None:
      return delivery_value.getStartDate()
488

489 490
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getOrderStopDate')
491
  def getOrderStopDate(self):
492
    # 'order' category is deprecated. it is kept for compatibility.
493 494 495
    order_value = self.getOrderValue()
    if order_value is not None:
      return order_value.getStopDate()
496 497 498
    delivery_value = self.getDeliveryValue()
    if delivery_value is not None:
      return delivery_value.getStopDate()
Romain Courteaud's avatar
Romain Courteaud committed
499

500 501
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getDeliveryStartDateList')
Romain Courteaud's avatar
Romain Courteaud committed
502 503
  def getDeliveryStartDateList(self):
    """
504
      Returns the stop date of related delivery
Romain Courteaud's avatar
Romain Courteaud committed
505 506 507 508 509 510
    """
    start_date_list = []
    delivery_movement = self.getDeliveryValue()
    if delivery_movement is not None:
      start_date_list.append(delivery_movement.getStartDate())
    return start_date_list
511

512 513
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getDeliveryStopDateList')
Romain Courteaud's avatar
Romain Courteaud committed
514 515
  def getDeliveryStopDateList(self):
    """
516
      Returns the stop date of related delivery
Romain Courteaud's avatar
Romain Courteaud committed
517 518 519 520 521 522
    """
    stop_date_list = []
    delivery_movement = self.getDeliveryValue()
    if delivery_movement is not None:
      stop_date_list.append(delivery_movement.getStopDate())
    return stop_date_list
523

524 525
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getDeliveryQuantity')
Romain Courteaud's avatar
Romain Courteaud committed
526 527
  def getDeliveryQuantity(self):
    """
528
      Returns the quantity of related delivery
Romain Courteaud's avatar
Romain Courteaud committed
529
    """
530
    quantity = 0.0
Romain Courteaud's avatar
Romain Courteaud committed
531 532 533 534
    delivery_movement = self.getDeliveryValue()
    if delivery_movement is not None:
      quantity = delivery_movement.getQuantity()
    return quantity
535

536 537
  security.declareProtected( Permissions.AccessContentsInformation,
                             'isConvergent')
538 539
  def isConvergent(self):
    """
540
      Returns true if the Simulation Movement is convergent with the
541
      the delivery value
542 543 544
    """
    return not self.isDivergent()

545
  security.declareProtected( Permissions.AccessContentsInformation,
546
      'isDivergent')
547 548
  def isDivergent(self):
    """
549
      Returns true if the Simulation Movement is divergent from the
550
      the delivery value
551
    """
552 553 554 555 556 557 558 559 560 561
    return self.getParentValue().isDivergent(self)

  security.declareProtected( Permissions.AccessContentsInformation,
      'getDivergenceList')
  def getDivergenceList(self):
    """
    Returns detailed information about the divergence
    """
    return self.getParentValue().getDivergenceList(self)

562 563
  security.declareProtected( Permissions.ModifyPortalContent,
                             'setDefaultDeliveryProperties')
564 565
  def setDefaultDeliveryProperties(self):
    """
566 567
    Sets the delivery_ratio and delivery_error properties to the
    calculated value
568 569 570 571 572
    """
    delivery = self.getDeliveryValue()
    if delivery is not None:
      delivery.updateSimulationDeliveryProperties(movement_list = [self])

573 574
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getCorrectedQuantity')
575 576
  def getCorrectedQuantity(self):
    """
577 578
    Returns the quantity property deducted by the possible profit_quantity and
    taking into account delivery error
579 580 581 582 583

    NOTE: XXX-JPS This method should not use profit_quantity. Profit and loss
          quantities are now only handled through explicit movements.
          Look are invocations of _isProfitAndLossMovement in
          ERP5.mixin.rule to understand how.
584
    """
585
    quantity = self.getQuantity()
586 587 588
    profit_quantity = self.getProfitQuantity() or 0
    delivery_error = self.getDeliveryError() or 0
    return quantity - profit_quantity + delivery_error
589

590 591
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getRootSimulationMovement')
592 593 594
  def getRootSimulationMovement(self):
    """
      Return the root simulation movement in the simulation tree.
595
      FIXME : this method should be called getRootSimulationMovementValue
596
    """
597
    parent_applied_rule = self.getParentValue()
598 599 600 601 602
    if parent_applied_rule.getRootAppliedRule() == parent_applied_rule:
      return self
    else:
      return parent_applied_rule.getRootSimulationMovement()

603 604
  security.declareProtected( Permissions.AccessContentsInformation,
                             'getRootSimulationMovementUid')
605 606 607 608 609 610 611 612 613
  def getRootSimulationMovementUid(self):
    """
      Return the uid of the root simulation movement in the simulation tree.
    """
    root_simulation_movement = self.getRootSimulationMovement()
    if root_simulation_movement is not None:
      return root_simulation_movement.getUid()
    return None

614
  security.declareProtected( Permissions.AccessContentsInformation,
615
                             'getRootCausalityValueList')
616 617 618 619 620 621 622 623
  def getRootCausalityValueList(self):
    """
      Returns the initial causality value for this movement.
      This method will look at the causality and check if the
      causality has already a causality
    """
    root_rule = self.getRootAppliedRule()
    return root_rule.getCausalityValueList()
624

625
  # XXX FIXME Use a interaction workflow instead
626
  # XXX This behavior is now done by simulation_movement_interaction_workflow
627
  # The call to activate() must be done after actual call to
628
  # setDelivery() on the movement,
629
  # but activate() must be called on the previous delivery...
630 631 632 633 634 635 636 637
  #def _setDelivery(self, value):
  #  LOG('setDelivery before', 0, '')
  #  delivery_value = self.getDeliveryValue()
  #  Movement.setDelivery(value)
  #  LOG('setDelivery', 0, '')
  #  if delivery_value is not None:
  #    LOG('delivery_value = ', 0, repr(delivery_value))
  #    activity = delivery_value.activate(
638
  #                activity='SQLQueue',
639
  #                after_path_and_method_id=(
640 641
  #                                        self.getPath(),
  #                                        ['immediateReindexObject',
642 643
  #                                         'recursiveImmediateReindexObject']))
  #    activity.edit()
644

645 646 647 648 649 650 651 652
  def _isTreeDelivered(self, ignore_first=0):
    """
    checks if subapplied rules  of this movement (going down the complete
    simulation tree) have a child with a delivery relation.
    Returns True if at least one is delivered, False if none of them are.

    see AppliedRule._isTreeDelivered
    """
653
    tv = getTransactionalVariable()
654 655 656 657
    cache = tv.setdefault(TREE_DELIVERED_CACHE_KEY, {})
    cache_enabled = cache.get(TREE_DELIVERED_CACHE_ENABLED, 0)

    def getTreeDelivered(movement, ignore_first=0):
658
      if not ignore_first:
659 660 661 662 663 664 665 666 667 668 669 670 671 672
        if len(movement.getDeliveryList()) > 0:
          return True
      for applied_rule in movement.objectValues():
        if applied_rule._isTreeDelivered():
          return True
      return False

    if ignore_first:
      rule_key = (self.getRelativeUrl(), 1)
    else:
      rule_key = self.getRelativeUrl()
    if cache_enabled:
      try:
        return cache[rule_key]
673
      except KeyError:
674 675 676 677 678 679
        result = getTreeDelivered(self, ignore_first=ignore_first)
        cache[rule_key] = result
        return result
    else:
      return getTreeDelivered(self, ignore_first=ignore_first)

680 681 682 683
  security.declareProtected(Permissions.AccessContentsInformation,
                            'isBuildable')
  def isBuildable(self):
    """Simulation Movement buildable logic"""
Jérome Perrin's avatar
Jérome Perrin committed
684
    if self.getDelivery():
685 686
      # already delivered
      return False
687

Sebastien Robin's avatar
Sebastien Robin committed
688
    # might be buildable - business path dependent
689
    business_link = self.getCausalityValue(portal_type='Business Link')
690
    explanation_value = self.getExplanationValue()
691
    if business_link is None or explanation_value is None:
692
      return True
Sebastien Robin's avatar
Sebastien Robin committed
693

Julien Muchembled's avatar
Julien Muchembled committed
694 695 696
    ## XXX Code below following line has been moved to BusinessPath (cf r37116)
    #return len(business_path.filterBuildableMovementList([self])) == 1

697
    predecessor_state = business_link.getPredecessor()
Sebastien Robin's avatar
Sebastien Robin committed
698
    if predecessor_state is None:
699
      # first one, can be built
700
      return True # XXX-JPS wrong cause root is marked
701

Sebastien Robin's avatar
Sebastien Robin committed
702 703
    # movement is not built, and corresponding business path
    # has predecessors: check movements related to those predecessors!
704 705 706
    composed_document = self.asComposedDocument()
    predecessor_link_list = composed_document.getBusinessLinkValueList(
            successor=predecessor_state)
Sebastien Robin's avatar
Sebastien Robin committed
707 708 709 710 711 712 713 714 715 716

    def isBuiltAndCompleted(simulation, path):
      return simulation.getCausalityValue() is not None and \
          simulation.getSimulationState() in path.getCompletedStateList()

    ### Step 1:
    ## Explore ancestors in ZODB (cheap)
    #

    # store a causality -> causality_related_movement_list mapping
Julien Muchembled's avatar
Julien Muchembled committed
717 718 719 720 721 722
    causality_dict = {}
    current = self.getParentValue().getParentValue()
    while current.getPortalType() == "Simulation Movement":
      causality_dict[current.getCausality(portal_type='Business Link')] = \
        current
      current = current.getParentValue().getParentValue()
Sebastien Robin's avatar
Sebastien Robin committed
723 724

    remaining_path_set = set()
725
    for path in predecessor_link_list:
Sebastien Robin's avatar
Sebastien Robin committed
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
      related_simulation = causality_dict.get(path.getRelativeUrl())
      if related_simulation is None:
        remaining_path_set.add(path)
        continue
      # XXX assumption is made here that if we find ONE completed ancestor
      # movement of self that is related to a predecessor path, then
      # that predecessor path is completed. Is it True? (aka when
      # Business Process goes downwards, is the maximum movements per
      # predecessor 1 or can we have more?)
      if not isBuiltAndCompleted(related_simulation, path):
        return False

    # in 90% of cases, Business Path goes downward and this is enough
    if not remaining_path_set:
      return True

742 743 744
    # XXX(Seb) All the code below is not tested and not documented.
    # Documentation must be written, the code must be reviewed or dropped

Sebastien Robin's avatar
Sebastien Robin committed
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848
    # But sometimes we have to dig deeper

    ### Step 2:
    ## Try catalog to find descendant movements, knowing
    # that it can be incomplete

    class treeNode(dict):
      """
      Used to cache accesses to ZODB objects.
      The idea is to put in visited_movement_dict the objects we've already
      loaded from ZODB in Step #2 to avoid loading them again in Step #3.

      - self represents a single ZODB container c
      - self.visited_movement_dict contains an id->(ZODB obj) cache for
        subobjects of c
      - self[id] contains the treeNode representing c[id]
      """
      def __init__(self):
        dict.__init__(self)
        self.visited_movement_dict = dict()

    path_tree = treeNode()
    def updateTree(simulation_movement, path):
      tree_node = path_tree
      movement_path = simulation_movement.getPhysicalPath()
      simulation_movement_id = movement_path[-1]
      # find container
      for path_id in movement_path[:-1]:
        tree_node = tree_node.setdefault(path_id, treeNode())
      # and mark the object as visited
      tree_node.visited_movement_dict[simulation_movement_id] = (simulation_movement, path)

    portal_catalog = self.getPortalObject().portal_catalog
    catalog_simulation_movement_list = portal_catalog(
      portal_type='Simulation Movement',
      causality_uid=[p.getUid() for p in remaining_path_set],
      path='%s/%%' % self.getPath())

    for movement in catalog_simulation_movement_list:
      path = movement.getCausalityValue()
      if not isBuiltAndCompleted(movement, path):
        return False
      updateTree(movement, path)

    ### Step 3:
    ## We had no luck, we have to explore descendant movements in ZODB
    #
    def descendantGenerator(document, tree_node, path_set_to_check):
      """
      generator yielding Simulation Movement descendants of document.
      It does _not_ explore the whole subtree if iteration is stopped.

      It uses the tree we built previously to avoid loading again ZODB
      objects that we already loaded during catalog querying

      path_set_to_check contains a set of Business Paths that we are
      interested in. A branch is only explored if this set is not
      empty; a movement is only yielded if its causality value is in this set
      """
      object_id_list = document.objectIds()
      for id in object_id_list:
        if id not in tree_node.visited_movement_dict:
          # we had not visited it in step #2
          subdocument = document._getOb(id)
          if subdocument.getPortalType() == "Simulation Movement":
            path = subdocument.getCausalityValue()
            t = (subdocument, path)
            tree_node.visited_movement_dict[id] = t
            if path in path_set_to_check:
              yield t
          else:
            # it must be an Applied Rule
            subtree = tree_node.get(id, treeNode())
            for d in descendantGenerator(subdocument,
                                         subtree,
                                         path_set_to_check):
              yield d

      for id, t in tree_node.visited_movement_dict.iteritems():
        subdocument, path = t
        to_check = path_set_to_check
        # do we need to change/copy the set?
        if path in to_check:
          if len(to_check) == 1:
            # no more paths to check in this branch
            continue
          to_check = to_check.copy()
          to_check.remove(path)
        subtree = tree_node.get(id, treeNode())
        for d in descendantGenerator(subdocument, subtree, to_check):
          yield d

    # descend in the tree to find self:
    tree_node = path_tree
    for path_id in self.getPhysicalPath():
      tree_node = tree_node.get(path_id, treeNode())

    # explore subobjects of self
    for descendant, path in descendantGenerator(self,
                                                tree_node,
                                                remaining_path_set):
      if not isBuiltAndCompleted(descendant, path):
        return False

849
    return True
850

851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888
  def getSolverProcessValueList(self, movement=None, validation_state=None):
    """
    Returns the list of solver processes which are
    are in a given state and which apply to delivery_or_movement.
    This method is useful to find applicable solver processes
    for a delivery.

    movement -- not applicable

    validation_state -- a state of a list of states
                        to filter the result
    """
    raise NotImplementedError

  def getSolverDecisionValueList(self, movement=None, validation_state=None):
    """
    Returns the list of solver decisions which apply
    to a given movement.

    movement -- not applicable

    validation_state -- a state of a list of states
                        to filter the result
    """
    raise NotImplementedError

  def getSolvedPropertyApplicationValueList(self, movement=None, divergence_tester=None):
    """
    Returns the list of documents at which a given divergence resolution
    can be resolved at. For example, in most cases, date divergences can
    only be resolved at delivery level whereas quantities are usually
    resolved at cell level.

    The result of this method is a list of ERP5 documents.

    movement -- not applicable
    """
    raise NotImplementedError
889 890 891 892

  security.declareProtected(Permissions.AccessContentsInformation,
                            'getMappedProperty')
  def getMappedProperty(self, property):
893
    mapping = self.getPropertyMappingValue()
894
    if mapping is not None:
895
      # Special case: corrected quantity is difficult to handle,
Yoshinori Okuji's avatar
Yoshinori Okuji committed
896
      # because, if quantity is inverse in the mapping, other
897
      # parameters, profit quantity (deprecated) and delivery error,
Yoshinori Okuji's avatar
Yoshinori Okuji committed
898
      # must be inverse as well.
899 900 901 902 903 904 905 906 907 908 909
      if property == 'corrected_quantity':
        mapped_quantity_id = mapping.getMappedPropertyId('quantity')
        quantity = mapping.getMappedProperty(self, 'quantity')
        profit_quantity = self.getProfitQuantity() or 0
        delivery_error = self.getDeliveryError() or 0
        if mapped_quantity_id[:1] == '-':
          # XXX what about if "quantity | -something_different" is
          # specified?
          return quantity + profit_quantity - delivery_error
        else:
          return quantity - profit_quantity + delivery_error
910
      return mapping.getMappedProperty(self, property)
Jérome Perrin's avatar
Jérome Perrin committed
911
    return self.getProperty(property)
912 913 914 915 916 917 918

  security.declareProtected(Permissions.ModifyPortalContent,
                            'setMappedProperty')
  def setMappedProperty(self, property, value):
    mapping = self.getPropertyMappingValue()
    if mapping is not None:
      return mapping.setMappedProperty(self, property, value)
Jérome Perrin's avatar
Jérome Perrin committed
919
    return self.setProperty(property, value)