openwferu-extras 0.9.15 → 0.9.16

data/lib/openwfe/extras/misc/activityfeed.rb

@@ -0,0 +1,275 @@
+#
+#--
+# Copyright (c) 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.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+#
+# this participant requires atom-tools from
+#
+# http://code.necronomicorp.com/trac/atom-tools 
+#
+# atom-tools' license is X11/MIT
+#
+
+#require 'monitor'
+
+require 'rubygems'
+
+begin
+    require 'atom/collection'
+rescue LoadError
+    #
+    # soft dependency on 'atom-tools'
+    #
+    puts
+    puts
+    puts "'atom/collection' is missing. You can install with :"
+    puts
+    puts "    [sudo] gem install atom-tools"
+    puts
+    puts
+    exit 1
+end
+
+require 'openwfe/service'
+
+
+
+module OpenWFE::Extras
+
+    #
+    # A workitem event as kept
+    #
+    class Entry
+
+        attr_accessor :id
+        attr_accessor :updated
+
+        attr_accessor :participant_name
+        attr_accessor :upon
+        attr_accessor :workitem
+
+        def initialize
+
+            @update = Time.now
+        end
+
+        def as_atom_entry
+
+            e = Atom::Entry.new
+
+            e.id = @id
+            e.updated = @updated
+
+            e
+        end
+    end
+
+    #
+    # This feed registers as an observer to the ParticipantMap.
+    # Each time a workitem is delivered to a participant or comes back from/for
+    # it, an AtomEntry is generated.
+    # The get_feed() method produces an atom feed of participant activity.
+    #
+    class ActivityFeedService
+        #include MonitorMixin
+        include ServiceMixin
+        include OwfeServiceLocator 
+
+
+        attr_accessor :max_item_count
+
+
+        #
+        # This service is generally tied to an engine by doing :
+        #
+        #     engine.init_service 'activityFeed', ActivityFeedService
+        #
+        # The init_service() will take care of calling the constructor
+        # implemented here.
+        #
+        def initialize (service_name, application_context)
+
+            super()
+
+            service_init service_name, application_context
+
+            @entries = []
+            @max_item_count = 100
+
+            get_participant_map.add_observer ".*", self
+        end
+
+        #
+        # This is the method call by the expression pool each time a
+        # workitem reaches a participant.
+        #
+        def call (channel, *args)
+
+            e = Entry.new
+
+            e.participant_name = channel
+            e.upon = args[0]
+            e.workitem = args[1].dup
+
+            e.id = \
+                "#{e.workitem.participant_name} - #{e.upon} " +
+                "#{e.workitem.fei.workflow_instance_id}--" +
+                "#{e.workitem.fei.expression_id}"
+
+            @entries << e
+
+            @entries = @entries[0, @max_item_count] \
+                if @entries.length > @max_item_count
+        end
+
+        #
+        # Returns an Atom feed of all the workitem activity for the 
+        # participants whose name matches the given regular expression.
+        #
+        # Options :
+        #
+        # [:upon]       can be set to either nil, :apply, :reply. :apply states
+        #               that the returned feed should only contain entries about
+        #               participant getting applied, :reply only about 
+        #               participant replying.
+        # [:feed_uri]   the URI for the feed. Defaults to 
+        #               'http://localhost/feed'
+        # [:feed_title] the title for the feed. Defaults to 
+        #               'OpenWFEru engine activity feed'
+        # [:format]     yaml|text|json
+        #
+        #
+        def get_feed (participant_regex, options={})
+
+            participant_regex = Regexp.compile(participant_regex) \
+                if participant_regex.is_a?(String)
+
+            upon = options[:upon]
+            feed_uri = options[:feed_uri] || "http://localhost/feed"
+            title = options[:feed_title] || "OpenWFEru engine activity feed"
+
+            feed = Atom::Collection.new feed_uri
+            feed.title = title
+
+            format = options[:format]
+            format = validate_format(format)
+
+            @entries.each do |e|
+
+                next unless participant_regex.match(e.participant_name)
+                next if upon and upon != e.upon
+
+                feed.updated = e.updated \
+                    if feed.updated == nil or e.updated > feed.updated
+
+                feed << as_atom_entry(format, e)
+            end
+
+            feed
+        end
+
+        protected
+
+            #
+            # Makes sure the required 'render' is valid. Returns it
+            # as a Symbol.
+            #
+            def validate_format (f)
+
+                f = "as_#{f}"
+                return :as_yaml unless methods.include?(f)
+                f.to_sym
+            end
+
+            def as_atom_entry (render, entry)
+
+                send(
+                    render, 
+                    entry.as_atom_entry, 
+                    entry.participant_name, 
+                    entry.upon, 
+                    entry.workitem)
+            end
+
+            #
+            # A basic rendition of a workitem as a YAML string
+            #
+            def as_yaml (atom_entry, participant_name, upon, workitem)
+
+                atom_entry.title = "#{participant_name} - #{upon}"
+                atom_entry.content = workitem.to_yaml
+                atom_entry.content['type'] = "text/plain"
+
+                atom_entry
+            end
+
+            #class Atom::Content
+            #    def convert_contents e
+            #        REXML::CData.new(@content.to_s)
+            #    end
+            #end
+
+            #
+            # A basic rendition of a workitem as text.
+            #
+            def as_text (atom_entry, participant_name, upon, workitem)
+
+                atom_entry.title = "#{participant_name} - #{upon}"
+
+                atom_entry.content = workitem.to_s
+                atom_entry.content['type'] = "text/plain"
+
+                atom_entry
+            end
+
+            #
+            # Renders the workitem as a JSON string.
+            #
+            def as_json (atom_entry, participant_name, upon, workitem)
+
+                atom_entry.title = "#{participant_name} - #{upon}"
+
+                atom_entry.content = workitem.to_json
+                atom_entry.content['type'] = "text/plain"
+
+                atom_entry
+            end
+    end
+
+end
+

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

@@ -68,7 +68,7 @@ module Extras
     # 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 OwfeTables < ActiveRecord::Migration
+    class WorkitemTables < ActiveRecord::Migration
 
         def self.up
 
@@ -106,6 +106,14 @@ module Extras
         end
     end
 
+    #
+    # Reopening InFlowWorkItem to add a 'db_id' attribute.
+    #
+    class InFlowWorkItem
+
+        attr_accessor :db_id
+    end
+
     #
     # The ActiveRecord version of an OpenWFEru workitem (InFlowWorkItem).
     #
@@ -179,7 +187,7 @@ module Extras
                 end
 
                 i.save!
-
+                    # making sure to throw an exception in case of trouble
             end
 
             i
@@ -191,10 +199,14 @@ module Extras
         def as_owfe_workitem
 
             wi = OpenWFE::InFlowWorkItem.new
+
             wi.fei = full_fei
             wi.participant_name = participant_name
             wi.attributes = fields_hash
             # don't care about dispatch_time and last_modified
+
+            wi.db_id = self.id
+
             wi
         end
 
@@ -230,6 +242,7 @@ module Extras
                 # an old trick for backward compatibility with OpenWFEja
 
             save!
+                # making sure to throw an exception in case of trouble
         end
 
         #
@@ -302,6 +315,78 @@ module Extras
 
             result
         end
+
+        #
+        # A kind of 'google search' among workitems
+        #
+        def Workitem.search (search_string, storename_list=nil)
+
+            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 }
+
+            # svalue
+
+            fields = Field.find(
+                :all,
+                :conditions => conditions(
+                    "svalue", search_string, storename_list),
+                :include => :workitem)
+
+            merge_search_results(ids, result, fields)
+
+            # fkey
+
+            fields = Field.find(
+                :all,
+                :conditions => conditions(
+                    "fkey", search_string, storename_list),
+                :include => :workitem)
+
+            merge_search_results(ids, result, fields)
+
+            # over.
+
+            result
+        end
+
+        protected
+
+            #
+            # builds the condition (the WHERE clause) for the
+            # search.
+            #
+            def Workitem.conditions (keyname, search_string, storename_list)
+
+                if storename_list
+                    [ "#{keyname} LIKE ? AND workitems.store_name IN (?)",
+                      search_string, storename_list ]
+                else
+                    [ "#{keyname} LIKE ?",
+                      search_string ]
+                end
+            end
+
+            def Workitem.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
 
     #

data/lib/openwfe/extras/participants/{atomparticipants.rb → atomfeed_participants.rb}

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id$
-#
 
 #
 # "made in Japan"
@@ -70,15 +68,14 @@ end
 require 'openwfe/participants/participant'
 
 
-module OpenWFE
-module Extras
+module OpenWFE::Extras
 
     #
     # Stores the incoming workitem into an 'atom feed'
     #
     # An example :
     #
-    #     feed0 = AtomParticipant.new(
+    #     feed0 = AtomFeedParticipant.new(
     #         20,                          # no more than 20 entries are kept
     #         """
     #         <p>
@@ -89,13 +86,13 @@ module Extras
     # The 'template' parameter may contain an instance of File instead of
     # an instance of String.
     #
-    #     feed0 = AtomParticipant.new(
+    #     feed0 = AtomFeedParticipant.new(
     #         20, File.new("path/to/my/atom/template.txt")
     #
     # The template can be passed as the second parameter (after the max entry
     # count) or as a block :
     #
-    #     feed1 = AtomParticipant.new(20) do |flow_expression, atom_participant, workitem|
+    #     feed1 = AtomFeedParticipant.new(20) do |flow_expression, atom_participant, workitem|
     #         #
     #         # usually only the workitem parameter is used
     #         # but the other two allow for advanced tricks...
@@ -117,15 +114,19 @@ module Extras
     # "atom-tools" from http://code.necronomicorp.com/trac/atom-tools
     #
     #
-    class AtomParticipant
-        include LocalParticipant, MonitorMixin
+    class AtomFeedParticipant
+        include MonitorMixin
+        include LocalParticipant
+        include TemplateMixin
 
-        attr_accessor \
-            :content_type       # blocks may manipulate them
+        #
+        # Made accessible so that blocks may set it.
+        #
+        attr_accessor :content_type
 
         def initialize (max_item_count, template=nil, &block)
 
-            super()
+            super() # very important as this class includes MonitorMixin
 
             @template = template
             @max_item_count = max_item_count
@@ -160,24 +161,15 @@ module Extras
 
         protected
 
+            #
+            # This base implementation simply calls the eval_template()
+            # method of the TemplateMixin.
+            # Feel free to override this render() method for custom 
+            # representations.
+            #
             def render (workitem)
 
-                fe = get_flow_expression(workitem)
-
-                template = if @block_template
-                    #@block_template.call(fe, self, workitem)
-                    call_block @block_template, workitem
-                elsif @template
-                    if @template.kind_of? File
-                        @template.readlines
-                    else
-                        @template.to_s
-                    end
-                else
-                    "(no template given)"
-                end
-
-                OpenWFE::dosub(template, fe, workitem)
+                eval_template workitem
             end
 
             #
@@ -194,5 +186,4 @@ module Extras
     end
 
 end
-end