droflo.py

日常的办公系统 应用工作流框架等增加员工的基本信息、培训信息、奖罚信息、薪资信息

#def _renderExpression (session, out, req, definition, expression, mayRemove=1, isScopedConditional=0):
def _renderExpression (session, out, req, definition, expression, mayRemove=1):

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

    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 border=1 cellpadding=1 cellspacing=0><tr><td align=center bgcolor=#eeeeee>')
    
    renderer = _getRenderer(expression)
    renderer.render(out, req, session, definition, expression)

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

    if session.isInEditMode() and not session.expressionToEdit:
        if _isEditable(expression):
            _displayEditButton(req, out, expression.id)
            out.print('&nbsp;')
        if mayRemove:
            _displayRemoveButton(req, 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, session, out, expressionId, message, expressions=None):

    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)

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

    out.print('</form>')


def _displayOkButton (req, out, formName, definition=None, flowExpressionId=None, action=UPDATE_ACTION):

    subProcessExp = ''

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

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


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


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


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


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


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


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


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

    #if not session.isInEditMode(): return

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

    if compositeFlowExpression.children.indexOf(flowExpressionId) < (compositeFlowExpression.children.size()-1):
        _displayDownButton(req, 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):
    expNames = []
    for expName in session.expressionMap.keySet(): 
        expClass = session.expressionMap.getClass(expName)
        if mustExclude(expClass):
            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, session, definition, expression):
        if session.isInEditMode() and expression.equals(session.expressionToEdit):
            self._edit(out, req, session, definition, expression)
        else:
            self._render(out, req, session, definition, expression)

    def _render (self, out, req, session, definition, expression): pass
    def _edit (self, out, req, 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, session, definition, expression):

        out.println('<form name=%s action=%s method=POST>' % (EDIT_FORM_NAME, UPDATE_ACTION))
        out.println('<table border=0 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('<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

class DefaultExpressionRenderer (ExpressionRenderer, Editable):

    def _render (self, out, req, session, definition, expression):
        out.print(_img(req, IMG_PARTICIPANT))
        out.println('<br>')
        out.print(session.getExpressionName(expression))
        out.print('&nbsp;')

    def _edit (self, out, req, session, definition, expression):
        out.println('<form name=%s action=%s method=POST>' % (EDIT_FORM_NAME, UPDATE_ACTION))
        out.println('<table border=0 align=center>')

        # header

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

        # body

        i = 0
        for key in expression.attributes.keySet():

            value = expression.attributes.get(key);

            out.println('<tr>')
            out.print('<td align=right>')
            out.print('<input type=text name=key_%i value="%s">' % (i, key))
            out.println(' : </td>')
            out.print('<td align=left>')
            out.print('<input type=text name=value_%i value="%s">' % (i, value))
            out.print('&nbsp;')

            out.print("""<a
href="" 
onClick="submitForm('%s', '%s&button=remove&key=%s'); return true;"
>""" % (EDIT_FORM_NAME, UPDATE_ACTION, key))

            out.print(_img(req, IMG_MINUS))
            out.print('</a>')
            out.println('</td>')
            out.println('</tr>')

            i = i+1

        # buttons
        
        out.println('<tr>')
        out.print('<td colspan=2 align=center>')
        out.print('<input type=submit name=button value="%s">' % P_ADD_PARAM)
        out.print('&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):

        buttonValue = req.getParameter(BUTTON)
        #log.debug('buttonValue is >%s<' % buttonValue)

        newAttributes = HashMap()

        #
        # add param ?
        
        if P_ADD_PARAM == buttonValue:
            newAttributes.put('__newParam', '__newValue')

        #
        # the rest of the params

        i = 0

        while 1:
            key = req.getParameter('key_%i' % i)
            value = req.getParameter('value_%i' % i)

            if key == None: break

            newAttributes.put(key, value)