ruote 0.9.18

data/lib/openwfe/orest/worklistclient.rb

@@ -0,0 +1,272 @@
+#
+#--
+# Copyright (c) 2005-2007, 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.
+#++
+#
+
+#
+# "hecho en Costa Rica"
+#
+
+require 'openwfe/workitem'
+require 'openwfe/orest/xmlcodec'
+require 'openwfe/orest/definitions'
+require 'openwfe/orest/restclient'
+
+
+module OpenWFE
+
+    #
+    # Reopening WorkItem to set the MAP_TYPE (as it's used by OpenWFEja...)
+    #
+    class WorkItem
+        def initialize
+            @last_modified = nil
+            @attributes = {}
+            @attributes[MAP_TYPE] = E_SMAP
+        end
+    end
+
+    #
+    # a client to an OpenWFE worklists.
+    #
+    class WorklistClient < RestClient
+
+        def initialize (url, username, password)
+            super
+        end
+
+        #
+        # Returns the list of stores the worklist hosts
+        #
+        def list_stores
+            r = get('listStores', nil, nil)
+            decode(r)
+        end
+
+        #
+        # An alias for list_stores()
+        #
+        alias :get_store_names :list_stores
+
+        #
+        # Returns the headers of a given store.
+        #
+        def get_headers (storeName, limit=1000)
+
+            params = {}
+            params["limit"] = limit
+
+            decode(get('getHeaders', storeName, params))
+        end
+
+        #
+        # TODO : rdoc me
+        #
+        def find_flow_instance (store_name, workflow_instance_id)
+
+            params = {}
+            params["id"] = workflow_instance_id
+
+            decode(get('findFlowInstance', store_name, params))
+        end
+
+        #
+        # Launches a flow (on a given engine and with a given launchitem).
+        # The 'engineId' corresponds to an engine's participant name
+        # (see etc/engine/participant-map.xml)
+        #
+        def launch_flow (engineId, launchitem)
+
+            eli = OpenWFE::XmlCodec::encode(launchitem)
+
+            params = {}
+            params[ENGINEID] = engineId
+
+            decode(post('launchFlow', nil, params, eli))
+        end
+
+        #
+        # Returns a workitem (but doesn't put a lock on it, thus modifications
+        # to it cannot be communicated with saveWorkitem() or forwardWorkitem()
+        # to the worklist)
+        #
+        def get_workitem (storeName, flowExpressionId)
+
+            get_item('getWorkitem', storeName, flowExpressionId)
+        end
+
+        #
+        # Returns a workitem and makes sure it's locked in the worklist. Thus,
+        # the usage of the methods saveWorkitem() and forwardWorkitem() is
+        # possible.
+        #
+        def get_and_lock_workitem (storeName, flowExpressionId)
+
+            #puts "...getAndLockWorkitem() for #{flowExpressionId}"
+
+            get_item('getAndLockWorkitem', storeName, flowExpressionId)
+        end
+
+        #
+        # Given a queryMap (a dict of keys and values), locks and returns 
+        # the first workitem matching.
+        #
+        def query_and_lock_workitem (storeName, queryMap)
+
+            hs = get_headers(storeName)
+            hs.each do |h|
+
+                #puts "...h.id  #{h.flowExpressionId}"
+                #h.attributes.each do |k, v|
+                #    puts "......h '#{k}' => '#{v}'"
+                #end
+
+                ok = true
+                id = nil
+
+                queryMap.each do |key, value|
+
+                    #puts "...'#{key}' => '#{h.attributes[key]}' ?= '#{value}'"
+                    ok = (ok and h.attributes[key] == value)
+                        #
+                        # the parenthesis are very important
+
+                    #puts "  .ok is #{ok}"
+                    #puts "  .id is #{h.flowExpressionId}"
+                    break unless ok
+                end
+
+                #puts "  .id is #{h.flowExpressionId}"
+
+                get_and_lock_workitem(storeName, h.flow_expression_id) if ok
+            end
+
+            nil
+        end
+
+        #
+        # Notifies the worklist that the given workitem has to be unlocked
+        # any local (client-side) modification to it are ignored.
+        #
+        def release_workitem (workitem)
+
+            post_item('releaseWorkitem', workitem)
+        end
+
+        #
+        # Saves back the workitem in the worklist (and releases it)
+        #
+        def save_workitem (workitem)
+
+            post_item('saveWorkitem', workitem)
+        end
+
+        #
+        # Returns the workitem to the worklist so that it can resume 
+        # its flow (changes to the workitem are saved).
+        #
+        def proceed_workitem (workitem)
+
+            post_item('forwardWorkitem', workitem)
+        end
+
+        alias :forward_workitem :proceed_workitem
+
+        #
+        # Returns the list of flow URLs the user owning this session may
+        # launch.
+        #
+        def list_launchables ()
+
+            params = {}
+
+            decode(get('listLaunchables', nil, params))
+        end
+
+        #
+        # Delegate the workitem (transfer it to another store).
+        #
+        def delegate (workitem, targetStoreName)
+
+            ewi = OpenWFE.encode(workitem)
+
+            params = {}
+            params[TARGETSTORE] = targetStoreName
+
+            decode(post('delegate', workitem.store, params, ewi))
+        end
+
+        #
+        # Delegate the workitem (ask the worklist to deliver it to 
+        # another participant).
+        #
+        def delegate_to_participant (workitem, targetParticipantName)
+
+            ewi = OpenWFE.encode(workitem)
+
+            params = {}
+            params[TARGETPARTICIPANT] = targetParticipantName
+
+            decode(post('delegate', workitem.store, params, ewi))
+        end
+
+        #def queryStore (storeName, query)
+        #end
+
+        protected
+
+            def get_item (rest_method_name, store_name, flow_expression_id)
+
+                fei = OpenWFE::XmlCodec::encode flow_expression_id
+                fei = OpenWFE::xmldoc_to_string fei, false
+
+                params = {}
+
+                wi = decode(post(rest_method_name, store_name, params, fei))
+
+                wi.store = store_name if wi
+
+                wi
+            end
+
+            def post_item (rest_method_name, workitem)
+
+                ewi = OpenWFE::XmlCodec::encode(workitem)
+
+                params = {}
+
+                decode(post(rest_method_name, workitem.store, params, ewi))
+            end
+
+    end
+
+end
+

data/lib/openwfe/orest/xmlcodec.rb

@@ -0,0 +1,670 @@
+#
+#--
+# Copyright (c) 2005-2008, 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.
+#++
+#
+
+#
+# "hecho en Costa Rica" (with just the PickAxe at hand)
+#
+
+require 'base64'
+require 'rexml/document'
+
+require 'openwfe/utils'
+require 'openwfe/workitem'
+require 'openwfe/flowexpressionid'
+require 'openwfe/orest/definitions'
+require 'openwfe/orest/workitem'
+
+
+module OpenWFE
+
+    #
+    # Ugly XML codec for OpenWFE workitems
+    #
+    # (one of the first things I wrote in Ruby...)
+    #
+    module XmlCodec
+
+        #
+        # Returns the first subelt of xmlElt that matches the given elt_name.
+        # If the name is null, the first elt will be returned.
+        #
+        def self.first_element (xml_elt, elt_name=nil)
+
+            return nil if not xml_elt
+
+            return xml_elt.elements.find { |e| e.is_a?(REXML::Element) } \
+                unless elt_name
+
+            xml_elt.elements.find do |e| 
+                e.is_a?(REXML::Element) and e.name == elt_name
+            end
+        end
+
+        #
+        # Takes as input some XML element and returns is decoded 
+        # (as an instance)
+        #
+        def XmlCodec.decode (xmlElt)
+
+            return nil unless xmlElt
+
+            if xmlElt.kind_of? String
+
+                xmlElt = REXML::Document.new(
+                    xmlElt, 
+                    :compress_whitespace => :all,
+                    :ignore_whitespace_nodes => :all)
+
+                xmlElt = xmlElt.root
+            end
+
+            #puts "decode() xmlElt.name is >#{xmlElt.name}<"
+
+            return decode_session_id(xmlElt) if xmlElt.name == 'session'
+            return decode_list(xmlElt) if xmlElt.name == STORES
+            return decode_store(xmlElt) if xmlElt.name == STORE
+            return decode_list(xmlElt) if xmlElt.name == HEADERS
+            return decode_header(xmlElt) if xmlElt.name == HEADER
+
+            return decode_launch_ok(xmlElt) if xmlElt.name == OK
+
+            return decode_list(xmlElt) if xmlElt.name == HISTORY
+            return decode_historyitem(xmlElt) if xmlElt.name == HISTORY_ITEM
+
+            return decode_list(xmlElt) if xmlElt.name == FLOW_EXPRESSION_IDS
+            return decode_fei(xmlElt) if xmlElt.name == FLOW_EXPRESSION_ID
+
+            return decode_inflowworkitem(xmlElt) \
+                if xmlElt.name == IN_FLOW_WORKITEM
+            return decode_launchitem(xmlElt) \
+                if xmlElt.name == LAUNCHITEM
+
+            return decode_list(xmlElt) if xmlElt.name == LAUNCHABLES
+            return decode_launchable(xmlElt) if xmlElt.name == LAUNCHABLE
+
+            return decode_list(xmlElt) if xmlElt.name == EXPRESSIONS
+            return decode_expression(xmlElt) if xmlElt.name == EXPRESSION
+
+            return decode_attribute(xmlElt.elements[1]) if xmlElt.name == ATTRIBUTES
+
+            #
+            # default
+
+            decode_attribute(xmlElt)
+
+            #raise \
+            #    ArgumentError, \
+            #    "Cannot decode : '"+xmlElt.name+"' "+xmlElt.to_s()
+        end
+
+        #
+        # Takes some OpenWFE Ruby instance and returns it as XML
+        #
+        def XmlCodec.encode (owfeData)
+
+            #puts "encode() #{owfeData.inspect}"
+
+            return encode_launchitem(owfeData) \
+                if owfeData.kind_of? LaunchItem
+
+            return encode_fei(owfeData) \
+                if owfeData.kind_of? FlowExpressionId
+
+            return encode_inflowworkitem(owfeData) \
+                if owfeData.kind_of? InFlowWorkItem
+
+            raise \
+                ArgumentError, \
+                "Cannot encode : "+owfeData.inspect()
+        end
+
+        def XmlCodec.encode_workitem_as_header (in_flow_workitem, locked)
+
+            e = REXML::Element.new HEADER
+
+            e.add_attribute A_LAST_MODIFIED, "#{in_flow_workitem.last_modified}"
+            e.add_attribute A_LOCKED, locked
+
+            e << XmlCodec::encode_fei(in_flow_workitem.fei)
+            e << XmlCodec::encode_attributes(in_flow_workitem)
+
+            e
+        end
+
+        private
+
+            #
+            # DECODE
+            #
+
+            def XmlCodec.decode_session_id (xmlElt)
+                Integer(xmlElt.attributes['id'])
+            end
+
+            def XmlCodec.decode_list (xmlElt)
+                xmlElt.elements.collect { |elt| decode(elt) }
+            end
+
+
+            def XmlCodec.decode_launchable (xmlElt)
+
+                launchable = Launchable.new()
+
+                launchable.url = xmlElt.attributes[URL]
+                launchable.engine_id = xmlElt.attributes[ENGINE_ID]
+
+                launchable
+            end
+
+
+            def XmlCodec.decode_expression (xmlElt)
+
+                exp = Expression.new()
+                
+                exp.id = decode(first_element(xmlElt))
+
+                exp.apply_time = xmlElt.attributes[APPLY_TIME]
+                exp.state = xmlElt.attributes[STATE]
+                exp.state_since = xmlElt.attributes[STATE_SINCE]
+
+                exp
+            end
+
+
+            def XmlCodec.decode_store (xmlElt)
+
+                store = Store.new()
+
+                store.name = xmlElt.attributes[NAME]
+                store.workitem_count = xmlElt.attributes[WORKITEM_COUNT]
+                store.workitem_count = Integer(store.workitem_count)
+                store.permissions = xmlElt.attributes[PERMISSIONS]
+
+                store
+            end
+
+
+            def XmlCodec.decode_header (xmlElt)
+
+                header = Header.new()
+
+                header.last_modified = xmlElt.attributes[A_LAST_MODIFIED]
+                header.locked = parse_boolean(xmlElt.attributes[A_LOCKED])
+                header.flow_expression_id = decode(first_element(xmlElt, FLOW_EXPRESSION_ID))
+                header.attributes = decode(first_element(xmlElt, ATTRIBUTES))
+
+                header
+            end
+
+
+            def XmlCodec.decode_fei (xmlElt)
+
+                fei = FlowExpressionId.new
+
+                fei.owfe_version = xmlElt.attributes[OWFE_VERSION]
+                fei.engine_id = xmlElt.attributes[ENGINE_ID]
+                fei.initial_engine_id = xmlElt.attributes[INITIAL_ENGINE_ID]
+
+                fei.workflow_definition_url = xmlElt.attributes[WORKFLOW_DEFINITION_URL]
+                fei.workflow_definition_name = xmlElt.attributes[WORKFLOW_DEFINITION_NAME]
+                fei.workflow_definition_revision = xmlElt.attributes[WORKFLOW_DEFINITION_REVISION]
+
+                fei.workflow_instance_id = xmlElt.attributes[WORKFLOW_INSTANCE_ID]
+
+                fei.expression_name = xmlElt.attributes[EXPRESSION_NAME]
+                fei.expression_id = xmlElt.attributes[EXPRESSION_ID]
+
+                #puts " ... fei.expressionName is >#{fei.expressionName}<"
+                #puts " ... fei.wfid is >#{fei.workflowInstanceId}<"
+
+                fei
+            end
+
+
+            def XmlCodec.decode_attribute (xmlElt)
+
+                #puts "decodeAttribute() '#{xmlElt.name}' --> '#{xmlElt.text}'"
+
+                #
+                # atomic types
+
+                return xmlElt.text.strip \
+                    if xmlElt.name == E_STRING
+                return Integer(xmlElt.text.strip) \
+                    if xmlElt.name == E_INTEGER
+                return Integer(xmlElt.text.strip) \
+                    if xmlElt.name == E_LONG
+                return Float(xmlElt.text.strip) \
+                    if xmlElt.name == E_DOUBLE
+                return parse_boolean(xmlElt.text) \
+                    if xmlElt.name == E_BOOLEAN
+
+                return decode_xmldocument(xmlElt) \
+                    if xmlElt.name == E_XML_DOCUMENT
+                return xmlElt.children[0] \
+                    if xmlElt.name == E_RAW_XML
+
+                return Base64Attribute.new(xmlElt.text) \
+                    if xmlElt.name == E_BASE64
+
+                #
+                # composite types
+
+                return decode_list(xmlElt) \
+                    if xmlElt.name == E_LIST
+
+                if xmlElt.name == E_SMAP or xmlElt.name == E_MAP
+
+                    map = {}
+                    map[MAP_TYPE] = xmlElt.name
+
+                    #xmlElt.elements.each("//"+M_ENTRY) do |e| 
+                    xmlElt.elements.each(M_ENTRY) do |e| 
+                        #puts "decodeAttribute() >#{e}<"
+                        decode_entry(e, map)
+                    end
+
+                    return map
+                end
+
+                #puts OpenWFE.xmldoc_to_string(xmlElt.document())
+
+                raise \
+                    ArgumentError, \
+                    "Cannot decode <#{xmlElt.name}/> in \n"+\
+                    OpenWFE.xmldoc_to_string(xmlElt.document())
+            end
+
+            def XmlCodec.decode_xmldocument (xmlElt)
+
+                s = Base64::decode64 xmlElt.text.strip
+                REXML::Document.new s
+            end
+
+            def XmlCodec.decode_entry (xmlElt, map)
+
+                key = xmlElt.elements[1]
+                val = xmlElt.elements[2]
+
+                #
+                # this parse method supports the old style and the [new] light
+                # style/schema
+                #
+
+                key = key.elements[1] if key.name == M_KEY
+                val = val.elements[1] if val.name == M_VALUE
+
+                key = decode(key)
+                val = decode(val)
+
+                #puts "decodeEntry() k >#{key}< v >#{val}<"
+                #puts "decodeEntry() subject '#{val}'" if key == '__subject__' 
+
+                key = key.strip if key.is_a?(String)
+                val = val.strip if val.is_a?(String)
+
+                map[key] = val
+            end
+
+            def XmlCodec.parse_boolean (string)
+
+                string.strip.downcase == 'true'
+            end
+
+            def XmlCodec.decode_historyitem (xmlElt)
+
+                hi = HistoryItem.new
+
+                hi.author = xmlElt.attributes[A_AUTHOR]
+                hi.date = xmlElt.attributes[A_DATE]
+                hi.host = xmlElt.attributes[A_HOST]
+                hi.text = xmlElt.text
+
+                hi.wfd_name = xmlElt.attributes[WORKFLOW_DEFINITION_NAME]
+                hi.wfd_revision = xmlElt.attributes[WORKFLOW_DEFINITION_REVISION]
+                hi.wf_instance_id = xmlElt.attributes[WORKFLOW_INSTANCE_ID]
+                hi.expression_id = xmlElt.attributes[EXPRESSION_ID]
+
+                hi
+            end
+
+
+            def XmlCodec.decode_launch_ok (xmlElt)
+
+                sFei = xmlElt.attributes[A_FLOW_ID]
+
+                return true unless sFei
+
+                FlowExpressionId.to_fei(sFei)
+            end
+
+
+            def XmlCodec.decode_inflowworkitem (xmlElt)
+
+                wi = InFlowWorkItem.new()
+
+                wi.last_modified = xmlElt.attributes[A_LAST_MODIFIED]
+                wi.attributes = decode(first_element(xmlElt, ATTRIBUTES))
+
+                wi.participant_name = xmlElt.attributes[A_PARTICIPANT_NAME]
+                wi.flow_expression_id = decode(first_element(first_element(xmlElt, E_LAST_EXPRESSION_ID), FLOW_EXPRESSION_ID))
+
+                wi.dispatch_time = xmlElt.attributes[A_DISPATCH_TIME]
+
+                # TODO : decode filter
+
+                wi.history = decode(first_element(xmlElt, HISTORY))
+
+                wi
+            end
+
+            def XmlCodec.decode_launchitem (xmlElt)
+
+                li = LaunchItem.new
+
+                li.workflow_definition_url = 
+                    xmlElt.attributes[WORKFLOW_DEFINITION_URL]
+
+                li.attributes = 
+                    decode(first_element(xmlElt, ATTRIBUTES))
+
+                li
+            end
+
+
+            #
+            # ENCODE
+            #
+
+
+            def XmlCodec.encode_item (item, elt)
+
+                elt.attributes[A_LAST_MODIFIED] = item.last_modified
+
+                elt << encode_attributes(item)
+            end
+
+            def XmlCodec.encode_attributes (item)
+
+                eAttributes = REXML::Element.new(ATTRIBUTES)
+
+                eAttributes << encode_attribute(item.attributes)
+
+                eAttributes
+            end
+
+
+            def XmlCodec.encode_launchitem (launchitem)
+
+                doc = REXML::Document.new()
+
+                root = REXML::Element.new(LAUNCHITEM)
+
+                encode_item(launchitem, root)
+
+                root.attributes[WORKFLOW_DEFINITION_URL] = \
+                    launchitem.workflow_definition_url
+
+                # TODO :
+                #
+                # - encode descriptionMap
+                #
+                # - replyTo is not necessary
+
+                doc << root
+
+                OpenWFE.xmldoc_to_string(doc)
+            end
+
+
+            def XmlCodec.encode_inflowitem (item, elt)
+
+                encode_item(item, elt)
+
+                elt.attributes[A_PARTICIPANT_NAME] = item.participant_name
+
+                eLastExpressionId = REXML::Element.new(E_LAST_EXPRESSION_ID)
+
+                eLastExpressionId << encode_fei(item.last_expression_id)
+
+                elt << eLastExpressionId
+            end
+
+
+            def XmlCodec.encode_inflowworkitem (item)
+
+                doc = REXML::Document.new()
+
+                root = REXML::Element.new(IN_FLOW_WORKITEM)
+
+                encode_inflowitem(item, root)
+
+                root.attributes[A_DISPATCH_TIME] = item.dispatch_time
+
+                # add filter ? no
+
+                encode_history(item, root) if item.history
+
+                doc << root
+
+                s = OpenWFE.xmldoc_to_string(doc)
+                #puts "encoded :\n#{s}"
+                s
+            end
+
+
+            def XmlCodec.encode_history (item, elt)
+
+                eHistory = REXML::Element.new(HISTORY)
+
+                item.history.each do |hi|
+
+                    ehi = REXML::Element.new(HISTORY_ITEM)
+
+                    ehi.attributes[A_AUTHOR] = hi.author
+                    ehi.attributes[A_DATE] = hi.date
+                    ehi.attributes[A_HOST] = hi.host
+
+                    ehi.attributes[WORKFLOW_DEFINITION_NAME] = hi.wfd_name
+                    ehi.attributes[WORKFLOW_DEFINITION_REVISION] = hi.wfd_revision
+                    ehi.attributes[WORKFLOW_INSTANCE_ID] = hi.wf_instance_id
+                    ehi.attributes[EXPRESSION_ID] = hi.expression_id
+
+                    eHistory << ehi
+                end
+
+                elt << eHistory
+            end
+
+
+            def XmlCodec.encode_attribute (att)
+
+                #puts "encodeAttribute() att.class is #{att.class}"
+
+                return encode_atomicattribute(E_STRING, att) \
+                    if att.kind_of?(String)
+                return encode_atomicattribute(E_INTEGER, att) \
+                    if att.kind_of?(Fixnum)
+                return encode_atomicattribute(E_DOUBLE, att) \
+                    if att.kind_of?(Float)
+
+                return encode_xmldocument(att) \
+                    if att.kind_of?(REXML::Document)
+                return encode_xmlattribute(att) \
+                    if att.kind_of?(REXML::Element)
+
+                return encode_atomicattribute(E_BOOLEAN, true) \
+                    if att.kind_of?(TrueClass)
+                return encode_atomicattribute(E_BOOLEAN, false) \
+                    if att.kind_of?(FalseClass)
+
+                return encode_base64attribute(att) \
+                    if att.kind_of?(Base64Attribute)
+
+                return encode_mapattribute(att) if att.kind_of?(Hash)
+                return encode_listattribute(att) if att.kind_of?(Array)
+
+                #
+                # default
+
+                encode_atomicattribute(E_STRING, att)
+
+                #raise \
+                #    ArgumentError, \
+                #    "Cannot encode attribute of class '#{att.class}'"
+            end
+
+            def XmlCodec.encode_xmldocument (elt)
+
+                e = REXML::Element.new(E_XML_DOCUMENT)
+                e.text = Base64::encode64(elt.to_s)
+                e
+            end
+
+            def XmlCodec.encode_xmlattribute (elt)
+
+                return elt if elt.name == E_RAW_XML
+
+                #
+                # else, wrap within <raw-xml>...</raw-xml>
+
+                e = REXML::Element.new(E_RAW_XML)
+                e << elt
+
+                e
+            end
+
+
+            def XmlCodec.encode_base64attribute (att)
+
+                e = REXML::Element.new(E_BASE64)
+                e.text = att.content
+
+                e
+            end
+
+
+            def XmlCodec.encode_atomicattribute (name, value)
+
+                elt = REXML::Element.new(name)
+                #elt << REXML::Text.new(value.to_s())
+                elt.add_text(value.to_s())
+
+                elt
+            end
+
+
+            def XmlCodec.encode_listattribute (list)
+
+                elt = REXML::Element.new(E_LIST)
+
+                list.each do |e|
+                    elt << encode_attribute(e)
+                end
+
+                elt
+            end
+
+
+            def XmlCodec.encode_mapattribute (hash)
+
+                name = hash[MAP_TYPE]
+                name = 'map' if name == nil
+
+                elt = REXML::Element.new(name)
+
+                hash.each_key do |key|
+
+                    next if key == MAP_TYPE
+
+                    eEntry = REXML::Element.new(M_ENTRY)
+
+                    val = hash[key]
+
+                    eEntry << encode_attribute(key)
+                    eEntry << encode_attribute(val)
+
+                    elt << eEntry
+                end
+
+                elt
+            end
+
+
+            def XmlCodec.encode_fei (fei)
+
+                elt = REXML::Element.new(FLOW_EXPRESSION_ID)
+
+                elt.attributes[OWFE_VERSION] = fei.owfe_version
+                elt.attributes[ENGINE_ID] = fei.engine_id
+                elt.attributes[INITIAL_ENGINE_ID] = fei.initial_engine_id
+
+                elt.attributes[WORKFLOW_DEFINITION_URL] = fei.workflow_definition_url
+                elt.attributes[WORKFLOW_DEFINITION_NAME] = fei.workflow_definition_name
+                elt.attributes[WORKFLOW_DEFINITION_REVISION] = fei.workflow_definition_revision
+                elt.attributes[WORKFLOW_INSTANCE_ID] = fei.workflow_instance_id
+
+                elt.attributes[EXPRESSION_NAME] = fei.expression_name
+                elt.attributes[EXPRESSION_ID] = fei.expression_id
+
+                elt
+            end
+    end
+
+    #
+    # Just turns some XML to a String (if decl is set to false, no 
+    # XML declaration will be printed).
+    #
+    def OpenWFE.xmldoc_to_string (xml, decl=true)
+
+        #return xml if xml.is_a?(String)
+
+        xml << REXML::XMLDecl.new \
+            if decl and (not xml[0].is_a?(REXML::XMLDecl))
+
+        #s = ""
+        #xml.write(s, 0)
+        #return s
+        xml.to_s
+    end
+
+    #
+    # An alias for OpenWFE::xmldoc_to_string()
+    #
+    def OpenWFE.xml_to_s (xml, decl=true)
+
+        OpenWFE::xmldoc_to_string(xml, decl)
+    end
+
+end
+