droflo.py

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

def _renderExpression (session, out, req, res, definition, expression, mayRemove=1):

    log.debug \
        ('_renderExpression() class is %s' % expression.getClass())

    if _isMinor(session, expression): return

    expName = req.getParameter(P_EXP_NAME)
    expId = req.getParameter(P_EXP_ID)

    highlight = 0
    if expName and expId:
        if session.isInEditMode():
            highlight = \
                expression.equals(session.expressionToEdit)
        else:
            highlight = \
                (expression.id.expressionName == expName and \
                 expression.id.expressionId == expId)

    if highlight:
        out.println('<table class="table_w_border" cellpadding="1" cellspacing="0"><tr><td align=center bgcolor=#eeeeee>')
    
    renderer = _getRenderer(session, expression)
    renderer.render(out, req, res, session, definition, expression)

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

    if session.isInEditMode() and not session.expressionToEdit:
        if _isEditable(session, expression):
            _displayEditButton(req, res, out, expression.id)
            out.print('&nbsp;')
        if mayRemove:
            _displayRemoveButton(req, res, out, expression.id)


#
# BUTTON METHODS

def _displaySelect (out, selectName, options, selected=None):
    out.println('<select name="%s">' % selectName)
    for option in options:
        out.print('<option')
        if option == selected: 
            out.print(' selected')
        out.println('>%s</option>' % option)
    out.print('</select>')


def _displayAddButton (req, res, session, out, expressionId, message, expressions=None, position=-1):

    log.debug("_displayAddButton() for %s" % expressionId.toString())

    expId = expressionId.expressionId

    formName = 'add-%s' % expId

    out.print('<form ')
    out.print('name=%s ' % formName)
    out.print('method=POST>')

    out.print('<small>%s</small>' % message)

    if not expressions:
        expressions = _getClassicalExpressions(session)

    _displaySelect(out, NEW_EXP_NAME, expressions)

    link = '%s&%s=%s' % (ADD_EXPRESSION_ACTION, P_SUBPROCESS_EXP, expId)
    
    #if (position > -1):
    link = '%s&%s=%i' % (link, P_ADD_EXPRESSION_POSITION, position)

    link = res.encodeURL(link)

    out.print("""<a 
href="" 
onClick="submitForm('%s', '%s'); return false;"
>%s</a>""" % (formName, link, _img(req, IMG_PLUS)))

    out.print('</form>')


def _displayOkButton (req, res, out, formName, definition=None, flowExpressionId=None, action=UPDATE_ACTION, title='OK'):

    subProcessExp = ''

    if (definition and flowExpressionId):
        subProcessExp = '&%s=%s' % (P_SUBPROCESS_EXP, flowExpressionId.expressionId)

    out.print('<a href="" title="%s"' % title)
    out.print('onClick="submitForm(\'%s\',' % formName)
    out.print('\'%s' % res.encodeURL(action))
    out.print('%s\'); return false;"' % subProcessExp)
    out.print('>%s</a>' % _img(req, IMG_OK))


def _displaySimpleButton (res, out, href, button, title=None):
    out.print('<a href="%s"' % res.encodeURL(href))
    if title: out.print(' title="%s"' % title)
    out.print('>%s</a>' % button)


def _displayEditAsXmlButton (res, out):
    href = '%s&asxml=true' % (UPDATE_ACTION)
    _displaySimpleButton(res, out, href, 'edit as xml', 'Directly edit as XML')


def _displayButton (res, out, flowExpressionId, action, button, title=None):
    href = "droflo.action?action=%s&subProcessExp=%s" % (action, flowExpressionId.expressionId)
    _displaySimpleButton(res, out, href, button, title)


def _displayEditButton (req, res, out, flowExpressionId):
    _displayButton(res, out, flowExpressionId, 'edit', _img(req, IMG_EDIT), "Edit element")


def _displayRemoveButton (req, res, out, flowExpressionId):
    _displayButton(res, out, flowExpressionId, 'remove', _img(req, IMG_MINUS), "Remove Element")


def _displayUpButton (req, res, out, definition, flowExpressionId):
    _displayButton(res, out, flowExpressionId, 'moveup', _img(req, IMG_UP), "Move element up one place")


def _displayDownButton (req, res, out, definition, flowExpressionId):
    _displayButton(res, out, flowExpressionId, 'movedown', _img(req, IMG_DOWN), "Move element down one place")


def _displayMoveButtons (req, res, session, out, definition, compositeFlowExpression, flowExpressionId):

    #if not session.isInEditMode(): return

    if compositeFlowExpression.children.indexOf(flowExpressionId) > 0:
        _displayUpButton(req, res, out, definition, flowExpressionId)

    if compositeFlowExpression.children.indexOf(flowExpressionId) < (compositeFlowExpression.children.size()-1):
        _displayDownButton(req, res, out, definition, flowExpressionId)

#
# some help methods

def _getValue (expression, fieldName, fieldOptions=None):
    if not _isList(fieldName):
        val = expression.attributes.get(fieldName)
        if not val: val = ''
        return (None, val, fieldOptions)
    for fName in fieldName:
        val = expression.attributes.get(fName)
        if val: return (fName, val, fieldOptions)
    return (None, '', fieldOptions)

def _getExpressions (session, mustExclude=None):
    expNames = []
    for expName in session.expressionMap.keySet(): 
        expClass = session.expressionMap.getClass(expName)
        if mustExclude and mustExclude(expClass):
            continue
        if expName == '__raw__':
            continue
        if expName == 'define':
            continue
        if expName.endswith("-definition"):
            continue
        expNames.append(expName)
    expNames.sort()
    return expNames

def _getSyncExpressions (session):
    return _getExpressions(session, (lambda x: not expressions.sync.SyncExpression.isAssignableFrom(x)))

def _getConditionalExpressions (session):
    return _getExpressions(session, (lambda x: not expressions.BooleanExpression.isAssignableFrom(x)))

def _getClassicalExpressions (session):
    return _getExpressions \
        (session, \
         (lambda x: \
            expressions.BooleanExpression.isAssignableFrom(x) or \
            expressions.sync.SyncExpression.isAssignableFrom(x) or \
            expressions.raw.RawExpression.isAssignableFrom(x)))


#
# RENDERING CLASSES

class ExpressionRenderer:
    def render (self, out, req, res, session, definition, expression):
        if session.isInEditMode() and expression.equals(session.expressionToEdit):
            self._edit(out, req, res, session, definition, expression)
        else:
            self._render(out, req, res, session, definition, expression)

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


class Editable:
    def parseRequest (self, session, expression, req): pass
    def getHelpFileName (self): return None


#
# some helper classes


class BasicRenderer (ExpressionRenderer, Editable):

    def __init__ (self):

        self.mandatoryFields = None
        self.optionalFields = None

        self.fieldWidth = 30

        

    def _displayField (self, index, out, fieldName, fieldValue, isOptional):

        selectedFieldName, fieldValue, fieldOptions = fieldValue

        out.println('<tr>');

        out.print('<td align=right>');
        if _isList(fieldName):
            _displaySelect(out, 'field_%i_name' % index, fieldName, selectedFieldName)
        else:
            out.print('<small>');
            if isOptional: out.print('<i>');
            out.print(fieldName);
            if isOptional: out.print('</i>');
            out.print(' :</small>');
        out.println('</td>');

        if _isList(fieldName): 
            fieldName = 'field_%i_value' % index
            index = index+1

        out.print('<td align=left>');
        if fieldOptions:
            _displaySelect(out, fieldName, fieldOptions, selected=fieldValue)
        else:
            out.print('<input type=text name="%s" value="%s" size="%s">' % (fieldName, fieldValue, self.fieldWidth));

        out.println('</td>');
        out.println('</tr>');
        return index


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

        out.println('<form name=%s action=%s method=POST>' % (EDIT_FORM_NAME, UPDATE_ACTION))
        out.println('<table align="center">')

        # header
        out.println('<tr>')
        out.print('<td colspan=2 align=center>')
        out.print(session.getExpressionName(expression))
        out.println('</td>')
        out.println('</tr>')

        # fields

        i = 0

        if self.mandatoryFields:
            for fieldName in self.mandatoryFields:
                fieldOptions = None
                if _isTuple(fieldName):
                    fieldName, fieldOptions = fieldName
                field = _getValue(expression, fieldName, fieldOptions)
                i = self._displayField(i, out, fieldName, field, 0)

        if self.optionalFields:
            for fieldName in self.optionalFields:
                fieldOptions = None
                if _isTuple(fieldName):
                    fieldName, fieldOptions = fieldName
                field = _getValue(expression, fieldName, fieldOptions)
                i = self._displayField(i, out, fieldName, field, 1)

        # buttons
        out.println('<tr>')
        out.print('<td colspan=2 align=center>')
        #out.print('<a href="%s&asxml=true">edit as xml</a>' % UPDATE_ACTION)
        _displayEditAsXmlButton(res, out)
        out.print('&nbsp;&nbsp;')
        out.print('<input type=submit name=button value=cancel>')
        out.print('&nbsp;')
        out.println('<input type=submit name=button value=submit>')
        out.println('</td>')
        out.println('</tr>')

        # end
        out.println('</table>')
        out.println('</form>')


    def parseRequest (self, session, expression, req):

        attributes = HashMap()

        for fieldName in self.mandatoryFields:
            if _isList(fieldName): continue
            if _isTuple(fieldName):
                fieldName, fieldOptions = fieldName
            fieldValue = req.getParameter(fieldName)
            if not fieldValue: fieldValue = EMPTY_STRING
            attributes.put(fieldName, fieldValue)

        if self.optionalFields:
            for fieldName in self.optionalFields:
                if _isList(fieldName): continue
                if _isTuple(fieldName):
                    fieldName, fieldOptions = fieldName
                fieldValue = req.getParameter(fieldName)
                if fieldValue and fieldValue != '':
                    attributes.put(fieldName, fieldValue)

        i = 0
        while 1:
            fieldName = 'field_%i_name' % i
            fieldValue = 'field_%i_value' % i
            fieldName = req.getParameter(fieldName)
            if not fieldName: break
            fieldValue = req.getParameter(fieldValue)
            attributes.put(fieldName, fieldValue)
            i = i+1

        expression.attributes = attributes
        session.unloadExpressionToEdit()


#
# defaultExpressionRenderer

def _getAsXmlString (definition, expression):

    sXml = definition.toXmlString(expression)
    sXml = sXml.strip()

    if sXml.startswith('<?xml'):
        i = sXml.find('\n')
        sXml = sXml[i+1:]

    sXml = sXml.replace('>', '&gt;')
    sXml = sXml.replace('<', '&lt;')

    return sXml


class DefaultExpressionRenderer (ExpressionRenderer, Editable):


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

        out.print('<table><tr><td align="left">')
        out.print('<pre>')
        out.print(_getAsXmlString(definition, expression))
        out.print('</pre>')
        out.print('</td></tr></table>')


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

        sXml = _getAsXmlString(definition, expression)

        out.println('<form name=%s action=%s method=POST>' % (EDIT_FORM_NAME, UPDATE_ACTION))
        out.println('<table align=center>')

        out.println('<tr>')
        out.println('<td align=center>')
        out.println('<textarea name="sxml" cols="70" rows="14" wrap="off">')
        out.print(sXml)
        out.println('</textarea>')
        out.println('</td>')
        out.println('</tr>')

        out.println('<tr>')
        out.println('<td>')
        out.println('<input type="submit" name="%s" value="cancel">' % BUTTON)
        out.println('&nbsp;')
        out.println('<input type="submit" name="%s" value="submit">' % BUTTON)
        out.println('</td>')
        out.println('</tr>')

        out.println('</table>')


    def parseRequest (self, session, expression, req):

        if (req.getParameter(BUTTON) == 'submit'):

            sXml = req.getParameter('sxml')
            #log.debug('sXml is >%s<' % sXml)
            session.substituteBranch(expression.id, sXml)

        session.unloadExpressionToEdit()


#
# SequenceExpressionRenderer

class SequenceExpressionRenderer (ExpressionRenderer):

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

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

        children = _listChildren(session, expression)

        for fei in children:

            childExpression = definition.get(fei)
            out.println('<tr>')
            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('</td>')
            out.println('</tr>')

            if children.indexOf(fei) < len(children)-1:
                out.println('<tr>')
                out.print('<td align=center>')
                out.print(_img(req, IMG_ARROW))
                out.println('</td>')
                out.println('</tr>')
        
        out.println('</table>')

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

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

#
# ConcurrenceExpressionRenderer

class ConcurrenceExpressionRenderer (ExpressionRenderer, Editable):

    def __init__ (self):
        self.FORM_NAME = 'syncform'
        self.fieldNames = [ 'count', 'merge', 'merge-type', 'remaining' ]
        self.fields = [ 
            'count', 
            ('merge', ['first', 'last', 'highest', 'lowest']),
            ('merge-type', ['mix', 'override']),
            ('remaining', ['cancel', 'forget'])
        ]


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

        HEIGHT = 4
        WIDTH_MOD = 140

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

        width = expression.children.size()

        out.println('<tr>')
        out.print('<td colspan=%i align=center>' % width)
        out.print(_img(req, IMG_CONCURRENCE, width*WIDTH_MOD, HEIGHT))
        out.println('</td>')
        out.println('</tr>')

        out.println('<tr>')