droflo.py

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

        # a swimlane for each child

        for fei in expression.children:
            childExpression = definition.get(fei)

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

            out.print(_img(req, IMG_ARROW))
            out.println('<br>')

            _renderExpression(session, out, req, res, definition, childExpression)
            #_displayMoveButtons(req, session, out, definition, expression, fei)
            out.println('<br>')
            out.print(_img(req, IMG_ARROW))

            out.println('</td>')

        out.println('</tr>')

        # bottom bar and sync

        out.println('<tr>')
        out.print('<td colspan=%i align=center>' % width)
        out.print(_img(req, IMG_CONCURRENCE, width*WIDTH_MOD, HEIGHT))
        out.println('<br>')
        out.print('<small>sync : </small>')
        if session.isInEditMode() and expression.equals(session.expressionToEdit):
            out.print('<form name=%s>' % self.FORM_NAME)
            out.print('<table>\n')
            for f in self.fields:
                out.print('<tr>\n')
                if _isTuple(f):
                    fieldName, fieldValues = f
                    selectedValue = expression.attributes.get(fieldName)
                    out.print('<td align=right>%s : </td>\n' % fieldName)
                    out.print('<td>');
                    _displaySelect(out, fieldName, fieldValues, selected=selectedValue)
                    out.print('</td>\n');
                else:
                    #value = _getValue(expression, f)
                    value = expression.attributes.get(f)
                    if not value: value = ''
                    out.print('<td align=right>%s : </td>\n' % f)
                    out.print('<td>');
                    out.print('<input type=text name="%s" value="%s" size="%s">' % (f, value, 5))
                    out.print('</td>\n');
                out.print('</tr>\n')
            out.print('</table>\n')
            _displayOkButton(req, res, out, self.FORM_NAME, definition, expression.id)
            out.print('</form>')
        else:
            #out.print(session.getExpressionName(expression.syncExpression))
            co = expression.attributes.get('count')
            mg = expression.attributes.get('merge')
            mt = expression.attributes.get('merge-type')
            rm = expression.attributes.get('remaining')
            if not co: co = '*'
            if not mg: mg = 'first'
            if not mt: mt = 'mix'
            if not rm: rm = 'cancel'
            out.print('<br>\ncount:%s  merge:%s  merge-type:%s  remaining:%s' % (co, mg, mt, rm))
        out.println('</td>')
        out.println('</tr>')
        
        out.println('</table>')

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

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


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


    def parseRequest (self, session, expression, req):
        attributes = HashMap()
        attributes.put('sync', 'generic')
        for fn in self.fieldNames:
            fv = req.getParameter(fn)
            attributes.put(fn, fv)
        expression.attributes = attributes
        session.unloadExpressionToEdit()


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

#
# IfExpressionRenderer

class IfExpressionRenderer (BasicRenderer):

    def __init__ (self):

        BasicRenderer.__init__(self)
        self.mandatoryFields = []
        self.optionalFields = [ 'test' ]


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

        aTest = None
        eCondition = None
        eThen = None
        eElse = None

        aTest = expression.attributes['test']

        for childId in expression.children:
            childExp = definition.get(childId)
            if aTest:
                if not eThen:
                    eThen = childExp
                elif not eElse:
                    eElse = childExp
            else:
                if not eCondition and isinstance(childExp, expressions.BooleanExpression):
                    eCondition = childExp
                elif not eThen:
                    eThen = childExp
                elif not eElse:
                    eElse = childExp

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

        out.println('<tr>')
        out.print('<td align="right">')
        out.print(_img(req, IMG_BRANCH))
        out.print('</td>\n')
        out.println('<td align="left">')
        out.print('if<br>\n')
        if aTest: 
            out.print(' "%s"' % aTest)
        else:
            if eCondition:
                _renderExpression(session, out, req, res, definition, eCondition)
            elif session.isInEditMode():
                _displayAddButton(req, res, session, out, expression.id, 'Add conditional clause<br>\n', _getConditionalExpressions(session))
        out.println('</td>')
        out.println('</tr>')

        out.println('<tr>')
        out.println('<td colspan="2" align="center">')

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

        out.print('<td align="right">')
        out.print('then<br>\n')
        out.print('</td>\n')

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

        out.print('<td align="left">')
        out.print('else<br>\n')
        out.print('</td>\n')

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

        # display then 
        out.print('<td align="center" valign="middle">')
        if eThen:
            _renderExpression(session, out, req, res, definition, eThen)
        elif eCondition and session.isInEditMode():
            _displayAddButton(req, res, session, out, expression.id, 'Add then clause<br>\n', _getClassicalExpressions(session))
        out.print('</td>\n')

        # display else 
        out.print('<td align="center" valign="middle">')
        if eElse:
            _renderExpression(session, out, req, res, definition, eElse)
        elif eCondition and eThen and session.isInEditMode():
            _displayAddButton(req, res, session, out, expression.id, 'Add else clause<br>\n', _getClassicalExpressions(session))
        out.println('</td>')

        out.println('</tr>')

        out.println('</table>')

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


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

#
# WhenExpressionRenderer

class WhenExpressionRenderer (ExpressionRenderer):

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

        expressionName = session.getExpressionName(expression)

        eCondition = None
        eThen = None

        eOne = None
        #eOneId = None
        eTwo = None
        #eTwoId = None

        if len(expression.children) > 0:
            eOneId = expression.children.get(0)
            eOne = definition.get(eOneId)
        if len(expression.children) > 1:
            eTwoId = expression.children.get(1)
            eTwo = definition.get(eTwoId)

        if eOne and not eTwo:
            if isinstance(eOne, expressions.ComparisonExpression):
                eCondition = eOne
            else:
                eThen = eOne
        elif eTwo:
            eCondition = eOne
            eThen = eTwo

            # no enforcement by the renderer here...

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

        out.println('<tr>')

        # diamond and condition
        out.print('<td align=center valign=top colspan=2>')
        out.print(_img(req, IMG_BRANCH))
        out.println('<br>')
        out.println('%s<br>' % expressionName)

        if eCondition:
            _renderExpression(session, out, req, res, definition, eCondition)
        elif session.isInEditMode():
            _displayAddButton(req, res, session, out, expression.id, 'Add conditional clause<br>\n', _getConditionalExpressions(session), 0)
                #
                # position is set to 0 (first child)

        out.println('<br>\n&nbsp;')

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

        # then clause
        out.println('<tr>')

        out.print('<td align=right valign=top>')
        out.print(_img(req, IMG_ARROW_TO_RIGHT))
        out.println('</td>')

        out.print('<td align=center valign=top>')
        if eThen:
            _renderExpression(session, out, req, res, definition, eThen)
        elif session.isInEditMode():
            _displayAddButton(req, res, session, out, expression.id, 'Add then clause<br>\n', _getClassicalExpressions(session))
        out.print('</td>')

        out.println('</tr>')

        # end
        out.print('</table>')


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


#
# [Concurrent]IteratorExpressionRenderer


class IteratorExpressionRenderer (BasicRenderer):

    def __init__ (self):

        BasicRenderer.__init__(self)
        self.mandatoryFields = [ [ 'on-value', 'on-field-value', 'on-variable-value' ], [ 'to-field', 'to-variable' ] ]
        self.optionalFields = [ 'value-separator' ]
        #self.arrowCount = 1


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

        expressionName = session.getExpressionName(expression)

        onKey = _getKeyWithPrefix(expression, 'on-')
        toKey = _getKeyWithPrefix(expression, 'to-')
        onValue = _neutralize(expression.attributes.get(onKey))
        toValue = _neutralize(expression.attributes.get(toKey))

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

        out.println('<tr>')
        out.print('<td align="right" valign="top">')
        out.print('%s<br>\n' % expressionName)
        if onKey:
            out.print('%s : %s<br>\n' % (onKey, onValue))
        if toKey:
            out.print('%s : %s' % (toKey, toValue))
        out.print('<br>\n')
        out.print(_img(req, IMG_ITERATOR))
        out.println('</td>')

        out.print('<td class="w_border">')
        #out.print('&nbsp;')
        out.print('</td>\n')

        out.println('<td align="center" valign="top">')
        child = definition.get(expression.childExpressionId)
        if child :
            _renderExpression(session, out, req, res, definition, child)
        elif session.isInEditMode():
            _displayAddButton(req, res, session, out, expression.id, 'Add body to iteration<br>\n', _getClassicalExpressions(session))
        out.println('</td>')

        out.println('</tr>')

        out.println('</table>')


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


class ConcurrentIteratorExpressionRenderer (IteratorExpressionRenderer):

    def __init__ (self):
        IteratorExpressionRenderer.__init__(self)
        self.arrowCount = 2


#
# BooleanCombinationExpressionRenderer

class BooleanCombinationExpressionRenderer (ExpressionRenderer, Editable):

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

        expressionName = session.getExpressionName(expression)
        out.print('(')

        for fei in expression.children:
            eChild = definition.get(fei)
            _renderExpression(session, out, req, res, definition, eChild)
            if expression.children.indexOf(fei) < len(expression.children)-1:
                out.println(' %s<br>' % expressionName)

        out.print(')')


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

        self._render(out, req, res, session, definition, expression)
        out.println('<br>')
        _displayAddButton(req, res, session, out, expression.id, 'Add conditional clause<br>\n', _getConditionalExpressions(session))


#
# OneChildConditionalExpressionRenderer

class OneChildConditionalRenderer (ExpressionRenderer):

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

        isANot = isinstance(expression, expressions.NotExpression)

        if isANot: out.print('(')
        out.print(expression.id.expressionName+' ')

        iChild = expression.childExpressionId

        if iChild:

            eChild = definition.get(iChild)

            _renderExpression(session, out, req, res, definition, eChild)
        
        elif session.isInEditMode():

            _displayAddButton(req, res, session, out, expression.id, 'Add conditional clause<br>\n', _getConditionalExpressions(session))

        if isANot: out.print(' )')


#
# CronExpressionRenderer

class CronExpressionRenderer (BasicRenderer):

    def __init__ (self):
        BasicRenderer.__init__(self)
        self.mandatoryFields = [ 'tab' ]
        self.optionalFields = [ ('level', [ '', '/', '//' ]), 'name' ]

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

        tab = expression.attributes.get('tab')
        level = expression.attributes.get('level')
        name = expression.attributes.get('name')

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

        out.print('<td valign=top align=right>')
        out.print(_img(req, 'cron.png'))
        out.println('<br>')
        out.println('cron<br>')
        out.println('tab : %s<br>' % tab)
        out.println('level : %s' % level)
        if name:
            out.println('<br>name : %s<br>' % name)
        out.println('</td>')

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

        out.print('<td align=center valign=top>')
        out.println('&nbsp;<br>')
        if expression.childExpressionId:
            eChild = definition.get(expression.childExpressionId)
            _renderExpression(session, out, req, res, definition, eChild)
        out.println('</td>')

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


#
# CaseExpressionRenderer

class CaseExpressionRenderer (DefaultExpressionRenderer):

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

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

        out.println('<tr>')
        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>')

        inLeftColumn = 1

        for fei in expression.children:

            childExpression = definition.get(fei)

            if inLeftColumn:
                out.println('<tr><td align=right valign=top>')
            else:
                out.print('<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('<br>')
            out.println('</td>')

            if not inLeftColumn:
                out.println('</tr>')