ruote-extras 0.9.18

data/lib/openwfe/extras/listeners/sqslisteners.rb

@@ -0,0 +1,146 @@
+#
+#--
+# Copyright (c) 2007-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.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'yaml'
+require 'base64'
+require 'monitor'
+
+require 'openwfe/service'
+require 'openwfe/listeners/listener'
+
+#require 'rubygems'
+require 'rufus/sqs' # gem 'rufus-sqs'
+
+
+module OpenWFE
+module Extras
+
+    #
+    # Polls an Amazon SQS queue for workitems
+    #
+    # Workitems can be instances of InFlowWorkItem or LaunchItem.
+    #
+    #     require 'openwfe/extras/listeners/sqslisteners'
+    #
+    #     ql = OpenWFE::SqsListener("workqueue1", engine.application_context)
+    #
+    #     engine.add_workitem_listener(ql, "2m30s")
+    #         #
+    #         # thus, the engine will poll our "workqueue1" SQS queue
+    #         # every 2 minutes and 30 seconds
+    #
+    class SqsListener < Service
+
+        include MonitorMixin
+        include WorkItemListener
+        include Rufus::Schedulable
+
+        #
+        # The name of the Amazon SQS whom this listener cares for
+        #
+        attr_reader :queue_name
+
+        def initialize (queue_name, application_context)
+
+            @queue_name = queue_name.to_s
+
+            service_name = "#{self.class}::#{@queue_name}"
+
+            super service_name, application_context
+
+            linfo { "new() queue is '#{@queue_name}'" }
+        end
+
+        #
+        # polls the SQS for incoming messages
+        #
+        def trigger (params)
+            synchronize do
+
+                ldebug { "trigger()" }
+
+                qs = Rufus::SQS::QueueService.new
+
+                qs.create_queue @queue_name
+                    # just to be sure it is there
+
+                while true
+
+                    l = qs.get_messages(
+                        @queue_name, :timeout => 0, :count => 255)
+
+                    break if l.length < 1
+
+                    l.each do |msg|
+
+                        o = decode_object msg
+
+                        handle_item o
+
+                        msg.delete
+
+                        ldebug do 
+                            "trigger() " +
+                            "handled successfully msg #{msg.message_id}" 
+                        end
+                    end
+                end
+            end
+        end
+
+        #
+        # Extracts a workitem from the message's body.
+        #
+        # By default, this listeners assumes the workitem is stored in
+        # its "hash form" (not directly as a Ruby InFlowWorkItem instance).
+        #
+        # LaunchItem instances (as hash as well) are also accepted.
+        #
+        def decode_object (message)
+
+            o = Base64.decode64 message.message_body
+            o = YAML.load o
+            o = OpenWFE::workitem_from_h o
+            o
+        end
+    end
+
+end
+end
+

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

@@ -0,0 +1,264 @@
+#
+#--
+# Copyright (c) 2007-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.
+#++
+#
+
+#
+# "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'
+require 'atom/collection' # gem 'atoom-tools'
+
+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 OpenWFE::ServiceMixin
+        include OpenWFE::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)
+
+            #ldebug "call() c '#{channel}' entries count : #{@entries.size}"
+
+            e = Entry.new
+
+            e.participant_name = channel
+            e.upon = args[0]
+            e.workitem = args[1].dup
+            e.updated = Time.now
+
+            e.id = \
+                "#{e.workitem.participant_name} - #{e.upon} " +
+                "#{e.workitem.fei.workflow_instance_id}--" +
+                "#{e.workitem.fei.expression_id}"
+
+            @entries << e
+
+            while @entries.length > @max_item_count
+                @entries.delete_at 0
+            end
+        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::Feed.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/misc/basecamp.rb

@@ -0,0 +1,485 @@
+
+#
+# This code was written by 37signals.com
+#
+# The original is at : 
+# http://developer.37signals.com/basecamp/basecamp.rb
+#
+
+require 'net/https'
+require 'yaml'
+require 'date'
+require 'time'
+
+#require 'rubygems'
+gem 'xml-simple'; require 'xmlsimple'
+
+# An interface to the Basecamp web-services API. Usage is straightforward:
+#
+#   session = Basecamp.new('your.basecamp.com', 'username', 'password')
+#   puts "projects: #{session.projects.length}"
+class Basecamp #:nodoc:
+  
+  # A wrapper to encapsulate the data returned by Basecamp, for easier access.
+  class Record #:nodoc:
+    attr_reader :type
+
+    def initialize(type, hash)
+      @type = type
+      @hash = hash
+    end
+
+    def [](name)
+      name = dashify(name)
+      case @hash[name]
+        when Hash then 
+          @hash[name] = (@hash[name].keys.length == 1 && Array === @hash[name].values.first) ?
+            @hash[name].values.first.map { |v| Record.new(@hash[name].keys.first, v) } :
+            Record.new(name, @hash[name])
+        else @hash[name]
+      end
+    end
+
+    def id
+      @hash["id"]
+    end
+
+    def attributes
+      @hash.keys
+    end
+
+    def respond_to?(sym)
+      super || @hash.has_key?(dashify(sym))
+    end
+
+    def method_missing(sym, *args)
+      if args.empty? && !block_given? && respond_to?(sym)
+        self[sym]
+      else
+        super
+      end
+    end
+
+    def to_s
+      "\#<Record(#{@type}) #{@hash.inspect[1..-2]}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    private
+
+      def dashify(name)
+        name.to_s.tr("_", "-")
+      end
+  end
+
+  # A wrapper to represent a file that should be uploaded. This is used so that
+  # the form/multi-part encoder knows when to encode a field as a file, versus
+  # when to encode it as a simple field.
+  class FileUpload #:nodoc:
+    attr_reader :filename, :content
+    
+    def initialize(filename, content)
+      @filename = filename
+      @content = content
+    end
+  end
+
+  attr_accessor :use_xml
+
+  # Connects
+  def initialize(url, user_name, password, use_ssl = false)
+    @use_xml = false
+    @user_name, @password = user_name, password
+    connect!(url, use_ssl)
+  end
+
+  # Return the list of all accessible projects.
+  def projects
+    records "project", "/project/list"
+  end
+
+  # Returns the list of message categories for the given project
+  def message_categories(project_id)
+    records "post-category", "/projects/#{project_id}/post_categories"
+  end
+
+  # Returns the list of file categories for the given project
+  def file_categories(project_id)
+    records "attachment-category", "/projects/#{project_id}/attachment_categories"
+  end
+
+  # Return information for the company with the given id
+  def company(id)
+    record "/contacts/company/#{id}"
+  end
+
+  # Return an array of the people in the given company. If the project-id is
+  # given, only people who have access to the given project will be returned.
+  def people(company_id, project_id=nil)
+    url = project_id ? "/projects/#{project_id}" : ""
+    url << "/contacts/people/#{company_id}"
+    records "person", url
+  end
+
+  # Return information about the person with the given id
+  def person(id)
+    record "/contacts/person/#{id}"
+  end
+
+  # Return information about the message(s) with the given id(s). The API
+  # limits you to requesting 25 messages at a time, so if you need to get more
+  # than that, you'll need to do it in multiple requests.
+  def message(*ids)
+    result = records("post", "/msg/get/#{ids.join(",")}")
+    result.length == 1 ? result.first : result
+  end
+
+  # Returns a summary of all messages in the given project (and category, if
+  # specified). The summary is simply the title and category of the message,
+  # as well as the number of attachments (if any).
+  def message_list(project_id, category_id=nil)
+    url = "/projects/#{project_id}/msg"
+    url << "/cat/#{category_id}" if category_id
+    url << "/archive"
+    
+    records "post", url
+  end
+
+  # Create a new message in the given project. The +message+ parameter should
+  # be a hash. The +email_to+ parameter must be an array of person-id's that
+  # should be notified of the post.
+  #
+  # If you want to add attachments to the message, the +attachments+ parameter
+  # should be an array of hashes, where each has has a :name key (optional),
+  # and a :file key (required). The :file key must refer to a Basecamp::FileUpload
+  # instance.
+  #
+  #   msg = session.post_message(158141,
+  #      { :title => "Requirements",
+  #        :body => "Here are the requirements documents you asked for.",
+  #        :category_id => 2301121 },
+  #      [john.id, martha.id],
+  #      [ { :name => "Primary Requirements",
+  #          :file => Basecamp::FileUpload.new('primary.doc", File.read('primary.doc')) },
+  #        { :file => Basecamp::FileUpload.new('other.doc', File.read('other.doc')) } ])
+  def post_message(project_id, message, notify=[], attachments=[])
+    prepare_attachments(attachments)
+    record "/projects/#{project_id}/msg/create",
+      :post => message,
+      :notify => notify,
+      :attachments => attachments
+  end
+
+  # Edit the message with the given id. The +message+ parameter should
+  # be a hash. The +email_to+ parameter must be an array of person-id's that
+  # should be notified of the post.
+  #
+  # The +attachments+ parameter, if used, should be the same as described for
+  # #post_message.
+  def update_message(id, message, notify=[], attachments=[])
+    prepare_attachments(attachments)
+    record "/msg/update/#{id}",
+      :post => message,
+      :notify => notify,
+      :attachments => attachments
+  end
+
+  # Deletes the message with the given id, and returns it.
+  def delete_message(id)
+    record "/msg/delete/#{id}"
+  end
+
+  # Return a list of the comments for the specified message.
+  def comments(post_id)
+    records "comment", "/msg/comments/#{post_id}"
+  end
+
+  # Retrieve a specific comment
+  def comment(id)
+    record "/msg/comment/#{id}"
+  end
+
+  # Add a new comment to a message. +comment+ must be a hash describing the
+  # comment. You can add attachments to the comment, too, by giving them in
+  # an array. See the #post_message method for a description of how to do that.
+  def create_comment(post_id, comment, attachments=[])
+    prepare_attachments(attachments)
+    record "/msg/create_comment", :comment => comment.merge(:post_id => post_id),
+      :attachments => attachments
+  end
+
+  # Update the given comment. Attachments follow the same format as #post_message.
+  def update_comment(id, comment, attachments=[])
+    prepare_attachments(attachments)
+    record "/msg/update_comment", :comment_id => id,
+      :comment => comment, :attachments => attachments
+  end
+
+  # Deletes (and returns) the given comment.
+  def delete_comment(id)
+    record "/msg/delete_comment/#{id}"
+  end
+
+  # =========================================================================
+  # TODO LISTS AND ITEMS
+  # =========================================================================
+
+  # Marks the given item completed.
+  def complete_item(id)
+    record "/todos/complete_item/#{id}"
+  end
+
+  # Marks the given item uncompleted.
+  def uncomplete_item(id)
+    record "/todos/uncomplete_item/#{id}"
+  end
+
+  # Creates a new to-do item.
+  def create_item(list_id, content, responsible_party=nil, notify=true)
+    record "/todos/create_item/#{list_id}",
+      :content => content, :responsible_party => responsible_party,
+      :notify => notify
+  end
+
+  # Creates a new list using the given hash of list metadata.
+  def create_list(project_id, list)
+    record "/projects/#{project_id}/todos/create_list", list
+  end
+
+  # Deletes the given item from it's parent list.
+  def delete_item(id)
+    record "/todos/delete_item/#{id}"
+  end
+
+  # Deletes the given list and all of its items.
+  def delete_list(id)
+    record "/todos/delete_list/#{id}"
+  end
+
+  # Retrieves the specified list, and all of its items.
+  def get_list(id)
+    record "/todos/list/#{id}"
+  end
+
+  # Return all lists for a project. If complete is true, only completed lists
+  # are returned. If complete is false, only uncompleted lists are returned.
+  def lists(project_id, complete=nil)
+    records "todo-list", "/projects/#{project_id}/todos/lists", :complete => complete
+  end
+
+  # Repositions an item to be at the given position in its list
+  def move_item(id, to)
+    record "/todos/move_item/#{id}", :to => to
+  end
+
+  # Repositions a list to be at the given position in its project
+  def move_list(id, to)
+    record "/todos/move_list/#{id}", :to => to
+  end
+
+  # Updates the given item
+  def update_item(id, content, responsible_party=nil, notify=true)
+    record "/todos/update_item/#{id}",
+      :item => { :content => content }, :responsible_party => responsible_party,
+      :notify => notify
+  end
+
+  # Updates the given list's metadata
+  def update_list(id, list)
+    record "/todos/update_list/#{id}", :list => list
+  end
+
+  # =========================================================================
+  # MILESTONES
+  # =========================================================================
+
+  # Complete the milestone with the given id
+  def complete_milestone(id)
+    record "/milestones/complete/#{id}"
+  end
+
+  # Create a new milestone for the given project. +data+ must be hash of the
+  # values to set, including +title+, +deadline+, +responsible_party+, and
+  # +notify+.
+  def create_milestone(project_id, data)
+    create_milestones(project_id, [data]).first
+  end
+
+  # As #create_milestone, but can create multiple milestones in a single
+  # request. The +milestones+ parameter must be an array of milestone values as
+  # descrbed in #create_milestone.
+  def create_milestones(project_id, milestones)
+    records "milestone", "/projects/#{project_id}/milestones/create", :milestone => milestones
+  end
+
+  # Destroys the milestone with the given id.
+  def delete_milestone(id)
+    record "/milestones/delete/#{id}"
+  end
+
+  # Returns a list of all milestones for the given project, optionally filtered
+  # by whether they are completed, late, or upcoming.
+  def milestones(project_id, find="all")
+    records "milestone", "/projects/#{project_id}/milestones/list", :find => find
+  end
+
+  # Uncomplete the milestone with the given id
+  def uncomplete_milestone(id)
+    record "/milestones/uncomplete/#{id}"
+  end
+
+  # Updates an existing milestone.
+  def update_milestone(id, data, move=false, move_off_weekends=false)
+    record "/milestones/update/#{id}", :milestone => data,
+      :move_upcoming_milestones => move,
+      :move_upcoming_milestones_off_weekends => move_off_weekends
+  end
+
+  # Make a raw web-service request to Basecamp. This will return a Hash of
+  # Arrays of the response, and may seem a little odd to the uninitiated.
+  def request(path, parameters = {}, second_try = false)
+    response = post(path, convert_body(parameters), "Content-Type" => content_type)
+
+    if response.code.to_i / 100 == 2
+      result = XmlSimple.xml_in(response.body, 'keeproot' => true,
+        'contentkey' => '__content__', 'forcecontent' => true)
+      typecast_value(result)
+    elsif response.code == "302" && !second_try
+      connect!(@url, !@use_ssl)
+      request(path, parameters, true)
+    else
+      raise "#{response.message} (#{response.code})"
+    end
+  end
+
+  # A convenience method for wrapping the result of a query in a Record
+  # object. This assumes that the result is a singleton, not a collection.
+  def record(path, parameters={})
+    result = request(path, parameters)
+    (result && !result.empty?) ? Record.new(result.keys.first, result.values.first) : nil
+  end
+
+  # A convenience method for wrapping the result of a query in Record
+  # objects. This assumes that the result is a collection--any singleton
+  # result will be wrapped in an array.
+  def records(node, path, parameters={})
+    result = request(path, parameters).values.first or return []
+    result = result[node] or return []
+    result = [result] unless Array === result
+    result.map { |row| Record.new(node, row) }
+  end
+
+  private
+
+    def connect!(url, use_ssl)
+      @use_ssl = use_ssl
+      @url = url
+      @connection = Net::HTTP.new(url, use_ssl ? 443 : 80)
+      @connection.use_ssl = @use_ssl
+      @connection.verify_mode = OpenSSL::SSL::VERIFY_NONE if @use_ssl
+    end
+
+    def convert_body(body)
+      body = use_xml ? body.to_xml : body.to_yaml
+    end
+
+    def content_type
+      use_xml ? "application/xml" : "application/x-yaml"
+    end
+
+    def post(path, body, header={})
+      request = Net::HTTP::Post.new(path, header.merge('Accept' => 'application/xml'))
+      request.basic_auth(@user_name, @password)
+      @connection.request(request, body)
+    end
+
+    def store_file(contents)
+      response = post("/upload", contents, 'Content-Type' => 'application/octet-stream',
+        'Accept' => 'application/xml')
+
+      if response.code == "200"
+        result = XmlSimple.xml_in(response.body, 'keeproot' => true, 'forcearray' => false)
+        return result["upload"]["id"]
+      else
+        raise "Could not store file: #{response.message} (#{response.code})"
+      end
+    end
+
+    def typecast_value(value)
+      case value
+      when Hash
+        if value.has_key?("__content__")
+          content = translate_entities(value["__content__"]).strip
+          case value["type"]
+          when "integer"  then content.to_i
+          when "boolean"  then content == "true"
+          when "datetime" then Time.parse(content)
+          when "date"     then Date.parse(content)
+          else                 content
+          end
+        # a special case to work-around a bug in XmlSimple. When you have an empty
+        # tag that has an attribute, XmlSimple will not add the __content__ key
+        # to the returned hash. Thus, we check for the presense of the 'type'
+        # attribute to look for empty, typed tags, and simply return nil for
+        # their value.
+        elsif value.keys == %w(type)
+          nil
+        elsif value["nil"] == "true"
+          nil
+        # another special case, introduced by the latest rails, where an array
+        # type now exists. This is parsed by XmlSimple as a two-key hash, where
+        # one key is 'type' and the other is the actual array value.
+        elsif value.keys.length == 2 && value["type"] == "array"
+          value.delete("type")
+          typecast_value(value)
+        else
+          value.empty? ? nil : value.inject({}) do |h,(k,v)|
+            h[k] = typecast_value(v)
+            h
+          end
+        end
+      when Array
+        value.map! { |i| typecast_value(i) }
+        case value.length
+        when 0 then nil
+        when 1 then value.first
+        else value
+        end
+      else
+        raise "can't typecast #{value.inspect}"
+      end
+    end
+
+    def translate_entities(value)
+      value.gsub(/&lt;/, "<").
+            gsub(/&gt;/, ">").
+            gsub(/&quot;/, '"').
+            gsub(/&apos;/, "'").
+            gsub(/&amp;/, "&")
+    end
+
+    def prepare_attachments(list)
+      (list || []).each do |data|
+        upload = data[:file]
+        id = store_file(upload.content)
+        data[:file] = { :file => id,
+                        :content_type => "application/octet-stream",
+                        :original_filename => upload.filename }
+      end
+    end
+end
+
+# A minor hack to let Xml-Simple serialize symbolic keys in hashes
+#class Symbol
+#  def [](*args)
+#    to_s[*args]
+#  end
+#end
+#class Hash
+#  def to_xml
+#    XmlSimple.xml_out({:request => self}, 'keeproot' => true, 'noattr' => true)
+#  end
+#end