ruote 0.9.19 → 0.9.20

data/lib/openwfe/extras/participants/active_resource_participants.rb

@@ -0,0 +1,213 @@
+#--
+# Copyright (c) 2008-2009, Torsten Schönebaum, John Mettraux (OpenWFE.org)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Europe and Japan.
+#++
+
+
+require 'activeresource' # gem activeresource
+
+require 'openwfe/participants/participants'
+
+
+module OpenWFE
+  module Extras
+
+    #
+    # Ruote participant which does a REST call. It's using ActiveResource to do
+    # the actual magic. You can call every class and instance method
+    # ActiveResource::Base and its mixins provide. You can also process the
+    # response of the REST request and save some of its data into the workitem
+    # for example.
+    #
+    # Before using this participant you *really* should make yourself familiar
+    # with ActiveResource and its usage.
+    #
+    # ==Using it
+    #
+    # The participant should be registered in the engine in a way like this:
+    #
+    #   engine.register_participant(
+    #     'reminder',
+    #     ActiveResourceParticipant.new(
+    #       {
+    #         :site => 'http://localhost:7000',
+    #         :resource_name => 'story',
+    #         :method => 'put', # we will use ActiveResource::CustomMethods::InstanceMethods#put
+    #         :argument => 'send_reminder', # put is happy with just one
+    #                                       # parameter: The action to be
+    #                                       # called. So we won't have to use a
+    #                                       # block to set the arguments of the
+    #                                       # ActiveResource method to call.
+    #       }
+    #     )
+    #   )
+    #
+    # Let's try a more complex example:
+    #
+    #   engine.register_participant(
+    #     'complex_ares',
+    #     ActiveResourceParticipant.new(
+    #       {
+    #         :site => 'http://localhost:7000',
+    #         :resource_name => 'story',
+    #         :method => 'find', # yes, even ActiveResource::Base#find method
+    #                            # may be used...
+    #         :response_handling => proc do |response, workitem| # define response
+    #                                                            # handling block
+    #           workitem.set_attribute('title', response.attributes['title'])
+    #                            # The type of the response object depends on
+    #                            # the method you use!
+    #         end
+    #       }
+    #     ) do |workitem| # define arguments to use with the find method
+    #       # each argument is an entry in an array the block has to return
+    #       [
+    #          workitem.attributes['story_id'], # the first argument
+    #          {:prefix => 'foo'} # the second one is an hash
+    #       ]
+    #     end
+    #   )
+    #
+    # You can now use the participant in your workflow definitions. An example
+    # using XML:
+    #
+    #     <concurrence count="1">
+    #       <participant ref="qa" />
+    #       <cron every="1m">
+    #         <participant
+    #           ref="reminder"
+    #           site="http://localhost:7000"
+    #           resource_name="story"
+    #           method="put"
+    #           action="send_reminder"
+    #           resource_id="${field:story_id}" />
+    #       </cron>
+    #     </concurrence>
+    #
+    # Here, the ActiveResourceParticipant is used to send a reminder.
+    #
+    # *Note:* prefer configuration of the participant at registration time,
+    # information like 'method', 'site' and 'resource_name' may clutter the
+    # process definition.
+    #
+    class ActiveResourceParticipant
+      include OpenWFE::LocalParticipant
+
+      #
+      # == options hash
+      #
+      # You have to set some default options by passing an options hash to the
+      # new method. It should contain the following keys:
+      #
+      # <tt>:site</tt>:: The URI (as string) of the site where your REST
+      #   interface sits. See <tt>site</tt> parameter in ActiveResource::Base.
+      # <tt>:resource_name</tt>:: The name of the resource you like to access.
+      #   See <tt>element_name</tt> parameter in ActiveResource::Base.
+      # <tt>:method</tt>:: The ActiveResource method to call. In most cases
+      #   should be "get", "put", "post" or "delete".
+      # <tt>:argument</tt>:: The first parameter which should be used as
+      #   argument to the ActiveResource method which will be called. This value
+      #   is ignored if a block is given (see below)
+      # <tt>:resource_id</tt>:: The ID of the resource on which the action
+      #   should be called on default. If negative, nil or false, the action
+      #   will be called on the complete set of resources instead of on a single
+      #   resource determined by its ID.
+      # <tt>:response_handling</tt>:: A proc object / block which gets called
+      #   after the request is done. It gets called with to arguments: The
+      #   response of the ActiveResource method called and the workitem.
+      #
+      # The new method also takes a block. It may be used to set the arguments
+      # of the ActiveResource method to call. The block must return an array of
+      # arguments. The array will be splitted and each entry will be used as
+      # argument to the ActiveResource method called. See
+      # OpenWFE::LocalParticipant#call_block for the arguments the block itself
+      # takes.
+      #
+      # All parameters except response_handling and the block set default values
+      # -- you can always override them in the process definition. Just use the
+      # corresponding symbol name (without ":") as attribute.
+      #
+      def initialize (options, &block)
+
+        @options = options
+
+        # some defaults
+        @options[:site] ||= 'http://127.0.0.1:3000'
+        @options[:method] ||= :get
+
+        @block = block
+      end
+
+      #
+      # This method is called each time the participant receives a workitem. It
+      # calls the requested ActiveResource method, calls the response handling
+      # code if present and then immediatly replies to the engine.
+      #
+      def consume (workitem)
+
+        # use block to determine the method's arguments if given
+        args = if @block
+          call_block(@block, workitem)
+        elsif a = param(workitem, :arg) || param(workitem, :argument)
+          Array(a)
+        else
+          [] # no arguments
+        end
+
+        # create new subclass of ActiveResource::Base
+        active_resource_class = Class.new(ActiveResource::Base)
+        active_resource_class.site = param(workitem, :site) # set site parameter
+        active_resource_class.element_name = param(workitem, :resource_name) # set element name
+
+        # Do we work on a single or on a set of resources? If resource_id is nil
+        # or negative, it's a set of resources.
+
+        resource_id = param(workitem, :resource_id)
+
+        active_resource = if (!resource_id) || (resource_id.to_i < 0)
+          # set of resources
+          active_resource_class
+        else
+          # specific resource
+          active_resource_class.new(:id => resource_id)
+        end
+
+        response = active_resource.send(param(workitem, :method), args)
+
+        # we got our response, but what to do with it?
+        if (h = param(workitem, :response_handling)).is_a?(Proc)
+          h.call(response, workitem)
+        end
+
+        # reply to the engine
+        reply_to_engine(workitem)
+      end
+
+      protected
+
+      def param (workitem, key)
+        workitem.params[key] || @options[key]
+      end
+    end
+
+  end
+end

data/lib/openwfe/extras/participants/activeparticipants.rb

@@ -1,749 +1,3 @@
-#
-#--
-# Copyright (c) 2007-2008, John Mettraux, Tomaso Tosolini 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.
-#++
-#
 
-#
-# "made in Japan"
-#
-# John Mettraux at openwfe.org
-# Tomaso Tosolini
-#
-
-#require 'rubygems'
-
-#require_gem 'activerecord'
-gem 'activerecord'; require 'active_record'
-
-
-require 'openwfe/workitem'
-require 'openwfe/flowexpressionid'
-require 'openwfe/engine/engine'
-require 'openwfe/participants/participant'
-
-
-module OpenWFE
-module Extras
-
-  #MUTEX = Mutex.new
-
-  #
-  # The migration for ActiveParticipant and associated classes.
-  #
-  # There are two tables 'workitems' and 'fields'. As its name implies,
-  # the latter table stores the fields (also called attributes in OpenWFE
-  # speak) of the workitems.
-  #
-  # See Workitem and Field for more details.
-  #
-  # For centralization purposes, the migration and the model are located
-  # in the same source file. It should be quite easy for the Rails hackers
-  # among you to sort that out for a Rails based usage.
-  #
-  class WorkitemTables < ActiveRecord::Migration
-
-    def self.up
-
-      create_table :workitems do |t|
-        t.column :fei, :string
-        t.column :wfid, :string
-        t.column :wf_name, :string
-        t.column :wf_revision, :string
-        t.column :participant_name, :string
-        t.column :store_name, :string
-        t.column :dispatch_time, :timestamp
-        t.column :last_modified, :timestamp
-
-        t.column :yattributes, :text
-          # when using compact_workitems, attributes are stored here
-      end
-      add_index :workitems, :fei, :unique => true
-        # with sqlite3, comment out this :unique => true on :fei :(
-      add_index :workitems, :wfid
-      add_index :workitems, :wf_name
-      add_index :workitems, :wf_revision
-      add_index :workitems, :participant_name
-      add_index :workitems, :store_name
-
-      create_table :fields do |t|
-        t.column :fkey, :string, :null => false
-        t.column :vclass, :string, :null => false
-        t.column :svalue, :string
-        t.column :yvalue, :text
-        t.column :workitem_id, :integer, :null => false
-      end
-      add_index :fields, [ :workitem_id, :fkey ], :unique => true
-      add_index :fields, :fkey
-      add_index :fields, :vclass
-      add_index :fields, :svalue
-    end
-
-    def self.down
-
-      drop_table :workitems
-      drop_table :fields
-    end
-  end
-
-  #
-  # Reopening InFlowWorkItem to add a 'db_id' attribute.
-  #
-  class OpenWFE::InFlowWorkItem
-
-    attr_accessor :db_id
-  end
-
-  #
-  # The ActiveRecord version of an OpenWFEru workitem (InFlowWorkItem).
-  #
-  # One can very easily build a worklist based on a participant name via :
-  #
-  #   wl = OpenWFE::Extras::Workitem.find_all_by_participant_name("toto")
-  #   puts "found #{wl.size} workitems for participant 'toto'"
-  #
-  # These workitems are not OpenWFEru workitems directly. But the conversion
-  # is pretty easy.
-  # Note that you probaly won't need to do the conversion by yourself,
-  # except for certain advanced scenarii.
-  #
-  #   awi = OpenWFE::Extras::Workitem.find_by_participant_name("toto")
-  #     #
-  #     # returns the first workitem in the database whose participant
-  #     # name is 'toto'.
-  #
-  #   owi = awi.as_owfe_workitem
-  #     #
-  #     # Now we have a copy of the reference as a OpenWFEru
-  #     # InFlowWorkItem instance.
-  #
-  #   awi = OpenWFE::Extras::Workitem.from_owfe_workitem(owi)
-  #     #
-  #     # turns an OpenWFEru InFlowWorkItem instance into an
-  #     # 'active workitem'.
-  #
-  class Workitem < ActiveRecord::Base
-
-    has_many :fields, :dependent => :destroy
-
-    serialize :yattributes
-
-
-    #
-    # Returns the flow expression id of this work (its unique OpenWFEru
-    # identifier) as a FlowExpressionId instance.
-    # (within the Workitem it's just stored as a String).
-    #
-    def full_fei
-
-      OpenWFE::FlowExpressionId.from_s(fei)
-    end
-
-    #
-    # Making sure last_modified is set to Time.now before each save.
-    #
-    def before_save
-
-      touch
-    end
-
-    #
-    # Generates a (new) Workitem from an OpenWFEru InFlowWorkItem instance.
-    #
-    # This is a 'static' method :
-    #
-    #   awi = OpenWFE::Extras::Workitem.from_owfe_workitem(wi)
-    #
-    # (This method saves the 'ActiveWorkitem').
-    #
-    def Workitem.from_owfe_workitem (wi, store_name=nil)
-
-      i = Workitem.new
-      i.fei = wi.fei.to_s
-      i.wfid = wi.fei.wfid
-      i.wf_name = wi.fei.workflow_definition_name
-      i.wf_revision = wi.fei.workflow_definition_revision
-      i.participant_name = wi.participant_name
-      i.dispatch_time = wi.dispatch_time
-      i.last_modified = nil
-
-      i.store_name = store_name
-
-      i.save!
-        # save workitem before adding any field
-        # making sure it has an id...
-
-      i = Workitem.find_by_fei(wi.fei.to_s) if i.id == 0
-        # sometimes, the saved workitem id wasn't updated, was remaining at 0
-        # thus finding if necessary...
-
-      #i.fields.delete_all
-        # why do I need that ??? fields were getting recycled...
-
-      # This is a field set by the active participant immediately
-      # before calling this method.
-      # the default behavior is "use field method"
-
-      if wi.attributes["compact_workitems"]
-
-        wi.attributes.delete("compact_workitems")
-        i.yattributes = wi.attributes
-
-      else
-
-        i.yattributes = nil
-
-        wi.attributes.each do |k, v|
-          i.fields << Field.new_field(k, v)
-        end
-      end
-
-      i.save!
-        # making sure to throw an exception in case of trouble
-        #
-        # damn, insert then update :(
-
-      i
-    end
-
-    #
-    # Turns the densha Workitem into an OpenWFEru InFlowWorkItem.
-    #
-    def as_owfe_workitem
-
-      wi = OpenWFE::InFlowWorkItem.new
-
-      wi.fei = full_fei
-      wi.participant_name = participant_name
-      wi.attributes = fields_hash
-
-      wi.dispatch_time = dispatch_time
-      wi.last_modified = last_modified
-
-      wi.db_id = self.id
-
-      wi
-    end
-
-    #
-    # Returns a hash version of the 'fields' of this workitem.
-    #
-    # (Each time this method is called, it returns a new hash).
-    #
-    def fields_hash
-
-      return self.yattributes if self.yattributes
-
-      fields.inject({}) do |r, f|
-        r[f.fkey] = f.value
-        r
-      end
-    end
-
-    #
-    # Replaces the current fields of this workitem with the given hash.
-    #
-    # This method modifies the content of the db.
-    #
-    def replace_fields (fhash)
-
-      if self.yattributes
-
-        self.yattributes = fhash
-
-      else
-
-        fields.delete_all
-
-        fhash.each do |k, v|
-          fields << Field.new_field(k, v)
-        end
-      end
-
-      #f = Field.new_field("___map_type", "smap")
-        #
-        # an old trick for backward compatibility with OpenWFEja
-
-      save!
-        # making sure to throw an exception in case of trouble
-    end
-
-    #
-    # Returns the Field instance with the given key. This method accept
-    # symbols as well as strings as its parameter.
-    #
-    #   wi.field("customer_name")
-    #   wi.field :customer_name
-    #
-    def field (key)
-
-      if self.yattributes
-        return self.yattributes[key.to_s]
-      end
-
-      fields.find_by_fkey key.to_s
-    end
-
-    #
-    # A shortcut method, replies to the workflow engine and removes self
-    # from the database.
-    # Handy for people who don't want to play with an ActiveParticipant
-    # instance when just consuming workitems (that an active participant
-    # pushed in the database).
-    #
-    def reply (engine)
-
-      engine.reply self.as_owfe_workitem
-      self.destroy
-    end
-
-    alias :forward :reply
-    alias :proceed :reply
-
-    #
-    # Simply sets the 'last_modified' field to now.
-    # (Doesn't save the workitem though).
-    #
-    def touch
-
-      self.last_modified = Time.now
-    end
-
-    #
-    # Opening engine to update its reply method to accept these
-    # active record workitems.
-    #
-    class OpenWFE::Engine
-
-      alias :oldreply :reply
-
-      def reply (workitem)
-
-        if workitem.is_a?(Workitem)
-
-          oldreply(workitem.as_owfe_workitem)
-          workitem.destroy
-        else
-
-          oldreply(workitem)
-        end
-      end
-
-      alias :forward :reply
-      alias :proceed :reply
-    end
-
-    #
-    # Returns all the workitems belonging to the stores listed
-    # in the parameter storename_list.
-    # The result is a Hash whose keys are the store names and whose
-    # values are list of workitems.
-    #
-    def self.find_in_stores (storename_list)
-
-      workitems = find_all_by_store_name(storename_list)
-
-      result = {}
-
-      workitems.each do |wi|
-        (result[wi.store_name] ||= []) << wi
-      end
-
-      result
-    end
-
-    #
-    # A kind of 'google search' among workitems
-    #
-    # == Note
-    #
-    # when this is used on compact_workitems, it will not be able to search
-    # info within the fields, because they aren't used by this kind of
-    # workitems. In this case the search will be limited to participant_name
-    #
-    def self.search (search_string, storename_list=nil)
-
-      #t = OpenWFE::Timer.new
-
-      storename_list = Array(storename_list) if storename_list
-
-      # participant_name
-
-      result = find(
-        :all,
-        :conditions => conditions(
-          "participant_name", search_string, storename_list),
-        :order => "participant_name")
-        # :limit => 10)
-
-      ids = result.collect { |wi| wi.id }
-
-      # search in fields
-
-      fields = Field.search search_string, storename_list
-      merge_search_results ids, result, fields
-
-      #puts "... took #{t.duration} ms"
-
-      # over.
-
-      result
-    end
-
-    #
-    # Not really about 'just launched', but rather about finding the first
-    # workitem for a given process instance (wfid) and a participant.
-    # It deserves its own method because the workitem could be in a
-    # subprocess, thus escaping the vanilla find_by_wfid_and_participant()
-    #
-    def self.find_just_launched (wfid, participant_name)
-
-      find(
-        :first,
-        :conditions => [
-          "wfid LIKE ? AND participant_name = ?",
-          "#{wfid}%",
-          participant_name ])
-    end
-
-    protected
-
-      #
-      # builds the condition (the WHERE clause) for the
-      # search.
-      #
-      def self.conditions (keyname, search_string, storename_list)
-
-        cs = [ "#{keyname} LIKE ?", search_string ]
-
-        if storename_list
-
-          cs[0] = "#{cs[0]} AND workitems.store_name IN (?)"
-          cs << storename_list
-        end
-
-        cs
-      end
-
-      def self.merge_search_results (ids, wis, new_wis)
-
-        return if new_wis.size < 1
-
-        new_wis.each do |wi|
-          wi = wi.workitem if wi.kind_of?(Field)
-          next if ids.include? wi.id
-          ids << wi.id
-          wis << wi
-        end
-      end
-  end
-
-  #
-  # A workaround is in place for some classes when then have to get
-  # serialized. The names of thoses classes are listed in this array.
-  #
-  SPECIAL_FIELD_CLASSES = [ 'Time', 'Date', 'DateTime' ]
-
-  #
-  # A Field (Attribute) of a Workitem.
-  #
-  class Field < ActiveRecord::Base
-
-    belongs_to :workitem
-    serialize :yvalue
-
-    #
-    # A quick method for doing
-    #
-    #   f = Field.new
-    #   f.key = key
-    #   f.value = value
-    #
-    # One can then quickly add fields to an [active] workitem via :
-    #
-    #   wi.fields << Field.new_field("toto", "b")
-    #
-    # This method does not save the new Field.
-    #
-    def self.new_field (key, value)
-
-      f = Field.new
-      f.fkey = key
-      f.vclass = value.class.to_s
-      f.value = value
-      f
-    end
-
-    def value= (v)
-
-      limit = connection.native_database_types[:string][:limit]
-
-      if v.is_a?(String) and v.length <= limit
-
-        self.svalue = v
-
-      elsif SPECIAL_FIELD_CLASSES.include?(v.class.to_s)
-
-        self.svalue = v.to_yaml
-
-      else
-
-        self.yvalue = v
-      end
-    end
-
-    def value
-
-      return YAML.load(self.svalue) \
-        if SPECIAL_FIELD_CLASSES.include?(self.vclass)
-
-      self.svalue || self.yvalue
-    end
-
-    #
-    # Will return all the fields that contain the given text.
-    #
-    # Looks in svalue and fkey. Looks as well in yvalue if it contains
-    # a string.
-    #
-    # This method is used by Workitem.search()
-    #
-    def self.search (text, storename_list=nil)
-
-      cs = build_search_conditions(text)
-
-      if storename_list
-
-        cs[0] = "(#{cs[0]}) AND workitems.store_name IN (?)"
-        cs << storename_list
-      end
-
-      find :all, :conditions => cs, :include => :workitem
-    end
-
-    protected
-
-      #
-      # The search operates on the content of these columns
-      #
-      FIELDS_TO_SEARCH = %w{ svalue fkey yvalue }
-
-      #
-      # Builds the condition array for a pseudo text search
-      #
-      def self.build_search_conditions (text)
-
-        has_percent = (text.index("%") != nil)
-
-        conds = []
-
-        conds << FIELDS_TO_SEARCH.collect { |key|
-
-          count = has_percent ? 1 : 4
-
-          s = ([ "#{key} LIKE ?" ] * count).join(" OR ")
-
-          s = "(vclass = ? AND (#{s}))" if key == 'yvalue'
-
-          s
-        }.join(" OR ")
-
-        FIELDS_TO_SEARCH.each do |key|
-
-          conds << 'String' if key == 'yvalue'
-
-          conds << text
-
-          unless has_percent
-            conds << "% #{text} %"
-            conds << "% #{text}"
-            conds << "#{text} %"
-          end
-        end
-
-        conds
-      end
-  end
-
-
-  #
-  # A basic 'ActiveParticipant'.
-  # A store participant whose store is a set of ActiveRecord tables.
-  #
-  # Sample usage :
-  #
-  #   class MyDefinition < OpenWFE::ProcessDefinition
-  #     sequence do
-  #       active0
-  #       active1
-  #     end
-  #   end
-  #
-  #   def play_with_the_engine
-  #
-  #     engine = OpenWFE::Engine.new
-  #
-  #     engine.register_participant(
-  #       :active0, OpenWFE::Extras::ActiveParticipant)
-  #     engine.register_participant(
-  #       :active1, OpenWFE::Extras::ActiveParticipant)
-  #
-  #     li = OpenWFE::LaunchItem.new(MyDefinition)
-  #     li.customer_name = 'toto'
-  #     engine.launch li
-  #
-  #     sleep 0.500
-  #       # give some slack to the engine, it's asynchronous after all
-  #
-  #     wi = OpenWFE::Extras::Workitem.find_by_participant_name("active0")
-  #
-  #     # ...
-  #  end
-  #
-  # == Compact workitems
-  #
-  # It is possible to save all the workitem data into a single table,
-  # the workitems table, without
-  # splitting info between workitems and fields tables.
-  #
-  # You can configure the "compact_workitems" behavior by adding to the
-  # previous lines:
-  #
-  #   active0 = engine.register_participant(
-  #     :active0, OpenWFE::Extras::ActiveParticipant)
-  #
-  #   active0.compact_workitems = true
-  #
-  # This behaviour is determined participant per participant, it's ok to
-  # have a participant instance that compacts will there is another that
-  # doesn't compact.
-  #
-  class ActiveParticipant
-    include OpenWFE::LocalParticipant
-
-    #
-    # when compact_workitems is set to true, the attributes of a workitem
-    # are stored in the yattributes column (they are not expanded into
-    # the Fields table).
-    # By default, workitem attributes are expanded.
-    #
-    attr :compact_workitems, true
-
-    #
-    # This is the method called by the OpenWFEru engine to hand a
-    # workitem to this participant.
-    #
-    def consume (workitem)
-
-      if compact_workitems
-        workitem.attributes["compact_workitems"] = true
-      end
-
-      Workitem.from_owfe_workitem workitem
-    end
-
-    #
-    # Called by the engine when the whole process instance (or just the
-    # segment of it that sports this participant) is cancelled.
-    # Will removed the workitem with the same fei as the cancelitem
-    # from the database.
-    #
-    # No expression will be raised if there is no corresponding workitem.
-    #
-    def cancel (cancelitem)
-
-      Workitem.destroy_all([ "fei = ?", cancelitem.fei.to_s ])
-        # note that delete_all was not removing workitem fields
-    end
-
-    #
-    # When the activity/work/operation whatever is over and the flow
-    # should resume, this is the method to use to hand back the [modified]
-    # workitem to the [local] engine.
-    #
-    def reply_to_engine (workitem)
-
-      super workitem.as_owfe_workitem
-        #
-        # replies to the workflow engine
-
-      workitem.destroy
-        #
-        # removes the workitem from the database
-    end
-  end
-
-  #
-  # An extension of ActiveParticipant. It has a 'store_name' and it
-  # makes sure to flag every workitem it 'consumes' with that name
-  # (in its 'store_name' column/field).
-  #
-  # This is the participant used mainly in 'densha' for human users.
-  #
-  class ActiveStoreParticipant < ActiveParticipant
-    include Enumerable
-
-    def initialize (store_name)
-
-      super()
-      @store_name = store_name
-    end
-
-    #
-    # This is the method called by the OpenWFEru engine to hand a
-    # workitem to this participant.
-    #
-    def consume (workitem)
-
-      if compact_workitems
-        workitem.attributes["compact_workitems"] = true
-      end
-
-      Workitem.from_owfe_workitem(workitem, @store_name)
-    end
-
-    #
-    # Iterates over the workitems currently in this store.
-    #
-    def each (&block)
-
-      return unless block
-
-      wis = Workitem.find_by_store_name @store_name
-
-      wis.each do |wi|
-        block.call wi
-      end
-    end
-  end
-
-end
-end
+require File.dirname(__FILE__) + '/active_participants'