etapper 0.0.0

data/lib/etapper/classes/journal_entry.rb

@@ -0,0 +1,91 @@
+require 'etapper/classes/account'
+
+module Etapper
+  class JournalEntry < EtapAbstract
+    
+    TYPES = {
+      :note => 1,
+      :contact => 2,
+      :gift => 5,
+      :pledge => 6,
+      :payment => 7,
+      :recurring_gift_schedule => 8,
+      :recurring_gift => 9,
+      :segmented_donation => 10,
+      :soft_credit => 11,
+      :disbursement => 12,
+      :segmented_pledge => 13
+    }
+    
+ 
+    attr_reader :type
+    etap_read_only :ref, :type, :accountName, :accountRef
+    
+    # Set the 'type' field based on the real class name, if it wasn't already
+    def initialize(base = nil)
+      super
+      @type = self.class.symbolize
+      @base.type ||= TYPES[@type]
+    end
+    
+    def definedValues
+      @base.definedValues ||= Etapper::API::ArrayOfDefinedValue.new
+      @definedValues ||= Etapper::DefinedValueHash.new(base.definedValues)
+    end
+    
+    # Associates the account that this gift belongs to.
+    def account
+      @account ||= Account.find(accountRef)
+    end
+    
+    # Sets the account that this gift belongs to.
+    def account=(val)
+      @account = val
+      @base.accountRef = val.ref
+    end
+    
+    # Returns the name of the class as a symbol (e.g. :gift)
+    def self.symbolize
+      cname.symbolize
+    end
+    
+    # Returns the type number of the particular subclass (e.g. 5)
+    def self.type
+      TYPES[self.symbolize]
+    end
+    
+    # Returns the "get" method of the class as a symbol (e.g. :getGift)
+    def self.getter
+      "get#{cname}".to_sym
+    end
+    
+    def self.find(query)
+      case query
+      when /\d+\.\d+\.\d+/  # "4310.0.2276679"
+        g = client.send(getter, query)
+        new(g) if g
+      when Hash
+        a = Account.find(query[:account])
+        findByAccount(a)
+      end
+    end
+    
+    # Retrieves a collection of gifts using getJournalEntries given an account
+    def self.findByAccount(account, options={})
+      p = Etapper::API::PagedJournalEntriesRequest.new(true, # clearCache
+                                                       100,  # count
+                                                       0,    # start
+                                                       account.ref,
+                                                       nil,   # baseQuery
+                                                       options[:endDate],
+                                                       options[:startDate], 
+                                                       [type])
+      j = Etapper.client.getJournalEntries(p)
+      if j.count > 0
+        j.data.collect {|je| new(je)}
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/etapper/classes/journal_entry_collection.rb

@@ -0,0 +1,70 @@
+require 'date'
+
+module Etapper
+  # Retrieves journal entries consecutively from eTapestry, and allows us to enumerate over them.
+  class JournalEntryCollection < Enumerator
+    attr_reader :request, :account
+    
+    # Returns a new collection of journal entries. _Requires_ an Etapper::Account object as the first
+    # parameter. Also allows options (:type, :count, etc) to be passed to the journal entry request.
+    def initialize(account=nil, options={})
+      raise RequiredFieldError, "An account is required!" unless @account = account
+      
+      # Set up our request
+      @request = API::PagedJournalEntriesRequest.new
+      @request.accountRef = account.ref
+      @request.count = options[:count] || 100   # Default to the largest request we can make
+      @request.startDate = options[:startDate].to_date if options[:startDate]
+      @request.endDate = options[:endDate].to_date if options[:endDate]
+      @request.baseQuery = options[:baseQuery]
+      @request.start = options[:start]
+      if options[:type]
+        @request.types = [JournalEntry::TYPES[options[:type]]]
+      elsif options[:types]
+        @request.types = options[:types].collect {|t| JournalEntry::TYPES[t]}
+      end
+      
+      # Make the request
+      @response = Etapper.client.getJournalEntries(@request)
+      @total = @response.total  # Do we have all the records?
+      @records = @response.data
+      
+      enum = Proc.new do |yielder|
+        counter = 0
+        while counter < @total
+          if counter == @records.length  # Retrieve more records
+            @request.start = counter
+            more = Etapper.client.getJournalEntries(@request)
+            @records += more.data
+          end
+          record = @records[counter]
+          etapper_class = Etapper.etapper_class(record.class)
+          
+          yielder.yield etapper_class.new(record)
+          counter += 1
+        end
+      end
+      
+      super(&enum)
+    end
+    
+    def size
+      @total
+    end
+    
+    def complete?
+      @records.count == size
+    end
+    
+    # Adds a journal entry of the appropriate type to the account, and to the end of this collection.
+    # Note that no exceptional validations happen here, and the added record may not match the collection's
+    # query parameters.  Use with moderate caution.
+    def <<(addendum)
+      addendum.account = @account
+      addendum.save
+      @records.push addendum  # Add to the end of this collection
+      @total += 1  # Increase the size of the collection
+      self  # Return the object again so that << can be chained
+    end
+  end
+end

data/lib/etapper/classes/phone.rb

@@ -0,0 +1,53 @@
+require 'etapper/classes/hashable'
+
+module Etapper
+  class Phone
+    include Hashable
+    
+    TYPES = [
+      :voice,
+      :mobile,
+      :pager,
+      :fax,
+      :business,
+      :home
+      ]
+                   
+    def initialize(params = {})
+      if params.kind_of?(Etapper::API::Phone)  # Simply wrap the API object we're given
+        @base = params
+      else
+        raise Etapper::BadValueError, "You must supply a valid type!" unless TYPES.include?(params[:type])
+        raise Etapper::BadValueError, "You must supply a phone number!" unless params[:number]
+        @base = Etapper::API::Phone.new(params[:number], params[:type].titleize)
+      end
+    end
+    
+    def base
+      @base
+    end
+    
+    def type
+      @base.type.symbolize
+    end
+    
+    def type=(val)
+      @base.type = val.titleize
+    end
+    
+    def number
+      @base.number
+    end
+    
+    def number=(val)
+      @base.number = val
+    end
+    
+    
+    alias_method :key, :type
+    alias_method :key=, :type=
+    alias_method :value, :number
+    alias_method :value=, :number=
+
+  end
+end

data/lib/etapper/classes/phone_hash.rb

@@ -0,0 +1,10 @@
+require 'etapper/classes/etap_hash'
+require 'etapper/classes/phone'
+
+module Etapper
+  class PhoneHash < EtapHash
+    def initialize(array_from_api)
+      super(array_from_api, Phone, :type, :number)
+    end
+  end
+end

data/lib/etapper/client.rb

@@ -0,0 +1,121 @@
+require 'etapper/api/serviceDriver'
+require 'forwardable'
+require 'uri'
+require 'singleton'
+require 'etapper/core_ext/string'
+require 'etapper/core_ext/symbol'
+require 'etapper/session_filter'
+require 'yaml'
+
+module Etapper
+  class Client
+    extend Forwardable
+    include Singleton
+    
+    attr_accessor :autoconnect
+    
+    # Some of our methods are really at the driver level
+    def_delegator :@driver, :endpoint_url, :url
+    def_delegator :@driver, :endpoint_url=, :url=
+    
+    def initialize
+      @driver = API::MessagingService.new
+      # Set the session handler
+      @driver.streamhandler.filterchain << SessionFilter.new
+      self.url = Etapper::ETAP_URL   # 'nil' is a valid value
+      @autoconnect = true
+      @username = nil
+      @password = nil      
+      @connected = false
+    end
+    
+    def username
+      @username ||= ENV['ETAPPER_USERNAME'] || config_file["username"]
+    end
+    
+    def username=(val)
+      @username = val
+      disconnect
+    end
+    
+    def password
+      @password ||= ENV['ETAPPER_PASSWORD'] || config_file["password"]
+    end
+    
+    def password=(val)
+      @password = val
+      disconnect
+    end
+
+    # Delegates from the driver's annoyingly named wiredump_dev property
+    def log
+      driver.wiredump_dev
+    end
+    
+    # Delegates to the driver's annoyingly named wiredump_dev property
+    def log=(logthing)
+      driver.wiredump_dev = logthing
+    end
+    
+    def connected?
+      @connected
+    end
+    
+    def connect
+      unless connected?
+        raise ConnectionError, "Username is required!" unless username
+        raise ConnectionError, "Password is required!" unless password
+        result = @driver.login(@username, @password)
+        if result == ''
+          @connected = true
+        else  # May need a redirect
+          newurl = URI.parse(result)
+          newurl.query = nil   # Strip off the '?wsdl' parameter at the end
+          driver.endpoint_url = newurl.to_s
+          @connected = connect
+        end
+      end
+    end
+    
+    def disconnect
+      driver.logout if connected?
+      @connected = false
+      true
+    end
+    
+    # Our primary proxy. Sends anything we don't know about to the driver for processing.
+    def method_missing(method, *params)
+      raise NoMethodError if method == :driver  # This is protected for a reason
+      unless connected?
+        if autoconnect
+          connect
+        else
+          raise ConnectionError, "Autoconnect is disabled! Use the 'connect' method before making any API calls."
+        end
+      end
+      driver.send(method, *params)
+    end
+ 
+  protected
+    def driver
+      @driver
+    end
+    
+    def config_file
+      unless @config_file
+        location = File.join(Etapper::ETAPPER_DIR, 'config.yml')
+        if File.exists?(location)
+          @config_file = ::YAML.load_file(location)
+        else
+          @config_file = {}
+        end
+      end
+      @config_file
+    end
+  end
+  
+  # Returns the Etapper::Class singleton object.
+  def self.client
+    Client.instance
+  end
+end

data/lib/etapper/core_ext/string.rb

@@ -0,0 +1,7 @@
+require 'english/style_orm'
+
+class String
+  def symbolize
+    self.snakecase.tr(' ','_').gsub(/[^\w_]/,'').to_sym
+  end
+end

data/lib/etapper/core_ext/symbol.rb

@@ -0,0 +1,7 @@
+require 'english/style_orm'
+
+class Symbol
+  def titleize
+    self.to_s.titleize
+  end
+end

data/lib/etapper/exceptions.rb

@@ -0,0 +1,15 @@
+module Etapper
+  # Some attribute value is out of range or otherwise invalid for the eTapestry API.
+  class BadValueError < StandardError; end
+  
+  # This value cannot be set by the client according to the eTapestry API specification.
+  class ReadOnlyError < StandardError; end
+  
+  # A connection could not be made.  The username or password may be invalid, or Etapper::Client.autoconnect
+  # may be set to false and you didn't run 'connect' before calling an API method.
+  class ConnectionError < StandardError; end
+  
+  # A required field was left empty.
+  class RequiredFieldError < StandardError; end
+end
+

data/lib/etapper/session_filter.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'soap/rpc/driver'
+require 'soap/filter/streamhandler'
+
+module Etapper
+  class SessionFilter < SOAP::Filter::StreamHandler
+    attr_accessor :cookie_values
+
+    def initialize
+      @cookie_values = {}
+    end
+
+    def on_http_outbound(req)
+      if cookies.empty?
+        req.header.delete('Cookie')
+      else
+        req.header['Cookie'] = cookies
+      end
+      
+      # Tweak the XML body to fit eTapestry's quirks and bugs
+      b = HTTP::Message::Body.new
+      c = req.body.content
+      c.gsub!(/>\s*</m,'><')  # Remove whitespace between elements
+      c.gsub!(/<(\S+) xsi:nil="true"><\/\1>/,'')  # Strip out elements that are simply nil
+      b.init_request(c)
+      req.body = b
+    end
+
+    def on_http_inbound(req, res)
+      res.header['Set-Cookie'].each do |cookie|
+        value = cookie.sub(/;.*/, '')
+        if value =~ /(.*?)\s*=\s*(.*)/
+          @cookie_values[$1] = $2
+        end
+      end
+    end
+
+    private
+      def cookies
+        cookie_array = []
+        @cookie_values.each {|key, value| cookie_array << "#{key}=#{value}"}
+        cookie_array.join("; ")
+      end
+  end
+end

data/lib/etapper/soap/generator.rb

@@ -0,0 +1,14 @@
+# The broken SOAP server that eTapestry uses (probably SAAJ from what I can tell) chokes if the XML
+# request contains any spaces or linebreaks between elements.  So we'll strip them all out the
+# most direct way we can, straight from the method that produces the XML text.
+
+module SOAP
+  class Generator
+    alias_method :orig_generate, :generate
+    def generate(obj, io = nil)
+      orig_generate(obj, io)  # Sets the @buf instance variable
+      @buf.gsub!(/>\s*</m, '><')
+    end
+  end
+end
+