droflo.py

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

#
# BooleanCombinationExpressionRenderer

class BooleanCombinationExpressionRenderer (ExpressionRenderer, Editable):

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

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

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

        out.print(')')


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

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


#
# NotExpressionRenderer

class NotExpressionRenderer (ExpressionRenderer):

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

        out.print('(not ')

        iChild = expression.childExpressionId

        if iChild:

            eChild = definition.get(iChild)

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

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

        out.print(' )')


#
# 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, 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' % (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, session, definition, expression):
        if expression.orEquals(None) and len(self.operator) <= 1:
            self.operator += '='
        EqualsExpressionRenderer._render(self, out, req, 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 = [ 'timeout', 'description', 'filter' ]

    def _render (self, out, req, 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(_img(req, IMG_PARTICIPANT))
        out.print('<br>\n<small>participant : </small>')
        if refType:
            out.print(_neutralize(refType))
            out.print('::')
            out.print(_neutralize(refValue))
        else:
            out.print('---')
        out.print('&nbsp;')

        if not session.isInEditMode():

            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)

    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, 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, 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, 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, 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, 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, session, definition, expression):
        out.print(_img(req, IMG_SUBPROCESS))
        out.print('<br>\nlaunch subprocess :')
        out.println('<br>\n%s' % self._determineRef(expression))

    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, 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.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.WhenExpression] = WhenExpressionRenderer
RENDERER_MAP[expressions.OrExpression] = BooleanCombinationExpressionRenderer
RENDERER_MAP[expressions.AndExpression] = BooleanCombinationExpressionRenderer
RENDERER_MAP[expressions.NotExpression] = NotExpressionRenderer
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.DefineExpression] = DefineExpressionRenderer