mosaic-lyris 1.0.1

data/lib/mosaic/lyris/partner.rb

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

data/lib/mosaic/lyris/record.rb

@@ -0,0 +1,101 @@
+module Mosaic
+  module Lyris
+    class Record < Object
+      attr_reader :demographics,
+                  :doubleoptin,
+                  :email,
+                  :encoding,
+                  :id,
+                  :joindate,
+                  :list_id,
+                  :proof,
+                  :state,
+                  :statedate,
+                  :trashed,
+                  :trigger
+
+      class << self
+        def add(email, options = {})
+          validate_options!(options)
+          reply = post('record', 'add') do |request|
+            request.MLID options[:list_id] if options[:list_id]
+            put_data(request, 'email', email)
+            put_demographic_data(request, options[:demographics])
+            put_extra_data(request, 'trigger', 'yes') if options[:trigger]
+            put_extra_data(request, 'proof', 'yes') if options[:proof]
+            put_extra_data(request, 'state', options[:state])
+            put_extra_data(request, 'encoding', options[:encoding])
+            put_extra_data(request, 'doubleoptin', 'yes') if options[:doubleoptin]
+          end
+          new(options.merge(:id => reply.at('/DATASET/DATA').inner_html, :email => email, :state => options[:state] || 'active', :trashed => %w(bounced unsubscribed trashed).include?(options[:state].to_s)))
+        end
+
+        def query(what, options = {})
+          if /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i === what
+            query_one(what, options)
+          else
+            query_all(what, options)
+          end
+        end
+
+        def update(email, options = {})
+          validate_options!(options)
+          reply = post('record', 'update') do |request|
+            request.MLID options[:list_id] if options[:list_id]
+            put_data(request, 'email', email)
+            put_extra_data(request, 'new_email', options[:email])
+            put_demographic_data(request, options[:demographics])
+            put_extra_data(request, 'trigger', 'yes') if options[:trigger]
+            put_extra_data(request, 'proof', 'yes') if options[:proof]
+            put_extra_data(request, 'state', options[:state])
+            put_extra_data(request, 'encoding', options[:encoding])
+          end
+          # TODO: query full record? this is an incomplete snapshot of the updated record (ie. it only contains updated attributes/demographics)
+          new(options.merge(:id => reply.at('/DATASET/DATA').inner_html, :email => options[:email] || email, :state => options[:state], :trashed => options[:state] && %w(bounced unsubscribed trashed).include?(options[:state].to_s)))
+        end
+
+      protected
+        def query_all(what, options = {})
+          raise ArgumentError, "expected :all; got #{what.inspect}" unless %w(all).include?(what.to_s)
+          reply = post('record', 'query-listdata') do |request|
+            request.MLID options[:list_id] if options[:list_id]
+            put_extra_data(request, 'pagelimit', options[:per_page])
+            put_extra_data(request, 'page', options[:page] || 1) if options[:per_page]
+            put_extra_data(request, 'type', options[:state])
+          end
+          reply.search('/DATASET/RECORD').collect do |record|
+            new :demographics => get_demographic_data(record),
+                :email => get_data(record, 'email'),
+                :id => get_data(record, 'extra', nil, :id => 'uid'),
+                :list_id => options[:list_id],
+                :proof => get_boolean_data(record, 'extra', 'yes', nil, :id => 'proof'),
+                :state => get_data(record, 'extra', nil, :id => 'state') || 'active',
+                :statedate => get_date_data(record, 'extra', nil, :id => 'statedate'),
+                :trashed => get_boolean_data(record, 'extra', 'y', nil, :id => 'trashed')
+          end
+        end
+
+        def query_one(email, options = {})
+          reply = post('record', 'query-data') do |request|
+            request.MLID options[:list_id] if options[:list_id]
+            put_data(request, 'email', email)
+          end
+          record = reply.at('/DATASET/RECORD')
+          new :demographics => get_demographic_data(record),
+              :email => get_data(record, 'extra', nil, :id => 'email'),
+              :id => get_data(record, 'extra', nil, :id => 'uid'),
+              :joindate => get_time_data(record, 'extra', nil, :id => 'joindate'),
+              :list_id => options[:list_id],
+              :proof => get_boolean_data(record, 'extra', 'yes', nil, :id => 'proof'),
+              :state => get_data(record, 'extra', nil, :id => 'state') || 'active',
+              :statedate => get_date_data(record, 'extra', nil, :id => 'statedate'),
+              :trashed => get_boolean_data(record, 'extra', 'y', nil, :id => 'trashed')
+        end
+
+        def validate_options!(options)
+          raise ArgumentError, "expected state of :active, :bounced, :unsubscribed or :trashed; got #{options[:state]}" unless %w(active bounced unsubscribed trashed).include?(options[:state].to_s) if options[:state]
+        end
+      end
+    end
+  end
+end

data/lib/mosaic/lyris/trigger.rb

@@ -0,0 +1,113 @@
+require 'uri'
+
+module Mosaic
+  module Lyris
+    class Trigger < Object
+      attr_reader :add,
+                  :clickthru,
+                  :enabled,
+                  :id,
+                  :from_email,
+                  :from_name,
+                  :message,
+                  :message_id,
+                  :message_text,
+                  :name,
+                  :not_sent,
+                  :recipients_data,
+                  :sent,
+                  :subject,
+                  :total_opened,
+                  :unique_bounced,
+                  :unique_click,
+                  :unique_opened,
+                  :unique_unsubscribed,
+                  :total_sent
+
+      class << self
+        def fire(id, *recipients)
+          options = recipients.pop if recipients.last.is_a?(Hash)
+          list_id = options[:list_id] || default_list_id
+          id = lookup_trigger(id, :locale => options.delete(:locale)) if id.is_a?(Symbol)
+          reply = post('triggers', 'fire-trigger') do |request|
+            request.MLID list_id if list_id
+            put_extra_data(request, 'trigger_id', id)
+            put_extra_data(request, 'recipients', recipients.join(','))
+            put_extra_data(request, 'recipients_data', recipients_data_url(options[:recipients_data]))
+            put_extra_data(request, 'subject', options[:subject])
+            put_extra_data(request, 'clickthru', 'on') if options[:clickthru]
+            put_extra_data(request, 'add', 'yes') if options[:add]
+            put_extra_data(request, 'message', options[:message])
+            put_extra_data(request, 'message_text', options[:message_text])
+            put_extra_data(request, 'from_email', options[:from_email])
+            put_extra_data(request, 'from_name', options[:from_name])
+          end
+          sent = get_data(reply.at('/DATASET'), 'sent') || ''
+          not_sent = get_data(reply.at('/DATASET'), 'not sent') || ''
+          new options.merge(:id => id, :not_sent => not_sent.split(','), :sent => sent.split(','))
+        end
+
+        def lookup_trigger(key, options = {})
+          locale = options[:locale] || I18n.locale
+          locale = locale.to_s
+          key = key.to_s
+          if triggers[locale].is_a?(Hash) && triggers[locale][key]
+            triggers[locale][key]
+          else
+            triggers[key]
+          end
+        end
+
+        def query(what, options = {})
+          if what == :all
+            query_all(options)
+          else
+            query_one(what, options)
+          end
+        end
+
+        def recipients_data_url(recipients_data)
+          return if recipients_data.nil?
+          return recipients_data if URI.parse(recipients_data).scheme
+          url = URI.parse(callback_url)
+          url.path = recipients_data
+          url.to_s
+        end
+
+      protected
+        def query_all(options)
+          reply = post('triggers', 'query-listdata') do |request|
+            request.MLID options[:list_id] if options[:list_id]
+          end
+          reply.search('/DATASET/RECORD').collect do |record|
+            new :id => get_integer_data(record, 'trigger_id'),
+                :name => get_data(record, 'trigger_name'),
+                :enabled => get_boolean_data(record, 'trigger_enabled', 'on')
+          end
+        end
+
+        def query_one(id, options)
+          reply = post('triggers', 'query-data-summary') do |request|
+            request.MLID options[:list_id] if options[:list_id]
+            put_extra_data(request, 'trigger_id', id)
+          end
+          record = reply.at('/DATASET/RECORD')
+          new :id => get_integer_data(record, 'trigger_id'),
+              :message_id => get_integer_data(record, 'message_id'),
+              :spam_complaints => get_integer_data(record, 'spam_complaints'),
+              :subject => get_data(record, 'message_subject'),
+              :total_opened => get_integer_data(record, 'total_opened'),
+              :total_sent => get_integer_data(record, 'total_sent'),
+              :unique_opened => get_integer_data(record, 'unique_opened'),
+              :unique_click => get_integer_data(record, 'unique_click'),
+              :unique_unsubscribed => get_integer_data(record, 'unique_unsubscribed'),
+              :unique_bounced => get_integer_data(record, 'unique_bounced')
+        end
+      end
+
+      def enabled?
+        enabled
+      end
+    end
+  end
+end

data/lib/mosaic/lyris/upload.rb

@@ -0,0 +1,89 @@
+module Mosaic
+  module Lyris
+    class Upload < Object
+      attr_reader :bytes_processed,
+                  :completed_at,
+                  :estimated_complete_at,
+                  :list_id,
+                  :size,
+                  :status,
+                  :time_elapsed,
+                  :time_remaining
+
+      def done?
+        status == 'done'
+      end
+
+      def fatal?
+        status == 'fatal'
+      end
+
+      def active?
+        status =~ /^[0-9]+%$/
+      end
+
+      def incomplete?
+        pending? || active?
+      end
+
+      def pending?
+        status == 'pending'
+      end
+
+      def retry?
+        status == 'retry'
+      end
+
+      class << self
+        def add(email, file, options = {})
+          validate_options!(options)
+          reply = post('record', 'upload') do |request|
+            request.MLID options[:list_id] || ''
+            put_data(request, 'email', email)
+            put_extra_data(request, 'file', file)
+            put_extra_data(request, 'type', options[:type] || 'active')
+            put_extra_data(request, 'trigger', 'yes') if options[:trigger]
+            if options[:update]
+              put_extra_data(request, 'update', options[:update].to_s == 'only' ? 'only' : 'on')
+              put_extra_data(request, 'delete_blank', 'on') if options[:blank]
+              put_extra_data(request, 'untrash', 'on') if options[:untrash]
+            end
+            put_extra_data(request, 'validate', 'on') if options[:validate]
+          end
+          new(options.merge(:id => reply.at('/DATASET/DATA').inner_html, :email => options[:email], :file => file, :type => options[:type] || 'active'))
+        end
+
+        def build(record, options = {})
+          new :list_id => options[:list_id],
+              :file => get_element(record, 'FILE'),
+              :status => get_element(record, 'STATUS'),
+              :size => get_integer_element(record, 'SIZE'),
+              :bytes_processed => get_integer_element(record, 'PROCESSED'),
+              :time_elapsed => get_integer_element(record, 'ELAPSED'),
+              :time_remaining => get_integer_element(record, 'TIMELEFT'),
+              :estimated_complete_at => get_time_element(record, 'ETC'),
+              :completed_at => get_time_element(record, 'TIME')
+        end
+
+        def query(what, options = {})
+          reply = post('record', 'upload-status') do |request|
+            request.MLID options[:list_id] || ''
+            put_extra_data(request, 'file', what) unless what.to_s == 'all'
+          end
+          if what.to_s == 'all'
+            reply.search('/DATASET/*').collect do |record|
+              build record, options
+            end
+          else
+            build reply.at('/DATASET/DATASET_1'), options
+          end
+        end
+
+        def validate_options!(options)
+          raise ArgumentError, "expected type of :active, :proof, :unsubscribed, :bounced, :trashed or :globalunsubscribe; got #{options[:type]}" unless %w(active proof unsubscribed bounced trashed globalunsubscribe).include?(options[:type].to_s) if options[:type]
+          raise ArgumentError, "expected update value of true or :only; for #{options[:update]}" unless %w(true only).include?(options[:update].to_s) if options[:update]
+        end
+      end
+    end
+  end
+end

data/lib/mosaic/lyris_mailer.rb

@@ -0,0 +1,102 @@
+module Mosaic
+  module LyrisMailer
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::TextHelper
+    include ActionView::Helpers::SanitizeHelper
+
+  private
+    if ActionMailer::Base.respond_to?(:add_delivery_method)
+      def friendly_from_for(mail)
+        mail[:from].display_names.first
+      end
+
+      def from_for(mail)
+        mail[:from].addresses.first
+      end
+    else
+      def friendly_from_for(mail)
+        mail.friendly_from
+      end
+
+      def from_for(mail)
+        mail.from
+      end
+    end
+
+    def get_lyris_html(mail)
+      if mail.multipart?
+        get_part_body(mail, 'text/html') || simple_format(get_part_body(mail, 'text/plain'))
+      elsif mail.content_type.start_with? 'text/html'
+        get_part_body(mail, 'text/html')
+      elsif mail.content_type.start_with? 'text/plain'
+        simple_format(mail.body.to_s)
+      else
+        raise TypeError, "unable to retrieve text/html for content type (#{mail.content_type})"
+      end
+    end
+
+    # TODO: handle encoding?
+    def get_lyris_options(mail)
+      lyris_options = {}
+      lyris_options[:subject] = mail.subject
+      lyris_options[:from_email] = from_for(mail)
+      lyris_options[:from_name] = friendly_from_for(mail)
+      lyris_options[:clickthru] = true
+      lyris_options[:message] = get_lyris_html(mail)
+      lyris_options[:message_text] = get_lyris_text(mail)
+      lyris_options
+    end
+
+    def get_lyris_text(mail)
+      if mail.multipart?
+        get_part_body(mail, 'text/plain') || ActionController::Base.helpers.strip_tags(get_part_body(mail, 'text/html'))
+      elsif mail.content_type.start_with? 'text/plain'
+        mail.body.to_s
+      elsif mail.content_type.start_with? 'text/html'
+        ActionController::Base.helpers.strip_tags(get_part_body(mail, 'text/html'))
+      else
+        raise TypeError, "unable to retrieve text/plain for content type (#{mail.content_type})"
+      end
+    end
+
+    def get_part(mail, content_type)
+      return mail if mail.parts.length == 0
+      mail.parts.find { |part| part.content_type.start_with? content_type }
+    end
+
+    def get_part_body(mail, content_type)
+      part = get_part(mail, content_type)
+      part.body.to_s if part
+    end
+
+    def perform_delivery_lyris(mail)
+      args = []
+      args << Mosaic::Lyris::Object.default_trigger_id
+      args += mail.destinations
+      args << get_lyris_options(mail)
+      trigger = Mosaic::Lyris::Trigger.fire(*args)
+      # TODO: deal with sent vs not sent
+      # raise "triggered email not sent" unless trigger.sent.include?(email)
+    end
+  end
+end
+
+if ActionMailer::Base.respond_to?(:add_delivery_method)
+  module Mosaic
+    class LyrisDeliveryMethod
+      include LyrisMailer
+
+      def initialize(values = {})
+      end
+
+      def deliver!(mail)
+        perform_delivery_lyris(mail)
+      end
+    end
+  end
+
+  ActionMailer::Base::add_delivery_method :lyris, Mosaic::LyrisDeliveryMethod
+else
+  ActionMailer::Base.send :include, Mosaic::LyrisMailer
+  ActionMailer::Base.send :extend, ActionView::Helpers::SanitizeHelper::ClassMethods
+end

data/mosaic-lyris.gemspec

@@ -0,0 +1,143 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mosaic-lyris}
+  s.version = "1.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["S. Brent Faulkner"]
+  s.date = %q{2013-03-07}
+  s.description = %q{A wrapper for the Lyris/EmailLabs API to simplify integration}
+  s.email = %q{brent.faulkner@mosaic.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "Gemfile",
+    "README",
+    "Rakefile",
+    "VERSION",
+    "init.rb",
+    "lib/lyris.rb",
+    "lib/mosaic/lyris.rb",
+    "lib/mosaic/lyris/demographic.rb",
+    "lib/mosaic/lyris/filter.rb",
+    "lib/mosaic/lyris/list.rb",
+    "lib/mosaic/lyris/message.rb",
+    "lib/mosaic/lyris/object.rb",
+    "lib/mosaic/lyris/partner.rb",
+    "lib/mosaic/lyris/record.rb",
+    "lib/mosaic/lyris/trigger.rb",
+    "lib/mosaic/lyris/upload.rb",
+    "lib/mosaic/lyris_mailer.rb",
+    "mosaic-lyris.gemspec",
+    "test/demographic_test.rb",
+    "test/filter_test.rb",
+    "test/http_responder.rb",
+    "test/list_test.rb",
+    "test/message_test.rb",
+    "test/partner_test.rb",
+    "test/record_test.rb",
+    "test/responses/demographic/add_error_name_already_exists.xml",
+    "test/responses/demographic/add_success_12345.xml",
+    "test/responses/demographic/query_all_success.xml",
+    "test/responses/demographic/query_enabled_details_success.xml",
+    "test/responses/demographic/query_enabled_success.xml",
+    "test/responses/list/add_error_name_already_exists.xml",
+    "test/responses/list/add_success_12345.xml",
+    "test/responses/list/delete_error_not_found_99999.xml",
+    "test/responses/list/delete_success_12345.xml",
+    "test/responses/list/query_list_data_success.xml",
+    "test/responses/record/add_error_email_already_exists.xml",
+    "test/responses/record/add_success.xml",
+    "test/responses/record/query_all_success.xml",
+    "test/responses/record/query_all_success_empty.xml",
+    "test/responses/record/query_all_success_page_1.xml",
+    "test/responses/record/query_all_success_page_2.xml",
+    "test/responses/record/query_all_success_page_3.xml",
+    "test/responses/record/query_email_error_not_found.xml",
+    "test/responses/record/query_email_success_active.xml",
+    "test/responses/record/query_email_success_admin_trashed.xml",
+    "test/responses/record/query_email_success_bounced.xml",
+    "test/responses/record/query_email_success_unsubscribed.xml",
+    "test/responses/record/update_error_not_found.xml",
+    "test/responses/record/update_success.xml",
+    "test/responses/triggers/fire_error_invalid_recipients.xml",
+    "test/responses/triggers/fire_error_invalid_trigger_id.xml",
+    "test/responses/triggers/fire_success.xml",
+    "test/test_helper.rb",
+    "test/trigger_test.rb"
+  ]
+  s.homepage = %q{http://github.com/mosaicxm/mosaic-lyris}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Lyris/EmailLabs API}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<mosaic-lyris>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_runtime_dependency(%q<builder>, [">= 0"])
+      s.add_runtime_dependency(%q<active_support>, [">= 0"])
+      s.add_runtime_dependency(%q<htmlentities>, [">= 0"])
+      s.add_runtime_dependency(%q<nokogiri>, [">= 0"])
+      s.add_runtime_dependency(%q<tzinfo>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+    else
+      s.add_dependency(%q<mosaic-lyris>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<builder>, [">= 0"])
+      s.add_dependency(%q<active_support>, [">= 0"])
+      s.add_dependency(%q<htmlentities>, [">= 0"])
+      s.add_dependency(%q<nokogiri>, [">= 0"])
+      s.add_dependency(%q<tzinfo>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<mosaic-lyris>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<builder>, [">= 0"])
+    s.add_dependency(%q<active_support>, [">= 0"])
+    s.add_dependency(%q<htmlentities>, [">= 0"])
+    s.add_dependency(%q<nokogiri>, [">= 0"])
+    s.add_dependency(%q<tzinfo>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+  end
+end
+