droflo.py

OpenWFE是一个开放源码的Java工作流引擎。它是一个完整的业务处理管理套件：一个引擎

            inLeftColumn = not inLeftColumn

        out.println('</table>')

        out.println('</td>')
                
        out.println('</tr>')

        out.println('<tr>')
        out.print('<td colspan=2 align=left>')
        out.print('&lt;/%s&gt;' % session.getExpressionName(expression))

        if session.isInEditMode() and not session.expressionToEdit:

            _displayEditButton(req, res, out, expression.id)

            out.println('<br><br>')

            _displayAddButton(req, res, session, out, expression.id, 'add to %s<br>\n' % session.getExpressionName(expression), _getExpressions(session))

        out.println('</td>')
        out.println('</tr>')
        out.println('</table>')


#
# DefaultCompositeRenderer

class DefaultCompositeRenderer (ExpressionRenderer):

    def _render (self, out, req, res, session, definition, expression):

        out.println('<table cellpadding="1" cellspacing="1">')

        out.println('<tr>')

        out.print('<td class="w_border" rowspan="3">')
        out.print('</td>\n')

        out.print('<td colspan=2 align=left>')
        out.print('&lt;%s&gt;' % session.getExpressionName(expression))
        out.println('</td>')
        out.println('</tr>')

        out.println('<tr>')
        out.println('<td>&nbsp;&nbsp;</td>')

        out.println('<td align=left>')

        out.println('<table>')

        for fei in expression.children:

            childExpression = definition.get(fei)

            out.print('<tr><td align=center>')

            _renderExpression(session, out, req, res, definition, childExpression)

            if session.isInEditMode() and not session.expressionToEdit:
                _displayMoveButtons(req, res, session, out, definition, expression, fei)

            out.println('</td></tr>')

        out.println('</table>')

        out.println('</td>')
                
        out.println('</tr>')

        out.println('<tr>')
        out.print('<td colspan=2 align=left>')
        out.print('&lt;/%s&gt;' % session.getExpressionName(expression))

        if session.isInEditMode() and not session.expressionToEdit:
            out.println('<br><br>')

            _displayAddButton(req, res, session, out, expression.id, 'add to %s<br>\n' % session.getExpressionName(expression), _getExpressions(session))

        out.println('</td>')
        out.println('</tr>')
        out.println('</table>')


#
# EqualsExpressionRenderer and friends

class EqualsExpressionRenderer (BasicRenderer):

    def __init__ (self):
        BasicRenderer.__init__(self)
        self.mandatoryFields = [ VALUE_OPTIONS, OTHER_OPTIONS ]
        #self.optionalFields = [ ]
        self.operator = '=='

    def _render (self, out, req, res, session, definition, expression):
        name, value, options = _getValue(expression, VALUE_OPTIONS)
        otherName, otherValue, options = _getValue(expression, OTHER_OPTIONS)

        name = _neutralize(name)
        value = _neutralize(value)
        otherName = _neutralize(otherName)
        otherValue = _neutralize(otherValue)

        out.print('%s::%s %s %s::%s&nbsp;' % (name, value, self.operator, otherName, otherValue))

    def getHelpFileName (self):
        return 'h_comparison.htm'


class NotEqualsExpressionRenderer (EqualsExpressionRenderer):

    def __init__ (self):
        EqualsExpressionRenderer.__init__(self)
        self.operator = '!='


class ComparisonExpressionRenderer (EqualsExpressionRenderer):

    def __init__ (self):
        EqualsExpressionRenderer.__init__(self)
        self.optionalFields = [ ('equals', [ '', 'true' ]) ]
        self.operator = '?'

    def _render (self, out, req, res, session, definition, expression):
        if expression.orEquals(None) and len(self.operator) <= 1:
            self.operator += '='
        EqualsExpressionRenderer._render(self, out, req, res, session, definition, expression)


class GreaterThanExpressionRenderer (ComparisonExpressionRenderer):
    def __init__ (self):
        ComparisonExpressionRenderer.__init__(self)
        self.operator = '>'

class LesserThanExpressionRenderer (ComparisonExpressionRenderer):
    def __init__ (self):
        ComparisonExpressionRenderer.__init__(self)
        self.operator = '<'

#
# ParticipantExpressionRenderer

def cutDate (date):
    if not date: return None
    i = date.rfind('+')
    j = date.rfind('-')
    if i > j:
        return date[:i]
    else:
        return date[:j]


def determineReplyTime (session, expressionId):
    """
        Returns the datetime string at which a given expression was
        replied to.
        A help method for the ParticipantExpressionRenderer.
    """
    for hi in session.workItem.history:

        if not hi.expressionId == expressionId: continue
        if not hi.text == 'ok': continue

        return cutDate(hi.date)

    return None


def determineDispatchTime (session, expressionId):
    """
        If the expressionId matches the lastExpression for the workitem, will
        return the dispatch time
    """
    if session.workItem.lastExpressionId.expressionId != expressionId: 
        return None
    return cutDate(session.workItem.dispatchTime)


class ParticipantExpressionRenderer (BasicRenderer):

    def __init__ (self):
        BasicRenderer.__init__(self)
        self.mandatoryFields = [ REFS ]
        self.optionalFields = [ 'default-ref', 'else-ref', 'timeout', 'description', 'filter' ]

    def _render (self, out, req, res, session, definition, expression):
        refType = None
        refValue = None
        for r in REFS:
            v = expression.attributes.get(r)
            if v:
                refType = r
                refValue = v
                break

        out.print('<table>')
        out.print('<tr>')
        out.print('<td valign="top">')

        out.print(_img(req, IMG_PARTICIPANT))

        out.print('</td>')
        out.print('<td valign="top">')

        out.print('<small>participant : </small><br>\n')
        if refType:
            out.print(_neutralize(refType))
            out.print('::')
            out.print(_neutralize(refValue))
        else:
            out.print('---')
        out.print('&nbsp;')

        elseRef = expression.attributes.get('else-ref')
        if elseRef:
            out.print('<br>\n')
            out.print('else-ref::')
            out.print(_neutralize(elseRef))

        if not session.isInEditMode() and session.workItem:

            #if not session.workItem: return

            replyTime = determineReplyTime(session, expression.id.expressionId)
            if replyTime:
                out.print('<br>\n')
                out.print('<small>reply time : %s</small>&nbsp;' % replyTime)

            dispatchTime = determineDispatchTime(session, expression.id.expressionId)
            if dispatchTime:
                out.print('<br>\n')
                out.print('<small>dispatch time : %s</small>&nbsp;' % dispatchTime)
        out.print('</td>')
        out.print('</tr>')
        out.print('</table>')

    def getHelpFileName (self):
        return 'h_participant.htm'


#
# save and restore expression renderer

class SaveExpressionRenderer (BasicRenderer):

    def __init__ (self):
        BasicRenderer.__init__(self)
        self.mandatoryFields = [ TO_VARIABLE ]

    def _render (self, out, req, res, session, definition, expression):
        out.println('save<br>')
        out.println('%s : &nbsp;' % TO_VARIABLE)
        out.print(_neutralize(_getValue(expression, TO_VARIABLE)[1]))

    def getHelpFileName (self):
        return 'h_save.htm'


class RestoreExpressionRenderer (BasicRenderer):

    def __init__ (self):
        BasicRenderer.__init__(self)
        self.mandatoryFields = [ FROM_VARIABLE ]
        self.optionalFields = [ ('merge-lead', ['', 'restored', 'current']), 'to-field' ]

    def _render (self, out, req, res, session, definition, expression):
        out.println('restore<br>')
        out.println('%s : &nbsp;' % FROM_VARIABLE)
        out.print(_neutralize(_getValue(expression, FROM_VARIABLE)[1]))

    def getHelpFileName (self):
        return 'h_restore.htm'


#
# Unset/SetExpressionRenderer


class SetExpressionRenderer (BasicRenderer):

    def __init__ (self):
        BasicRenderer.__init__(self)
        self.mandatoryFields = [ OPTIONS, VALUE_OPTIONS ]
        self.optionalFields = [ ('override', ['', 'true']), ('type', ['', 'boolean', 'integer', 'long', 'double']) ]
        self.operator = '='

    def _render (self, out, req, res, session, definition, expression):
        targetName, targetValue, nada = _getValue(expression, OPTIONS)
        sourceName, sourceValue, nada = _getValue(expression, VALUE_OPTIONS)

        name = '?'
        value = '?'

        if targetName:
            name = _neutralize('%s::"%s"' % (targetName, targetValue))
        if sourceName:
            value = _neutralize('%s::"%s"' % (sourceName, sourceValue))

        out.print('<small>%s (</small>' % session.getExpressionName(expression))
        out.print('%s %s %s' % (name, self.operator, value))
        out.print('<small>)</small>&nbsp;')

    def getHelpFileName (self):
        return 'h_set.htm'


class UnsetExpressionRenderer (BasicRenderer):

    def __init__ (self):
        BasicRenderer.__init__(self)
        self.mandatoryFields = [ OPTIONS ]
        #self.optionalFields = [ ]

    def _render (self, out, req, res, session, definition, expression):
        targetName, targetValue, nada = _getValue(expression, OPTIONS)

        name = '?'

        if targetName:
            name = '%s::"%s"' % (targetName, targetValue)

        out.print('<small>unset (</small>')
        out.print(_neutralize(name))
        out.print('<small>)</small>&nbsp;')

    def getHelpFileName (self):
        return 'h_unset.htm'


class IncrementExpressionRenderer (SetExpressionRenderer):
    def __init__ (self):
        SetExpressionRenderer.__init__(self)
        self.operator = '+='
    def getHelpFileName (self):
        return None


class SleepExpressionRenderer (BasicRenderer):

    def __init__ (self):
        BasicRenderer.__init__(self)
        #self.mandatoryFields = [ OPTIONS ]
        self.optionalFields = [ 'for', 'until' ]

    def _render (self, out, req, res, session, definition, expression):

        aFor = expression.attributes.get('for')
        aUntil = expression.attributes.get('until')

        out.print('<small>sleep ')

        if aFor:
            out.print('for %s' % aFor)
        elif aUntil:
            out.print("until %s" % aUntil)

        out.print('</small>&nbsp;')

    def getHelpFileName (self):
        return 'h_sleep.htm'


#
# subProcessRefExpression renderer

class SubProcessRefExpressionRenderer (BasicRenderer):

    def __init__ (self):
        BasicRenderer.__init__(self)
        self.mandatoryFields = REFS
        self.optionalFields = [ ('forget', ['', 'true']), 'fields' ]
        self.fieldWidth = 70

    def _determineRef (self, expression):
        tuple = None
        if expression.attributes.get(VARIABLE_REF):
            tuple = (VARIABLE_REF, expression.attributes[VARIABLE_REF])
        elif expression.attributes.get(FIELD_REF):
            tuple = (FIELD_REF, expression.attributes[FIELD_REF])
        else:
            tuple = (REF, expression.attributes.get(REF))
        return '<small>%s</small>::%s' % tuple

    def _render (self, out, req, res, session, definition, expression):
        out.print('<table>\n')
        out.print('<tr>\n')
        out.print('<td>')
        out.print(_img(req, IMG_SUBPROCESS))
        out.print('</td>\n')
        out.print('<td>\n')
        out.print('subprocess call')
        out.print('<br>\n%s' % self._determineRef(expression))
        out.print('</td>\n')
        out.print('</tr>\n')
        out.print('</table>\n')

    def getHelpFileName (self):
        return 'h_subprocess.htm'


#
# {Undefined|Defined}Expression renderer

class DefinedExpressionRenderer (BasicRenderer):

    def __init__ (self):
        BasicRenderer.__init__(self)
        self.mandatoryFields = [ VALUE_OPTIONS[1:] ]
            # without 'value'
        #self.optionalFields = [ ]

    def _determineItem (self, expression):
        tuple = None
        if expression.attributes.get(VARIABLE_VALUE):
            tuple = (VARIABLE_VALUE, expression.attributes[VARIABLE_VALUE])
        elif expression.attributes.get(FUNCTION_VALUE):
            tuple = (FUNCTION_VALUE, expression.attributes[FUNCTION_VALUE])
        else:
            tuple = (FIELD_VALUE, expression.attributes.get(FIELD_VALUE))
        return '<small>%s</small>::%s' % tuple

    def _render (self, out, req, res, session, definition, expression):
        qualifier = 'undefined'
        if expressions.DefinedExpression.isAssignableFrom(expression.class):
            qualifier = 'defined'
        item = self._determineItem(expression)
        out.print('%s is %s' % (item, qualifier))

    def getHelpFileName (self):
        if expressions.DefinedExpression.isAssignableFrom(expression.class):
            return 'h_defined.htm'
        return 'h_undefined.htm'



#
# FILLING THE RENDERER_MAP

RENDERER_MAP[expressions.SequenceExpression] = SequenceExpressionRenderer
#RENDERER_MAP[expressions.FlatSequenceExpression] = SequenceExpressionRenderer
RENDERER_MAP[expressions.ParticipantExpression] = ParticipantExpressionRenderer
RENDERER_MAP[expressions.SetValueExpression] = SetExpressionRenderer
RENDERER_MAP[expressions.UnsetValueExpression] = UnsetExpressionRenderer
RENDERER_MAP[expressions.IncrementExpression] = IncrementExpressionRenderer
RENDERER_MAP[expressions.ConcurrenceExpression] = ConcurrenceExpressionRenderer
RENDERER_MAP[expressions.IfExpression] = IfExpressionRenderer
RENDERER_MAP[expressions.CaseExpression] = CaseExpressionRenderer
RENDERER_MAP[expressions.WhenExpression] = WhenExpressionRenderer
RENDERER_MAP[expressions.OrExpression] = BooleanCombinationExpressionRenderer
RENDERER_MAP[expressions.AndExpression] = BooleanCombinationExpressionRenderer
RENDERER_MAP[expressions.NotExpression] = OneChildConditionalRenderer
RENDERER_MAP[expressions.EqualsExpression] = EqualsExpressionRenderer
RENDERER_MAP[expressions.NotEqualsExpression] = NotEqualsExpressionRenderer
RENDERER_MAP[expressions.GreaterThanExpression] = GreaterThanExpressionRenderer
RENDERER_MAP[expressions.LesserThanExpression] = LesserThanExpressionRenderer
RENDERER_MAP[expressions.SubProcessRefExpression] = SubProcessRefExpressionRenderer
RENDERER_MAP[expressions.DefinedExpression] = DefinedExpressionRenderer
RENDERER_MAP[expressions.UndefinedExpression] = DefinedExpressionRenderer
RENDERER_MAP[expressions.SaveExpression] = SaveExpressionRenderer
RENDERER_MAP[expressions.RestoreExpression] = RestoreExpressionRenderer
RENDERER_MAP[expressions.IteratorExpression] = IteratorExpressionRenderer
RENDERER_MAP[expressions.ConcurrentIteratorExpression] = ConcurrentIteratorExpressionRenderer
RENDERER_MAP[expressions.SleepExpression] = SleepExpressionRenderer
RENDERER_MAP[expressions.CronExpression] = CronExpressionRenderer
#RENDERER_MAP[expressions.DefineExpression] = DefineExpressionRenderer

RENDERER_MAP[expressions.WhileExpression] = OneChildConditionalRenderer
RENDERER_MAP[expressions.UntilExpression] = OneChildConditionalRenderer

MINOR_EXPNAMES.append('set')
MINOR_EXPNAMES.append('unset')