codec.py

一个工作流设计及定义的系统,可以直接与数据库结合进行系统工作流程的定义及应用.

#
# Copyright (c) 2005, John Mettraux, OpenWFE.org
# All rights reserved.
# 
# Redistribution and use in source and binary forms, with or without 
# modification, are permitted provided that the following conditions are met:
# 
# . Redistributions of source code must retain the above copyright notice, this
#   list of conditions and the following disclaimer.  
# 
# . Redistributions in binary form must reproduce the above copyright notice, 
#   this list of conditions and the following disclaimer in the documentation 
#   and/or other materials provided with the distribution.
# 
# . Neither the name of the "OpenWFE" nor the names of its contributors may be
#   used to endorse or promote products derived from this software without
#   specific prior written permission.
# 
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
# POSSIBILITY OF SUCH DAMAGE.
#
# $Id: codec.py,v 1.49 2005/04/22 16:39:22 jmettraux Exp $
#

"""

    codec.py

    code for {en|de}coding XML REST stuff

    directly addresses 
    http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/openwfe/poya/worklist/doc/rest_worklist_iface.txt?rev=HEAD&content-type=text/vnd.viewcvs-markup

    $Id: codec.py,v 1.49 2005/04/22 16:39:22 jmettraux Exp $

"""

from xml.dom.minidom import parse
from xml.dom.minidom import parseString
from xml.dom.minidom import Document
from xml.dom.minidom import Element
from openwfe.workitem import Store
from openwfe.workitem import Header
from openwfe.workitem import Filter
from openwfe.workitem import FilterEntry
from openwfe.workitem import Workitem
from openwfe.workitem import Launchitem
from openwfe.workitem import Cancelitem
from openwfe.workitem import InFlowWorkitem
from openwfe.workitem import FlowExpressionId
from openwfe.workitem import HistoryItem
from openwfe.workitem import Launchable
from openwfe.workitem import Expression
from openwfe.workitem import StringMapAttribute
from openwfe.workitem.attributeCodec import parseAttribute
from openwfe.workitem.attributeCodec import encodeAttribute
from openwfe.workitem.attributeCodec import STRING_MAP
from openwfe.utils import isString
from openwfe.xmlutils import getEncoding
from openwfe.xmlutils import getChildrenByTagName

#
# some... well, constants

ID = 'id'
BYE = 'bye'
NAME = 'name'
LOCKED = 'locked'
ALLOWED = 'allowed'
NOT_ALLOWED = 'not-allowed'
SESSION = 'session'
STORE = 'store'
STORES = 'stores'
HEADER = 'header'
HEADERS = 'headers'
WORKITEM = 'workitem'
LAUNCHITEM = 'launchitem'
CANCELITEM = 'cancelitem'
WORKITEM_COUNT = 'workitem-count'
WORKFLOW_INSTANCE_ID = 'workflow-instance-id'
OPEN_FILTER = 'open-filter'
CLOSED_FILTER = 'closed-filter'
ADD_ALLOWED = 'add-allowed'
REMOVE_ALLOWED = 'remove-allowed'
READ_WRITE = 'read-write'
READ_ONLY = 'read-only'
HIDE = 'hide'
PERMISSIONS = 'permissions'
DISPATCH_TIME = 'dispatch-time'
PARTICIPANT_NAME = 'participant-name'
LAST_EXPRESSION_ID = 'last-expression-id'
LAST_MODIFIED = 'last-modified'
ENGINE_ID = 'engine-id'
INITIAL_ENGINE_ID = 'initial-engine-id'
WORKFLOW_DEFINITION_URL = 'workflow-definition-url'
WORKFLOW_DEFINITION_NAME = 'workflow-definition-name'
WORKFLOW_DEFINITION_REVISION = 'workflow-definition-revision'
WORKFLOW_INSTANCE_ID = 'workflow-instance-id'
EXPRESSION_NAME = 'expression-name'
EXPRESSION_ID = 'expression-id'
FLOW_EXPRESSION_ID = 'flow-expression-id'
FLOW_EXPRESSION_IDS = 'flow-expression-ids'
FLOW_STACK = 'flow-stack'
ATTRIBUTES = 'attributes'
HISTORY = 'history'
HISTORY_ITEM = 'history-item'
DATE = 'date'
AUTHOR = 'author'
HOST = 'host'
FIELD = 'field'
REGEX = 'regex'
TYPE = 'type'
PERMISSIONS = 'permissions'
LAUNCHABLES = 'launchables'
LAUNCHABLE = 'launchable'
URL = 'url'
DESCRIPTION = 'description'
LANGUAGE = 'language'
OK = 'ok'
FLOW_ID = 'flow-id'
EXPRESSION = 'expression'
EXPRESSIONS = 'expressions'
APPLY_TIME = 'apply-time'
FROZEN_TIME = 'frozen-time'


ENCODING = getEncoding()
#ENCODING = 'utf-8'
#ENCODING = 'latin-1'


#
# DECODING
#

def decodeFile (fileName):
    file = open(fileName, 'r')
    return decode(file)


#def _fetch (result, fileOrXmlString):
#    s = fileOrXmlString.read()
#    print '_fetch() %i chars' % len(s)
#    if not s: return result.encode('utf-8')
#    result = '%s%s' % (result, s)
#    return _fetch(result, fileOrXmlString)


def decode (fileOrXmlString):

    #try:
    #    print 'decode() input type  %s' % type(fileOrXmlString)
    #    print 'decode() input class %s' % fileOrXmlString.__class__
    #except:
    #    pass

    #if isinstance(file, str):
    if isString(fileOrXmlString):
        #doc = parseString(fileOrXmlString)
        doc = parseString(fileOrXmlString.encode('utf-8'))
    else:
        doc = parse(fileOrXmlString)
        #
        # or :
        #doc = parseString(_fetch('', fileOrXmlString))
        #
        # debug :
        #fileOrXmlString = fileOrXmlString.read()
        #print 'decode() len is %i' % len(fileOrXmlString)
        #print 'decode(s) --|%s|--' % fileOrXmlString
        #doc = parseString(fileOrXmlString.encode('utf-8'))

    root = doc.firstChild

    #print 'root.nodeName is >%s<' % root.nodeName

    if root.nodeName == SESSION:
        return parseSession(root)
    elif root.nodeName == STORES:
        return parseStores(root)
    elif root.nodeName == STORE:
        return parseStore(root)
    elif root.nodeName == HEADERS:
        return parseHeaders(root)
    elif root.nodeName == FLOW_EXPRESSION_IDS:
        return parseFlowExpressionIds(root)
    elif root.nodeName == CANCELITEM:
        return parseWorkitem(root)
    elif root.nodeName == WORKITEM:
        return parseWorkitem(root)
    elif root.nodeName == LAUNCHITEM:
        return parseWorkitem(root)
    elif root.nodeName == LAUNCHABLES:
        return parseLaunchables(root)
    elif root.nodeName == EXPRESSIONS:
        return parseExpressions(root)
    elif (root.nodeName == ATTRIBUTES or root.nodeName == STRING_MAP):
        return parseAttribute(root)
    elif root.nodeName == BYE:
        return BYE
    elif root.nodeName == ALLOWED:
        return 1
    elif root.nodeName == NOT_ALLOWED:
        return 0
    elif root.nodeName == OK:
        flowId = root.getAttribute(FLOW_ID)
        if not flowId: return ''
        return flowId

    return None


def parseSession (element):
    return element.getAttribute(ID)


def parseStores (element):
    result = []
    for e in getChildrenByTagName(element, STORE):
        result.append(parseStore(e))
    return result


def parseStore (element):
    store = Store()
    store.name = element.getAttribute(NAME)
    store.workitemCount = int(element.getAttribute(WORKITEM_COUNT))

    permissionString = element.getAttribute(PERMISSIONS)
    store.mayRead = (permissionString.find('r') > -1)
    store.mayWrite = (permissionString.find('w') > -1)
    store.mayDelegate = (permissionString.find('d') > -1)
    store.mayBrowse = (permissionString.find('b') > -1)

    return store


def parseFlowExpressionIds (element):
    result = []
    for e in getChildrenByTagName(element, FLOW_EXPRESSION_ID):
        result.append(parseFlowExpressionId(e))
    return result


def parseHeaders (element):
    result = []
    for e in getChildrenByTagName(element, HEADER):
        result.append(parseHeader(e))
    return result


def parseHeader (element):
    header = Header()

    header.lastModified = element.getAttribute(LAST_MODIFIED)
    header.locked = (element.getAttribute(LOCKED) == 'true')

    header.flowExpressionId = \
        parseFlowExpressionId(getChildrenByTagName(element, FLOW_EXPRESSION_ID)[0])
    header.attributes = \
        parseAttribute(getChildrenByTagName(element, ATTRIBUTES)[0])

    return header


def parseWorkitem (element):
    item = None

    if element.nodeName == LAUNCHITEM:
        item = parseLaunchitem(element)
    elif element.nodeName == CANCELITEM:
        item = parseCancelitem(element)
    elif element.nodeName == WORKITEM:
        item = parseInFlowWorkitem(element)
    parseBasicWorkitem(item, element)
    return item


def parseBasicWorkitem (workitem, element):
    #workitem.flowStack = \
    #    parseFlowStack(getChildrenByTagName(element, FLOW_STACK)[0])
    workitem.attributes = \
        parseAttribute(getChildrenByTagName(element, ATTRIBUTES)[0])


def parseFlowStack (elt):
    fs = []
    for e in getChildrenByTagName(elt, FLOW_EXPRESSION_ID):
        fs.append(parseFlowExpressionId(e))
    return fs


def parseLaunchitem (elt):
    item = Launchitem()

    workitem.workflowDefinitionUrl = \
        element.getAttribute(WORKFLOW_DEFINITION_URL)

    #
    # parse descriptions

    item.descriptionMap = {}

    ds = getChildrenByTagName(elt, DESCRIPTION)

    for de in ds:
        lang = de.getAttribute(LANGUAGE)
        if lang == None or len(lang.strip()) < 1: lang = 'default'
        item.descriptionMap[lang] = de.firstChild.data.strip()
        #print ' *************** descriptionMap[%s] = "%s"' % (lang, de.firstChild.data)

    return item


def parseCancelitem (elt):
    item = Cancelitem()

    item.lastModified = elt.getAttribute(LAST_MODIFIED)
    item.participantName = elt.getAttribute(PARTICIPANT_NAME)
    item.lastExpressionId = parseFlowExpressionId(elt \
        .getElementsByTagName(LAST_EXPRESSION_ID)[0]
            .getElementsByTagName(FLOW_EXPRESSION_ID)[0])

    return item


def parseInFlowWorkitem (elt):
    item = InFlowWorkitem()

    item.lastModified = elt.getAttribute(LAST_MODIFIED)
    item.participantName = elt.getAttribute(PARTICIPANT_NAME)
    item.dispatchTime = elt.getAttribute(DISPATCH_TIME)

    item.lastExpressionId = parseFlowExpressionId(elt \
        .getElementsByTagName(LAST_EXPRESSION_ID)[0]
            .getElementsByTagName(FLOW_EXPRESSION_ID)[0])

    l = elt.getElementsByTagName(OPEN_FILTER)
    if len(l) > 0: 
        item.filter = parseFilter(l[0])
    l = elt.getElementsByTagName(CLOSED_FILTER)
    if len(l) > 0: 
        item.filter = parseFilter(l[0])

    hElts = getChildrenByTagName(elt, HISTORY)
    if len(hElts) > 0:
        item.history = parseHistory(hElts[0])

    return item


def parseLaunchables (elt):