exact-target 0.0.4

data/lib/exact_target/net_https_hack.rb

@@ -0,0 +1,8 @@
+class Net::HTTP
+  alias_method :old_initialize, :initialize
+  def initialize(*args)
+    old_initialize(*args)
+    @ssl_context = OpenSSL::SSL::SSLContext.new
+    @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+  end
+end

data/lib/exact_target/request_builder.rb

@@ -0,0 +1,284 @@
+require 'builder'
+
+module ExactTarget
+  class RequestBuilder
+
+    def initialize(config)
+      @config = config
+    end
+
+    def accountinfo_retrieve_attrbs
+      build(:accountinfo, :retrieve_attrbs)
+    end
+
+    def list_add(list_name, list_type=nil)
+      list_type = :public unless %w(public private salesforce).include?(list_type.to_s)
+      build(:list, :add) do |li|
+        li.list_type list_type.to_s
+        li.list_name list_name.to_s
+      end
+    end
+
+    def list_edit(list_id, new_list_name)
+      build(:list, :edit, :listid, list_id) do |li|
+        li.list_name new_list_name.to_s
+      end
+    end
+
+    def list_retrieve(id_or_name=nil)
+      if id_or_name.is_a?(Fixnum) or id_or_name =~ /^\d+$/
+        build(:list, :retrieve, :listid, id_or_name.to_i)
+      else
+        build(:list, :retrieve, :listname, id_or_name)
+      end
+    end
+
+    def list_import(list_id, file_name, file_mapping, options={})
+      options = list_import_default_options(options, file_name)
+      build(:list, :import, :listid, list_id) do |li|
+        li.tags_from_options! options, :file_name, :email_address, :file_type, :column_headings
+        li.file_mapping do |fm|
+          file_mapping.each { |m| fm.field(m) }
+        end
+        li.tags_from_options! options, :import_type, :returnid, :encrypted, :encrypt_format
+      end
+    end
+
+    def list_importstatus(import_id)
+      build(
+        :list, :import,
+        :sub_action => :importstatus,
+        :search_type => :omit,
+        :search_value => import_id
+      )
+    end
+
+    def list_retrieve_sub(list_id, status=nil)
+      unless status.nil? or %w(Active Unsubscribed Returned Undeliverable Deleted).include?(status)
+        raise "Invalid status: #{status}"
+      end
+      build(:list, :retrieve_sub, :listid, list_id) do |li|
+        li.search_status status unless status.nil?
+      end
+    end
+
+    def list_delete(id)
+      build(:list, :delete, :listid, id)
+    end
+
+    def list_retrievegroups
+      build(:list, :retrievegroups, :groups)
+    end
+
+    def list_refresh_group(group_id)
+      build(
+        :list, :refresh_group,
+        :sub_action => nil,
+        :search_type => :omit,
+        :search_value => group_id,
+        :search_value2 => nil
+      )
+    end
+
+    def batch_inquire(batch_id)
+      build(
+        :batch, :inquire, :batchid, batch_id,
+        :sub_action => nil,
+        :search_value2 => nil
+      )
+    end
+
+    ###################################################################
+
+    def subscriber_add(list_id, subscriber, options={})
+      subscriber_edit(list_id, nil, subscriber, options)
+    end
+
+    def subscriber_edit(list_id, orig_email, subscriber, options={})
+      options = subscriber_edit_default_options(options)
+      subscriber = subscriber.to_et_hash if subscriber.is_a?(Subscriber)
+      action = orig_email.nil? ? :add : :edit
+      build(:subscriber, action, :listid, list_id, :search_value2 => orig_email) do |sub|
+        sub.values do |vs|
+          subscriber.each do |k, v|
+            vs.tag!(k.to_s, v) unless k.to_s =~ /status/i
+          end
+          vs.status options[:status].to_s
+          vs.reason options[:reason] if options.has_key? :reason
+          vs.ChannelMemberID options[:ChannelMemberID] if options.has_key? :ChannelMemberID
+        end
+        sub.update options[:update] if orig_email.nil?
+      end
+    end
+
+    def subscriber_retrieve(id, email=nil)
+      type = email.blank? ? :subid : :listid
+      build(:subscriber, :retrieve, type, id, :search_value2 => email)
+    end
+
+    def subscriber_delete(id, email=nil)
+      type = email.blank? ? :subid : :listid
+      build(:subscriber, :delete, type, id, :search_value2 => email)
+    end
+
+    def subscriber_masterunsub(*email_addresses)
+      build(:subscriber, :masterunsub, :emailaddress, :search_value => :omit) do |sub|
+        sub.search_value do |sv|
+          email_addresses.flatten.each { |a| sv.emailaddress(a) }
+        end
+      end
+    end
+
+    ###################################################################
+
+    def email_retrieve(name=nil, options={})
+      name, options = nil, name if name.is_a?(Hash)
+      start_date, end_date = %w(start_date end_date).map do |n|
+        et_date options[n.to_sym]
+      end
+      type = unless start_date.nil? and end_date.nil?
+               name.nil? ? :daterange : :emailnameanddaterange
+             else
+               name.nil? ? nil : :emailname
+             end
+      build(:email, :retrieve, type, name, :sub_action => :all, :search_value2 => nil) do |em|
+        em.daterange do |r|
+          r.startdate start_date if start_date
+          r.enddate   end_date   if end_date
+        end
+      end
+    end
+
+    def email_add(name, subject, options)
+      build(:email, :add, :search_type => :omit, :search_value => :omit, :sub_action => 'HTMLPaste') do |em|
+        em.category
+        em.email_name name
+        em.email_subject subject
+        if options.has_key? :body
+          em.email_body { |eb| eb.cdata! options[:body] }
+        elsif options.has_key? :file
+          em.file_name options[:file]
+        end
+      end
+    end
+
+    def email_add_text(email_id, options)
+      build(:email, :add, :search_type => :emailid,
+                  :search_value => email_id, :sub_action => :text) do |em|
+        if options.has_key? :body
+          em.email_body { |eb| eb.cdata! options[:body] }
+        elsif options.has_key? :file
+          em.file_name options[:file]
+        end
+      end
+    end
+
+    def email_retrieve_body(email_id)
+      build(:email, :retrieve, :emailid, email_id, :sub_action => :htmlemail) do |em|
+        em.search_value2
+        em.search_value3
+      end
+    end
+
+    ###################################################################
+
+    def job_send(email_id, list_ids, options={})
+      options = job_send_default_options(options)
+
+      build(:job, :send, :emailid, email_id) do |job|
+        job.tags_from_options! options, :from_name, :from_email, :additional,
+                                        :multipart_mime, :track_links,
+                                        :send_date, :send_time
+        job_send_id_list job, :lists, list_ids
+        job_send_id_list job, :suppress, options[:suppress_ids]
+        job.test_send options[:test_send]
+      end
+    end
+
+    ###################################################################
+    private
+    ###################################################################
+
+    def list_import_default_options(options, file_name)
+      options = options.dup
+      options[:file_name]         = file_name
+      options[:file_type]       ||= (file_name =~ /\.txt$/i ? 'tab' : 'csv')
+      options[:column_headings] ||= true
+      options[:import_type]     ||= 0
+      options[:returnid]        ||= true
+      options[:encrypted]       ||= false
+      options
+    end
+
+    def subscriber_edit_default_options(options)
+      options = options.dup
+      options[:status] = :active unless options[:status].to_s == 'unsub'
+      options[:update] = true unless options[:update] == false
+      options
+    end
+
+    def job_send_default_options(options)
+      options = options.nil? ? {} : options.dup # Don't munge hash passed in
+      options[:multipart_mime] = false unless options.has_key? :multipart_mime
+      options[:track_links]    = true  unless options.has_key? :track_links
+      options[:test_send]      = false unless options.has_key? :test_send
+      options[:send_date]    ||= :immediate
+      options[:suppress_ids] ||= []
+      options
+    end
+
+    def job_send_id_list(job, tag, ids)
+      job.tag!(tag.to_s) do |li|
+        [ids].flatten.compact.each { |id| li.list id }
+      end
+    end
+
+    def et_date(d)
+      d = Date.parse(d) if d.is_a?(String)
+      [d.month, d.day, d.year] * '/' if d
+    end
+
+    def build(system_name, action, search_type=nil, search_value=nil, options=nil, &block)
+      options = parse_options(search_type, search_value, options)
+      xml = Builder::XmlMarkup.new
+      xml.instruct! :xml, :version => "1.0", :encoding => nil
+      xml = xml.exacttarget do |et|
+        et.authorization do |a|
+          a.username @config.username
+          a.password @config.password
+        end
+        et.system do |s|
+          build_system(s, system_name, action, options, &block)
+        end
+      end
+      xml.to_s
+    end
+
+    def parse_options(search_type, search_value, options)
+      options, search_type = search_type, nil if search_type.is_a?(Hash)
+      options, search_value = search_value, nil if search_value.is_a?(Hash)
+      options ||= {}
+      { :search_type => search_type, :search_value => search_value }.merge(options)
+    end
+
+    def build_system(s, system_name, action, options, &block)
+      s.system_name system_name.to_s
+      s.action action.to_s
+      [:sub_action, :search_type, :search_value, :search_value2].each do |name|
+        build_system_option(s, name, options[name]) if options.has_key? name
+      end
+      yield(s) if block_given?
+    end
+
+    def build_system_option(s, name, value)
+      if name == :search_value and value.is_a?(Array)
+        s.search_values do |ss|
+          value.each { |v| ss.search_value v }
+        end
+      elsif value != :omit
+        s.tag! name.to_s, value.to_s
+      end
+    end
+
+  end
+end

data/lib/exact_target/response_class.erb

@@ -0,0 +1,30 @@
+class <%= name %>
+
+  <% attributes.each do |rb_a, et_a| %>
+    attr_accessor :<%= rb_a %>
+
+    <% if rb_a != et_a %>
+    alias :<%= et_a %> :<%= rb_a %>
+    alias :<%= et_a %>= :<%= rb_a %>=
+    <% end %>
+  <% end %>
+
+  def attributes
+    [<%= attributes.map { |rb_a, et_a| ":#{rb_a}" } * ', ' %>]
+  end
+
+  def et_attributes
+    [<%= attributes.map { |rb_a, et_a| ":#{et_a}" } * ', ' %>]
+  end
+
+  def to_hash
+    attributes.map { |a| [a, send(a)] }
+  end
+
+  def to_et_hash
+    et_attributes.map { |a| [a, send(a)] }
+  end
+
+  alias :to_s :<%= attributes.first.first %>
+
+end

data/lib/exact_target/response_classes.rb

@@ -0,0 +1,61 @@
+require 'erb'
+
+module ExactTarget
+  #
+  # Response classes for ExactTarget.  We'll use these rather
+  # than just stuff it all in a hash as it allows us to more
+  # easily map between ugly ET names (e.g. GroupID) to ruby-friendly
+  # names (e.g. group_id).
+  #
+  module ResponseClasses
+    class << self
+
+      def extended(base)
+        class_from_et_attributes base, :ListProfileAttribute,
+          :name, :description, :default_value, :data_type, :required,
+          :min_size, :max_size, :subscriber_editable, :display, :values
+
+        class_from_et_attributes base, :ListInformation,
+         :list_name, :list_type, :modified, :subscriber_count,
+         :active_total, :held_count, :bounce_count, :unsub_count
+
+        class_from_et_attributes base, :ListGroupInformation,
+          :groupName, :groupID, :parentlistID, :description
+
+        class_from_et_attributes base, :SubscriberInformation,
+          :subid, :listid, :list_name, :subscriber
+
+        class_from_et_attributes base, :EmailInformation,
+          :emailname, :emailid, :emailsubject, :emailcreateddate, :categoryid
+
+        def base.subscriber_class
+          @subscriber_class ||= ResponseClasses.class_from_et_attributes(
+            self, :Subscriber, accountinfo_retrieve_attrbs.map(&:name)
+          )
+        end
+
+        def base.const_missing(name)
+          if name.to_sym == :Subscriber
+            subscriber_class
+          else
+            super
+          end
+        end
+      end
+
+      def class_from_et_attributes(base, name, *attribute_names)
+        attributes = attribute_names.flatten.map do |a|
+          [a.to_s.underscore.gsub(' ', '_'), a.to_s.gsub(' ', '__')]
+        end
+        class_def = class_template.result(binding)
+        base.module_eval(class_def)
+        base.const_get(name)
+      end
+
+      def class_template
+        @class_template ||= ERB.new File.read(File.expand_path '../response_class.erb', __FILE__)
+      end
+
+    end
+  end
+end

data/lib/exact_target/response_handler.rb

@@ -0,0 +1,167 @@
+require 'builder'
+
+module ExactTarget
+  #
+  # This class is responsible for turning parsed ExactTarget response xml
+  # into data that applications can use
+  #
+  class ResponseHandler
+
+    def initialize(config)
+      @config = config
+    end
+
+    def handle_import_id_result(resp)
+      handle_id_result resp, :import_info, :importid, /is being imported/i
+    end
+
+    %w(email job list subscriber).each do |t|
+      define_method "handle_#{t}_id_result", lambda { |resp|
+        handle_id_result resp, "#{t}_info", "#{t}_description", /success/i
+      }
+    end
+
+    def accountinfo_retrieve_attrbs(resp)
+      resp.xpath('//attribute').map do |a|
+        create_result(ListProfileAttribute, a) do |child|
+          child.children.map { |v| cast_value(v.text) } if child.name == 'values'
+        end
+      end
+    end
+
+    alias :list_add :handle_list_id_result
+
+    alias :list_edit :handle_list_id_result
+
+    def list_retrieve(resp)
+      if resp.xpath('//list/list_name').size == 1
+        resp.xpath('//list[1]').map do |list|
+          create_result(ListInformation, list)
+        end.first
+      else
+        resp.xpath('//listid').map do |id|
+          id.text.to_i
+        end
+      end
+    end
+
+    alias :list_import :handle_import_id_result
+
+    def list_importstatus(resp)
+      resp.xpath('//import_info[1]').first.text
+    end
+
+    def list_retrieve_sub(resp)
+      resp.xpath('//subscriber').map do |s|
+        return [] if s.text =~ /no subscribers found/i
+        create_result(Subscriber, s)
+      end
+    end
+
+    alias :list_delete :handle_list_id_result
+
+    def list_retrievegroups(resp)
+      resp.xpath('//group').map do |group|
+        create_result(ListGroupInformation, group)
+      end
+    end
+
+    def list_refresh_group(resp)
+      resp.xpath('//groupRefresh/groupAsyncID[1]').first.text.to_i
+    end
+
+    def batch_inquire(resp)
+      resp.xpath('//Batch/status[1]').first.text
+    end
+
+    ###################################################################
+
+    alias :subscriber_add :handle_subscriber_id_result
+
+    alias :subscriber_edit :handle_subscriber_id_result
+
+    def subscriber_retrieve(resp)
+      resp.xpath('//subscriber').map do |s|
+        return [] if s.text =~ /no subscribers found/i
+        sri = create_result(SubscriberInformation, s)
+        sri.subscriber = create_result(Subscriber, s)
+        sri
+      end
+    end
+
+    alias :subscriber_delete :handle_subscriber_id_result
+
+    def subscriber_masterunsub(resp)
+      resp = resp.xpath('//subscriberunsub').map do |su|
+        %w(emailaddress status).map { |p| su.xpath(".//#{p}[1]").first.text }
+      end
+      Hash[resp]
+    end
+
+    ###################################################################
+
+    def email_retrieve(resp)
+      resp.xpath('//emaillist').map do |el|
+        create_result(EmailInformation, el)
+      end
+    end
+
+    def email_add(resp)
+      resp.xpath('//emailID[1]').first.text.to_i
+    end
+
+    alias :email_add_text :handle_email_id_result
+
+    def email_retrieve_body(resp)
+      resp.xpath('//htmlbody[1]').first.text
+    end
+
+    ###################################################################
+
+    alias :job_send :handle_job_id_result
+
+    ###################################################################
+    private
+    ###################################################################
+
+    def handle_id_result(resp, info_tag, id_tag, success_regex)
+      info = resp.xpath("//#{info_tag}[1]").first
+      if !info.nil? and info.text =~ success_regex
+        id = resp.xpath("//#{id_tag}[1]").first
+        id.nil? ? true : cast_value(id.text)
+      else
+        raise Error.new(0, "Unsupported id result: #{resp.to_s}")
+      end
+    end
+
+    def create_result(clazz, node, &block)
+      ret = clazz.new
+      node.children.each do |child|
+        if ret.respond_to? "#{child.name}="
+          val = yield(child) if block_given?
+          val = cast_value(child.text) if val.nil?
+          ret.send "#{child.name}=", val
+        end
+      end
+      ret
+    end
+
+    def cast_value(v)
+      case v
+      when /^[+-]?\d+$/
+        v.to_i
+      when /^([+-]?)(?=\dâ\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/
+        v.to_f
+      when /^true$/i
+        true
+      when /^false$/i
+        false
+      when %r{^\d+/\d+/\d+ \d+:\d+:\d+ [AP]M$}i, %r{^\d+/\d+/\d+$}i
+        DateTime.parse(v)
+      else
+        v.strip
+      end
+    end
+
+  end
+end