bronto 0.0.1

data/lib/bronto/delivery.rb

@@ -0,0 +1,49 @@
+module Bronto
+  class Delivery < Base
+    attr_accessor :start, :message_id, :status, :type, :from_email, :from_name, :reply_email, :content, :recipients,
+        :fields, :authentication, :reply_tracking
+
+    # Finds contacts based on the `filter` (Bronto::Filter object).
+    # * `page_number` is the page of contacts to request. Bronto doesn't specify how many contacts are returned per page,
+    #    only that you should keep increasing the number until no more contacts are returned.
+    # * `fields` can be an array of field IDs or an array of Field objects.
+    # * `include_lists` determines whether to include the list IDs each contact belongs to.
+    def self.find(filter = Bronto::Filter.new, page_number = 1, include_recipients = false, include_content = false)
+      body = { filter: filter.to_hash, page_number: page_number, include_recipients: include_recipients,
+          include_content: include_content }
+
+      resp = request(:read) do
+        soap.body = body
+      end
+
+      Array.wrap(resp[:return]).map { |hash| new(hash) }
+    end
+
+    def initialize(options = {})
+      super(options)
+      self.recipients = []
+    end
+
+    def to_hash
+      hash = {
+        id: id, start: start, message_id: message_id, type: type, from_email: from_email, from_name: from_name,
+        reply_email: reply_email, recipients: recipients, fields: fields, authentication: authentication,
+        reply_tracking: reply_tracking
+      }
+      hash.each { |k,v| hash.delete(k) if v.blank? }
+      hash
+    end
+
+    def add_recipient(*args)
+      type = id = nil
+
+      type, id = if args.is_a? Array and args.length == 2
+        args
+      else
+        [args.first.class.to_s.split("::").last.downcase, args.first.id]
+      end
+
+      self.recipients << { type: type, id: id }
+    end
+  end
+end

data/lib/bronto/field.rb

@@ -0,0 +1,11 @@
+module Bronto
+  class Field < Base
+    attr_accessor :id, :name, :label, :type, :visibility
+
+    def to_hash
+      hash = { name: name, label: label, type: type, visibility: visibility }
+      hash[:id] = id if id.present?
+      hash
+    end
+  end
+end

data/lib/bronto/filter.rb

@@ -0,0 +1,36 @@
+# Represents a filter (which is actually a set of filters).
+# For more information, see the [Bronto documentation](http://community.bronto.com/api/v4/filters).
+
+module Bronto
+  class Filter
+    attr_accessor :type, :fields
+
+    def initialize
+      self.fields = {}
+    end
+
+    def to_hash
+      hash = { type: type || "AND" }
+      hash.merge(fields)
+    end
+
+    # Accepts two or three arguments:
+    #  1. Field name
+    #  2. (optional) The operator to use (only available for certain fields; see the filter documentation).
+    #  3. Value
+    def add_filter(*args)
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 2..3)" if args.length != 2 and args.length != 3
+
+      field = args.shift.to_sym
+      self.fields[field] = [] unless self.fields.has_key?(field)
+
+      if args.length == 1
+        self.fields[field] << args.first
+      else
+        self.fields[field] << { operator: args.first, value: args.last }
+      end
+
+      self
+    end
+  end
+end

data/lib/bronto/list.rb

@@ -0,0 +1,62 @@
+module Bronto
+  class List < Base
+    attr_accessor :name, :label, :active_count, :status, :visibility
+
+    # Removes all contacts from the given lists.
+    def self.clear_lists(*lists)
+      resp = request(:clear) do
+        soap.body = {
+          list: lists.map { |l| { id: l.id } }
+        }
+      end
+
+      Array.wrap(resp[:return][:results]).select { |r| r[:is_error] }.count == 0
+    end
+
+    def initialize(options = {})
+      super(options)
+      self.active_count ||= 0
+    end
+
+    # Adds the given contacts to this list.
+    def add_to_list(*contacts)
+      return false if !self.id.present?
+
+      # The block below is evaluated in a weird scope so we need to capture self as _self for use inside the block.
+      _self = self
+
+      resp = request("add_to_list") do
+        soap.body = {
+          list: { id: _self.id },
+          contacts: contacts.map { |c| { id: c.id } }
+        }
+      end
+
+      Array.wrap(resp[:return][:results]).select { |r| r[:is_error] }.count == 0
+    end
+
+    # Removes the given contacts from this list.
+    def remove_from_list(*contacts)
+      return false if !self.id.present?
+
+      resp = request("remove_from_list") do
+        soap.body = {
+          list: self.to_hash,
+          contacts: contacts.map(&:to_hash)
+        }
+      end
+
+      Array.wrap(resp[:return][:results]).select { |r| r[:is_error] }.count == 0
+    end
+
+    def active_count=(new_val)
+      @active_count = new_val.to_i
+    end
+
+    def to_hash
+      hash = { name: name, label: label, status: status, visibility: visibility }
+      hash[:id] = id if id.present?
+      hash
+    end
+  end
+end

data/lib/bronto/message.rb

@@ -0,0 +1,36 @@
+module Bronto
+  class Message < Base
+    attr_accessor :name, :status, :message_folder_id, :content
+
+    def initialize(options = {})
+      super(options)
+      self.content = { }
+    end
+
+    def to_hash
+      hash = { id: id, name: name, status: status, message_folder_id: message_folder_id, content: content.values.map(&:to_hash) }
+      [ :status, :id, :message_folder_id ].each do |f|
+        hash.delete(f) if send(f).blank?
+      end
+      hash
+    end
+
+    def add_content(type, subject, content)
+      self.content[type] = Content.new(type, subject, content)
+    end
+
+    class Content
+      attr_accessor :type, :subject, :content
+
+      def initialize(type, subject, content)
+        self.type = type
+        self.subject = subject
+        self.content = content
+      end
+
+      def to_hash
+        { type: type, subject: subject, content: content }
+      end
+    end
+  end
+end

data/lib/bronto/version.rb

@@ -0,0 +1,3 @@
+module Bronto
+  VERSION = "0.0.1"
+end

data/lib/core_ext/array.rb

@@ -0,0 +1,14 @@
+class Array
+  unless self.respond_to? :wrap
+    # From: activesupport/lib/active_support/core_ext/array/wrap.rb, line 39
+    def self.wrap(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      else
+        [object]
+      end
+    end
+  end
+end

data/lib/core_ext/object.rb

@@ -0,0 +1,34 @@
+class Object
+  # From: activesupport/lib/active_support/core_ext/object/blank.rb, line 14
+
+  unless self.new.respond_to? :blank?
+    def blank?
+      respond_to?(:empty?) ? empty? : !self
+    end
+  end
+
+  unless self.new.respond_to? :present?
+    # From: activesupport/lib/active_support/core_ext/object/blank.rb, line 19
+    def present?
+      !blank?
+    end
+  end
+
+  unless self.new.respond_to? :try
+    # From: activesupport/lib/active_support/core_ext/object/try.rb, line 28
+    def try(*a, &b)
+      if a.empty? && block_given?
+        yield self
+      else
+        __send__(*a, &b)
+      end
+    end
+  end
+end
+
+class NilClass
+  # From: activesupport/lib/active_support/core_ext/object/try.rb, line 50
+  def try(*args)
+    nil
+  end
+end

data/lib/core_ext/string.rb

@@ -0,0 +1,8 @@
+class String
+  unless self.new.respond_to? :pluralize
+    # A very simple `pluralize` method that works for every object in the Bronto API.
+    def pluralize
+      self[-1] == "y" ? self[0...-1] + "ies" : self + "s"
+    end
+  end
+end

data/test/contact_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+class ContactTest < Test::Unit::TestCase
+  context "" do
+    setup do
+      @contact = Bronto::Contact.new(email: "#{Time.now.to_i}-#{rand(1000)}@example.com", status: "active")
+    end
+
+    teardown do
+      reset_all
+    end
+
+    should "create a new contact" do
+      assert_equal nil, @contact.id
+
+      @contact.save
+
+      assert_not_nil @contact.id
+      assert_equal 0, @contact.errors.count
+    end
+
+    should "get error on duplicate contact" do
+      @contact.save
+
+      c2 = Bronto::Contact.new(email: @contact.email)
+      c2.save
+
+      assert_equal nil, c2.id
+      assert_equal 1, c2.errors.count
+      assert_equal "305", c2.errors.messages.keys.first
+    end
+
+    should "destroy a contact" do
+      @contact.save
+
+      assert_nothing_raised do
+        @contact.destroy
+      end
+    end
+
+    should "find all contacts" do
+      @contact.save
+
+      contacts = Bronto::Contact.find
+
+      assert_equal 1, contacts.count
+      assert_equal @contact.id, contacts.first.id
+
+      c2 = Bronto::Contact.new(email: "#{Time.now.to_i}-#{rand(1000)}@example.com")
+      c2.save
+
+      assert_not_nil c2.id
+
+      contacts = Bronto::Contact.find
+
+      assert_equal 2, contacts.count
+    end
+
+    should "find a specific contact" do
+      @contact.save
+
+      filter = Bronto::Filter.new
+      filter.add_filter("email", "EndsWith", "example.com")
+
+      contacts = Bronto::Contact.find(filter)
+
+      assert_equal 1, contacts.count
+      assert_equal @contact.id, contacts.first.id
+
+      filter = Bronto::Filter.new
+      filter.add_filter("id", @contact.id)
+
+      contacts = Bronto::Contact.find(filter)
+
+      assert_equal 1, contacts.count
+      assert_equal @contact.id, contacts.first.id
+    end
+
+    should "include fields in results" do
+      f = Bronto::Field.new(name: "test_field", label: "Test Field", type: "text", visibility: "private")
+      f.save
+
+      @contact.set_field(f, "test value")
+      @contact.save
+
+      contacts = Bronto::Contact.find(Bronto::Filter.new, 1, [f.id], true)
+      assert_equal @contact.id, contacts.first.id
+      assert_equal "test value", contacts.first.get_field(f)
+    end
+  end
+end

data/test/delivery_test.rb

@@ -0,0 +1,98 @@
+require 'test_helper'
+
+class DeliveryTest < Test::Unit::TestCase
+  context "" do
+    setup do
+      @message = Bronto::Message.new(name: "Test Message")
+      @message.add_content("html", "HTML Subject", "HTML Content")
+      @message.add_content("text", "Text Subject", "Text Content")
+      @message.save
+
+      @contact = Bronto::Contact.new(email: "#{Time.now.to_i}-#{rand(1000)}@example.com", status: "active")
+      @contact.save
+
+      @delivery = Bronto::Delivery.new(start: Time.now, type: "normal", from_name: "Hello", from_email: "test@example.com")
+      @delivery_2 = Bronto::Delivery.new(start: Time.now + (60 * 60 * 24 * 5), type: "normal", from_name: "Hello",
+          from_email: "test2@example.com")
+    end
+
+    teardown do
+      reset_all
+    end
+
+    should "create a new delivery" do
+      assert_equal nil, @delivery.id
+
+      @delivery.add_recipient(@contact)
+      @delivery.save
+      assert_equal "205", @delivery.errors.messages.keys.first
+
+      @delivery.message_id = @message.id
+      @delivery.save
+
+      assert_not_nil @delivery.id
+      assert_equal 0, @delivery.errors.count
+    end
+
+    should "destroy a delivery" do
+      skip "API says we should be able to delete a delivery, but well-formed message returns an error."
+      @delivery.message_id = @message.id
+      @delivery.save
+
+      assert_nothing_raised do
+        @delivery.destroy
+      end
+    end
+
+    should "find all deliveries" do
+      orig_delivery_count = Bronto::Delivery.find.count
+
+      @delivery.add_recipient(@contact)
+      @delivery.message_id = @message.id
+      @delivery.save
+      assert_not_nil @delivery.id
+
+      sleep(2)
+
+      deliveries = Bronto::Delivery.find
+      assert_equal orig_delivery_count + 1, deliveries.count
+      assert deliveries.any? { |d| d.id == @delivery.id }
+
+      @delivery_2.add_recipient(@contact)
+      @delivery_2.message_id = @message.id
+      @delivery_2.save
+      assert_not_nil @delivery_2.id
+
+      sleep(2)
+
+      deliveries = Bronto::Delivery.find
+      assert_equal orig_delivery_count + 2, deliveries.count
+    end
+
+    should "find a specific delivery" do
+      @delivery.add_recipient(@contact)
+      @delivery.message_id = @message.id
+      @delivery.save
+
+      @delivery_2.add_recipient(@contact)
+      @delivery_2.message_id = @message.id
+      @delivery_2.save
+
+      filter = Bronto::Filter.new
+      filter.add_filter("message_id", @message.id)
+
+      sleep(2)
+
+      deliveries = Bronto::Delivery.find(filter)
+      assert_equal 2, deliveries.count
+
+      filter = Bronto::Filter.new
+      filter.add_filter("id", @delivery.id)
+
+      deliveries = Bronto::Delivery.find(filter)
+
+      assert_equal 1, deliveries.count
+      assert deliveries.any? { |d| d.id == @delivery.id }
+    end
+  end
+end