mosaic-lyris 1.0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README

@@ -0,0 +1,4 @@
+
+    gem 'lyris', '~> 1.0.0'
+    bundle
+

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rake'
+require 'rake/testtask'
+
+task :default => [:test]
+
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end
+
+Rake::Task[:test].comment = "Run all tests"
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "mosaic-lyris"
+    gemspec.summary = "Lyris/EmailLabs API"
+    gemspec.description = "A wrapper for the Lyris/EmailLabs API to simplify integration"
+    gemspec.email = "brent.faulkner@mosaic.com"
+    gemspec.homepage = "http://github.com/mosaicxm/mosaic-lyris"
+    gemspec.authors = ["S. Brent Faulkner"]
+    gemspec.add_dependency('builder')
+    gemspec.add_dependency('active_support')
+    gemspec.add_dependency('htmlentities')
+    gemspec.add_dependency('nokogiri')
+    gemspec.add_dependency('tzinfo')
+    gemspec.add_development_dependency('mocha')
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.1

data/init.rb

@@ -0,0 +1,4 @@
+gem 'nokogiri'
+gem 'htmlentities'
+
+require 'lyris'

data/lib/lyris.rb

@@ -0,0 +1,2 @@
+require 'mosaic/lyris'
+require 'mosaic/lyris_mailer'

data/lib/mosaic/lyris.rb

@@ -0,0 +1,12 @@
+%w(
+  object
+  demographic
+  filter
+  list
+  message
+  partner
+  record
+  trigger
+).each do |file|
+  require File.join(File.dirname(__FILE__),'lyris',file)
+end

data/lib/mosaic/lyris/demographic.rb

@@ -0,0 +1,65 @@
+module Mosaic
+  module Lyris
+    class Demographic < Object
+      attr_reader :enabled,
+                  :group,
+                  :id,
+                  :list_id,
+                  :name,
+                  :options,
+                  :size,
+                  :type
+
+      class << self
+        def add(type, name, options = {})
+          validate_options!(type, options)
+          reply = post('demographic', 'add') do |request|
+            request.MLID options[:list_id] if options[:list_id]
+            put_data(request, demographic_type(type), name)
+            put_array_data(request, 'option', options[:option])
+            put_data(request, 'state', 'enabled') if options[:enabled]
+            put_data(request, 'size', options[:size]) if options[:size]
+          end
+          new(options.merge(:id => reply.at('/DATASET/DATA').inner_html.to_i, :name => name, :type => type))
+        end
+
+        def query(what, options = {})
+          reply = post('demographic', query_type(what)) do |request|
+            request.MLID options[:list_id] if options[:list_id]
+          end
+          reply.search('/DATASET/RECORD').collect do |record|
+            new :enabled => ([:enabled, :enabled_details].include?(what) || get_boolean_data(record, 'state', 'enabled')),
+                :group => get_data(record, "group"),
+                :id => get_integer_data(record, 'id'),
+                :list_id => options[:list_id],
+                :name => get_data(record, 'name'),
+                :options => get_array_data(record, 'option'),
+                :size => get_integer_data(record, 'size'),
+                :type => get_data(record, 'type').downcase.gsub(/ /,'_').to_sym
+          end
+        end
+
+      protected
+        def demographic_type(type)
+          raise ArgumentError, "expected :checkbox, :date, :multiple_checkbox, :multiple_select_list, :radio_button, :select_list, :text or :textarea; got #{type.inspect}" unless %w(checkbox date multiple_checkbox multiple_select_list radio_button select_list text textarea).include?(type.to_s)
+          type.to_s.gsub(/_/,' ')
+        end
+
+        def query_type(what)
+          raise ArgumentError, "expected :all, :enabled or :enabled_details; got #{what.inspect}" unless %w(all enabled enabled_details).include?(what.to_s)
+          "query-#{what}".gsub(/_/,'-')
+        end
+
+        def validate_options!(type, options)
+          if %w(multiple_checkbox multiple_select_list radio_button select_list).include?(type.to_s)
+            raise ArgumentError, "missing options for #{type.inspect} demographic" unless options[:options]
+          else
+            raise ArgumentError, "#{type.inspect} demographic does not support options" if options[:options]
+          end
+          raise ArgumentError, "#{type.inspect} demographic does not support :size option" if options[:size] unless %w(multiple_select_list select_list).include?(type.to_s)
+        end
+      end
+    end
+  end
+end
+

data/lib/mosaic/lyris/filter.rb

@@ -0,0 +1,6 @@
+module Mosaic
+  module Lyris
+    class Filter < Object
+    end
+  end
+end

data/lib/mosaic/lyris/list.rb

@@ -0,0 +1,73 @@
+require 'time'
+
+module Mosaic
+  module Lyris
+    class List < Object
+      attr_reader :cache_time,
+                  :clickthru_url,
+                  :footer_html,
+                  :footer_text,
+                  :handle_autoreply,
+                  :handle_autoreply_email,
+                  :handle_unsubscribe,
+                  :handle_unsubscribe_email,
+                  :id,
+                  :last_sent,
+                  :members,
+                  :messages,
+                  :name,
+                  :reply_forward_email,
+                  :reply_forward_subject,
+                  :reply_from_email,
+                  :reply_from_name,
+                  :status
+
+      def active?
+        status == 'active'
+      end
+
+      def archived?
+        status == 'archived'
+      end
+
+      class << self
+        def add(name, attributes = {})
+          reply = post('list', 'add') do |request|
+            put_data(request, 'name', name)
+            put_extra_data(request, 'CLICKTHRU_URL', attributes[:clickthru_url])
+          end
+          new attributes.merge(:id => reply.at('/DATASET/DATA').inner_html.to_i, :name => name)
+        end
+
+        def delete(id)
+          reply = post('list', 'delete') do |request|
+            request.MLID id
+          end
+          new :id => id
+        end
+
+        def query(what)
+          reply = post('list', query_type(what))
+          reply.search('/DATASET/RECORD').collect do |record|
+            new :cache_time => get_xml_time_data(record, 'cache-time'),
+                :id => get_integer_data(record, 'name', :id),
+                :last_sent => get_date_data(record, 'last-sent'),
+                :members => get_integer_data(record, 'members'),
+                :messages => get_integer_data(record, 'messages'),
+                :name => get_data(record, 'name'),
+                :status => get_data(record, 'status')
+          end
+        end
+
+      protected
+        def query_type(what)
+          if what == :all
+            'query-listdata'
+          else
+            raise ArgumentError, "expected :all, got #{what.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mosaic/lyris/message.rb

@@ -0,0 +1,95 @@
+module Mosaic
+  module Lyris
+    class Message < Object
+      attr_reader :id,
+                  :aol,
+                  :category,
+                  :charset,
+                  :clickthru,
+                  :clickthru_text,
+                  :edited_at,
+                  :format,
+                  :from_email,
+                  :from_name,
+                  :html,
+                  :htmlencoding,
+                  :name,
+                  :rule,
+                  :segment,
+                  :segment_id,
+                  :sent,
+                  :sent_at,
+                  :stats_sent,
+                  :subject,
+                  :text,
+                  :type
+
+      class << self
+        def query(what, options = {})
+          if what == :all
+            query_all(options)
+          else
+            query_one(what, options)
+          end
+        end
+
+      protected
+        def query_all(options)
+          reply = post('message', 'query-listdata') do |request|
+            request.MLID options[:list_id] if options[:list_id]
+          end
+          reply.search('/DATASET/RECORD').collect do |record|
+            edit_time = get_time_data(record, 'last-edit-time')
+            edit_date = get_date_data(record, 'last-edit-date')
+            sent = get_data(record, 'sent')
+            sent_at = (sent == 'yes') ? get_date_data(record, 'date').to_time + get_time_offset_data(record, 'delivery') : nil
+            subject = get_data(record, 'subject')
+            new :id => get_integer_data(record, 'mid'),
+                :category => get_data(record, 'category'),
+                :edited_at => edit_date && (edit_date.to_time + edit_time.to_i - edit_time.to_date.to_time.to_i),
+                :format => get_data(record, 'message-format'),
+                :segment_id => get_integer_data(record, 'segment-id'),
+                :segment => get_data(record, 'segment'),
+                :sent => sent,
+                :sent_at => sent_at,
+                :stats_sent => get_integer_data(record, 'stats-sent'),
+                :subject => subject,
+                :type => get_data(record, 'mlid').blank? ? 'system' : (subject =~ /\APROOF: / ? 'test' : 'user')
+          end
+        end
+
+        def query_one(id, options)
+          reply = post('message', 'query-data') do |request|
+            request.MLID options[:list_id] if options[:list_id]
+            request.MID id
+          end
+          record = reply.at('/DATASET/RECORD')
+          sent = get_data(record, 'sent')
+          sent_at = (sent == 'yes') ? get_date_data(record, 'date').to_time + get_time_offset_data(record, 'delivery') : nil
+          new :id => id,
+              :aol => get_data(record, 'message-aol'),
+              :category => get_data(record, 'category'),
+              :charset => get_data(record, 'charset'),
+              :clickthru => get_boolean_data(record, 'clickthru', 'on'),
+              :clickthru_text => get_boolean_data(record, 'clickthru-text', 'on'),
+              :format => get_data(record, 'message-format'),
+              :from_email => get_data(record, 'from-email'),
+              :from_name => get_data(record, 'from-name'),
+              :html => get_data(record, 'message-html'),
+              :htmlencoding => get_data(record, 'htmlencoding'),
+              :segment_id => get_integer_data(record, 'rule'),
+              :segment => get_data(record, 'rule-name'),
+              :name => get_data(record, 'name'),
+              :sent => sent,
+              :sent_at => sent_at,
+              :subject => get_data(record, 'subject'),
+              :text => get_data(record, 'message-text')
+        end
+      end
+
+      def sent?
+        sent == 'yes'
+      end
+    end
+  end
+end

data/lib/mosaic/lyris/object.rb

@@ -0,0 +1,227 @@
+require 'builder'
+require 'net/https'
+require 'nokogiri'
+require 'uri'
+require 'htmlentities'
+
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/time/calculations'
+
+module Mosaic
+  module Lyris
+    class Error < RuntimeError; end
+
+    class Object
+      private_class_method :new
+
+      @@logger = nil
+
+      def initialize(attributes)
+        attributes.each do |attribute,value|
+          instance_variable_set "@#{attribute}", value unless value.nil?
+        end
+      end
+
+      def to_param
+        id && id.to_s
+      end
+
+      class << self
+        def configuration
+          @@configuration ||= load_configuration
+        end
+
+        def configuration=(value)
+          @@configuration = value
+        end
+
+        def load_configuration
+          configuration = YAML.load_file(File.join(::Rails.root.to_s,'config','lyris.yml')) rescue {}
+          configuration = configuration[::Rails.env] if configuration.include?(::Rails.env)
+          configuration
+        end
+      end
+
+    protected
+      class << self
+        def callback_url
+          configuration['callback_url']
+        end
+
+        def default_list_id
+          configuration['list_id']
+        end
+
+        def default_trigger_id
+          configuration['trigger_id']
+        end
+
+        def get_array_data(record, type)
+          if record.at("DATA[@type='#{type}']")
+            record.search("DATA[@type='#{type}']").collect do |data|
+              if block_given?
+                yield data
+              else
+                data.inner_html
+              end
+            end
+          end
+        end
+
+        def get_boolean_data(record, type, value, attribute = nil, conditions = {})
+          if data = get_data(record, type, attribute, conditions)
+            data == value
+          end
+        end
+
+        def get_data(record, type, attribute = nil, conditions = {})
+          xpath = "DATA[@type='#{type}']"
+          xpath << conditions.collect { |a,v| "[@#{a}='#{v}']" }.join
+          if element = record.at(xpath)
+            data = attribute ? element[attribute] : element.inner_html
+            # TODO: fix encoding if necessary... seems like we should need to convert to UTF-8 here, but this works for now
+            HTMLEntities.new.decode(data.gsub(/&#(\d+);/) { Integer($1).chr })
+          end
+        end
+
+        def get_date_data(record, type, attribute = nil, conditions = {})
+          data = get_data(record, type, attribute, conditions)
+          Date.parse(data) unless data.blank?
+        end
+
+        def get_demographic_data(record)
+          if data = get_array_data(record, 'demographic') { |d| [ d[:id].to_i, d.inner_html ] }
+            data.inject({}) do |h,(k,v)|
+              case h[k]
+              when NilClass
+                h[k] = v
+              when Array
+                h[k] << v
+              else
+                h[k] = Array(h[k])
+                h[k] << v
+              end
+              h
+            end
+          end
+        end
+
+        def get_element(record, element)
+          if data = record.at("/#{element}")
+            data.inner_html
+          end
+        end
+
+        def get_integer_data(record, type, attribute = nil, conditions = {})
+          if data = get_data(record, type, attribute, conditions)
+            data.gsub(/,/,'').to_i
+          end
+        end
+
+        def get_integer_element(record, element)
+          get_element(record, element).to_i
+        end
+
+        def get_time_data(record, type, attribute = nil, conditions = {})
+          if data = get_data(record, type, attribute, conditions)
+            Time.use_zone('Pacific Time (US & Canada)') do
+              Time.zone.parse(data)
+            end
+          end
+        end
+
+        def get_time_element(record, element)
+          if data = get_element(record, element)
+            Time.parse(data) + (Time.zone.utc_offset - Time.zone_offset('PST'))
+          end
+        end
+
+        def get_time_offset_data(record, type, attribute = nil, conditions = {})
+          if offset = get_integer_data(record, type, attribute, conditions)
+            offset + (Time.zone.utc_offset - Time.zone_offset('PST'))
+          end
+        end
+
+        def get_xml_time_data(record, type, attribute = nil, conditions = {})
+          if data = get_data(record, type, attribute, conditions)
+            Time.xmlschema(data)
+          end
+        end
+
+        def logger
+          @@logger ||= nil
+        end
+
+        def logger=(logger)
+          @@logger = logger
+        end
+
+        def password
+          configuration['password']
+        end
+
+        def post(type, activity, &block)
+          xml = Builder::XmlMarkup.new(:indent => 2)
+          xml.instruct!
+          xml.DATASET do
+            xml.SITE_ID site_id
+            put_extra_data(xml, 'password', password)
+            block.call(xml) if block
+          end
+          input = xml.target!
+
+          request = Net::HTTP::Post.new("/API/mailing_list.html")
+          logger.debug ">>>>> REQUEST:\ntype=#{type}\nactivity=#{activity}\ninput=#{input}\n>>>>>" if logger
+          request.set_form_data('type' => type, 'activity' => activity, 'input' => input)
+
+          conn = Net::HTTP.new(server, 443)
+          conn.use_ssl = true
+          conn.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+          conn.start do |http|
+            # TODO: parse encoding from declaration? update declaration after conversion?
+            reply = http.request(request).body
+            logger.debug ">>>>> REPLY:\n#{reply}\n>>>>>" if logger
+            document = Nokogiri.XML(reply)
+            raise Error, (document % '/DATASET/DATA').inner_html unless document % "/DATASET/TYPE[.='success']"
+            document
+          end
+        end
+
+        def put_array_data(request, type, values)
+          Array(values).each do |value|
+            put_data(request, type, value)
+          end
+        end
+        
+        def put_data(request, type, value, attributes = {})
+          request.DATA value, {:type => type}.merge(attributes) unless value.nil?
+        end
+
+        def put_demographic_data(request, demographics)
+          Array(demographics).each do |id, value|
+            Array(value).each do |v|
+              put_data(request, 'demographic', v, :id => id)
+            end
+          end
+        end
+
+        def put_extra_data(request, id, value)
+          put_data(request, 'extra', value, :id => id)
+        end
+
+        def server
+          configuration['server']
+        end
+
+        def site_id
+          configuration['site_id']
+        end
+
+        def triggers
+          configuration['triggers']
+        end
+      end
+    end
+  end
+end