openwferu 0.9.1 → 0.9.2

data/lib/openwfe/rest/xmlcodec.rb

@@ -0,0 +1,575 @@
+#
+#--
+# Copyright (c) 2005-2007, John Mettraux, 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.rb 2865 2006-06-23 14:54:07Z jmettraux $
+#
+
+#
+# "hecho en Costa Rica"
+#
+
+#require 'base64'
+require 'rexml/document'
+
+require 'definitions'
+require 'utils'
+require 'workitem'
+require 'flowexpressionid'
+
+
+module OpenWFE
+
+    class XmlCodec
+
+        #
+        # Takes as input some XML element and returns is decoded 
+        # (as an instance)
+        #
+        def decode (xmlElt)
+
+            return nil if not xmlElt
+
+            #puts "decode() xmlElt.name is >#{xmlElt.name}<"
+
+            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_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 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
+
+        private
+
+            #
+            # DECODE
+            #
+
+            def decode_list (xmlElt)
+                xmlElt.elements.collect { |elt| decode(elt) }
+            end
+
+
+            def decode_launchable (xmlElt)
+
+                launchable = Launchable.new()
+
+                launchable.url = xmlElt.attributes[URL]
+                launchable.engine_id = xmlElt.attributes[ENGINE_ID]
+
+                return launchable
+            end
+
+
+            def decode_expression (xmlElt)
+
+                exp = Expression.new()
+                
+                #exp.id = decode(OpenWFE.first_element(xmlElt, "//"+FLOW_EXPRESSION_ID))
+                exp.id = decode(OpenWFE.first_element(xmlElt))
+
+                exp.apply_time = xmlElt.attributes[APPLY_TIME]
+                exp.state = xmlElt.attributes[STATE]
+                exp.state_since = xmlElt.attributes[STATE_SINCE]
+
+                return exp
+            end
+
+
+            def 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]
+
+                return store
+            end
+
+
+            def 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(OpenWFE.first_element(xmlElt, FLOW_EXPRESSION_ID))
+                header.attributes = decode(OpenWFE.first_element(xmlElt, ATTRIBUTES))
+
+                return header
+            end
+
+
+            def 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}<"
+
+                return fei
+            end
+
+
+            def decode_attribute (xmlElt)
+
+                #puts "decodeAttribute() '#{xmlElt.name}' --> '#{xmlElt.text}'"
+
+                #
+                # atomic types
+
+                return xmlElt.text if xmlElt.name == E_STRING
+                return Integer(xmlElt.text) if xmlElt.name == E_INTEGER
+                return Integer(xmlElt.text) if xmlElt.name == E_LONG
+                return Float(xmlElt.text) if xmlElt.name == E_DOUBLE
+                return parseBoolean(xmlElt.text) if xmlElt.name == E_BOOLEAN
+
+                return xmlElt if xmlElt.name == E_XML
+
+                return Base64Attribute.new(xmlElt.txt) if xmlElt.name == E_BASE64
+
+                #
+                # composite types
+
+                return decodeList(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 xmldoc_to_string(xmlElt.document())
+
+                raise \
+                    ArgumentError, \
+                    "Cannot decode <#{xmlElt.name}/> in \n"+\
+                    xmldoc_to_string(xmlElt.document())
+            end
+
+            def 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__' 
+
+                map[key] = val
+            end
+
+            def parse_boolean (string)
+
+                return string.strip.downcase == 'true'
+            end
+
+            def 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]
+
+                return hi
+            end
+
+
+            def decode_launch_ok (xmlElt)
+
+                sFei = xmlElt.attributes[A_FLOW_ID]
+
+                return true if not sFei
+
+                FlowExpressionId.to_fei(sFei)
+            end
+
+
+            def decode_inflowworkitem (xmlElt)
+
+                wi = InFlowWorkItem.new()
+
+                wi.last_modified = xmlElt.attributes[A_LAST_MODIFIED]
+                wi.attributes = decode(OpenWFE.first_element(xmlElt, ATTRIBUTES))
+
+                wi.participant_name = xmlElt.attributes[A_PARTICIPANT_NAME]
+                wi.flow_expression_id = decode(OpenWFE.first_element(OpenWFE.first_element(xmlElt, E_LAST_EXPRESSION_ID), FLOW_EXPRESSION_ID))
+
+                wi.dispatch_time = xmlElt.attributes[A_DISPATCH_TIME]
+
+                # TODO : decode filter
+
+                wi.history = decode(OpenWFE.first_element(xmlElt, HISTORY))
+
+                return wi
+            end
+
+
+            #
+            # ENCODE
+            #
+
+
+            def encode_item (item, elt)
+
+                elt.attributes[A_LAST_MODIFIED] = item.last_modified
+
+                eAttributes = REXML::Element.new(ATTRIBUTES)
+
+                eAttributes << encode_attribute(item.attributes)
+
+                elt << eAttributes
+            end
+
+
+            def encode_launchitem (launchitem)
+
+                doc = REXML::Document.new()
+
+                root = REXML::Element.new(E_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 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 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)
+
+                doc << root
+
+                s = OpenWFE.xmldoc_to_string(doc)
+                #puts "encoded :\n#{s}"
+                return s
+            end
+
+
+            def 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 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_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 encode_xmlattribute (elt)
+
+                return elt if elt.name == E_XML
+
+                #
+                # else, wrap within <raw-xml>...</raw-xml>
+
+                e = REXML::Element.new(E_XML)
+                e << elt
+
+                return e
+            end
+
+
+            def encode_base64attribute (att)
+
+                e = REXML::Element.new(E_BASE64)
+                e.text = att.content
+
+                return e
+            end
+
+
+            def encode_atomicattribute (name, value)
+
+                elt = REXML::Element.new(name)
+                #elt << REXML::Text.new(value.to_s())
+                elt.add_text(value.to_s())
+
+                return elt
+            end
+
+
+            def encode_listattribute (list)
+
+                elt = REXML::Element.new(E_LIST)
+
+                list.each do |e|
+                    elt << encode_attribute(e)
+                end
+
+                return elt
+            end
+
+
+            def 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
+
+                return elt
+            end
+
+
+            def 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
+
+                return elt
+            end
+    end
+
+    XMLCODEC = XmlCodec.new
+
+    def OpenWFE.xml_decode (xmlelt)
+        XMLCODEC.decode(xmlelt)
+    end
+
+    def OpenWFE.xml_encode (owfedata)
+        XMLCODEC.encode(owfedata)
+    end
+
+    def OpenWFE.xmldoc_to_string (xml, decl=true)
+
+        s = ""
+
+        if decl and xml[0].kind_of? REXML::XMLDecl
+            xml << REXML::XMLDecl.new()
+        end
+
+        xml.write(s, 0)
+        return s
+    end
+
+end
+