constant_contact 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,56 @@
+ConstantContact
+===============
+This is a very ActiveResource-like ruby wrapper to the Constant Contact API.  It's not quite done yet and if you are interested in using this code, check it out, and message me with questions. 
+
+See the [ActiveResource::Base docs](http://api.rubyonrails.org/classes/ActiveResource/Base.html) for more information on how to use this ActiveResource-based wrapper.
+
+Examples
+--------
+
+All examples require setting up either the specific class you'll be use or the Base object before use:
+
+    ConstantContact::Base.user = 'user'
+    ConstantContact::Base.api_key = 'api-key'
+    ConstantContact::Base.password = 'password'
+
+
+### Find Lists
+
+    ConstantContact::List.find(1)
+    ConstantContact::List.find :all
+
+### Find A Contact
+
+
+    ConstantContact::Contact.find(1)
+    ConstantContact::Contact.find(:first, :params => {:email => 'jon@example.com'})
+    ConstantContact::Contact.find_by_email('jon@example.com') # => same as previous line
+
+### Create a Contact (with rescue if it already exists)
+
+    ConstantContact::Base.user = 'user'
+    ConstantContact::Base.api_key = 'api-key'
+    ConstantContact::Base.password = 'password'
+
+    # Contact not found. Create it.
+    begin
+      @contact = ConstantContact::Contact.new(
+        :email_address => "jon@example.com",
+        :first_name => "jon",
+        :last_name => "smith"
+      )
+      @contact.save
+    rescue ActiveResource::ResourceConflict => e
+      # contact already exists
+      puts 'Contact already exists. Saving contact failed.'
+      puts e
+    end
+
+### Find a Contact By Email Address, Check if They're a Member of the Default List
+
+    c = ConstantContact::Contact.find_by_email('jon@example.com')
+    @contact = ConstantContact::Contact.find(@contact.int_id)
+    puts 'In default contact list.' if @contact.contact_lists.include?(1) # contact_lists is an array of list ids
+
+
+Copyright (c) 2009 Timothy Case, released under the MIT license

data/lib/constant_contact.rb

@@ -0,0 +1,13 @@
+directory = File.expand_path(File.dirname(__FILE__))
+
+require 'active_resource'
+require 'action_pack'
+require File.join(directory, 'constant_contact', 'formats')
+require File.join(directory, 'constant_contact', 'base')
+require File.join(directory, 'constant_contact', 'list');
+require File.join(directory, 'constant_contact', 'member')
+require File.join(directory, 'constant_contact', 'contact')
+require File.join(directory, 'constant_contact', 'campaign')
+require File.join(directory, 'constant_contact', 'contact_event')
+require File.join(directory, 'constant_contact', 'activity')
+require File.join(directory, 'constant_contact', 'email_address')

data/lib/constant_contact/activity.rb

@@ -0,0 +1,41 @@
+
+module ConstantContact
+  class Activity < Base
+    self.format = ActiveResource::Formats::HtmlEncodedFormat
+    attr_accessor :contacts, :lists, :activity_type
+    
+    def encode
+      post_data = "activityType=#{self.activity_type}"
+      post_data += self.encoded_data
+      post_data += self.encoded_lists
+      return post_data
+    end
+
+    def activity_type
+      @activity_type ||= "SV_ADD"
+    end
+    
+    protected
+    def encoded_data
+      result = "&data="
+      result += CGI.escape("Email Address,First Name,Last Name\n")
+      contact_strings = []
+      self.contacts.each do |contact|
+        contact_strings << "#{contact.email_address}, #{contact.first_name}, #{contact.last_name}"        
+      end      
+      result += CGI.escape(contact_strings.join("\n"))        
+      return result
+    end
+    
+    
+    def encoded_lists
+      result = ""
+      self.lists.each do |list|
+        result += "&lists="
+        result += CGI.escape(list.id)
+      end
+      return result
+    end
+    
+  end
+end

data/lib/constant_contact/base.rb

@@ -0,0 +1,150 @@
+module ConstantContact
+  class Base < ActiveResource::Base
+    
+    self.site = "https://api.constantcontact.com"
+    self.format = :atom
+
+    DATE_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
+
+    class << self
+      # Returns an integer which can be used in #find calls.
+      # Assumes url structure with the id at the end, e.g.:
+      #   http://api.constantcontact.com/ws/customers/yourname/contacts/29
+      def parse_id(url)
+        url.to_s.split(/\//).last.to_i
+      end
+    
+      def api_key
+        if defined?(@api_key)
+          @api_key
+        elsif superclass != Object && superclass.api_key
+          superclass.api_key.dup.freeze
+        end
+      end
+
+      def api_key=(api_key)
+        @connection = nil
+        @api_key = api_key
+      end
+      
+      def connection(refresh = false)
+        if defined?(@connection) || superclass == Object
+          @connection = ActiveResource::Connection.new(site, format) if refresh || @connection.nil?
+          @connection.user = "#{api_key}%#{user}" if user
+          @connection.password = password if password
+          @connection.timeout = timeout if timeout
+          @connection
+        else
+          superclass.connection
+        end
+      end
+      
+      def collection_path(prefix_options = {}, query_options = nil)
+        prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+        "/ws/customers/#{self.user}#{prefix(prefix_options)}#{collection_name}#{query_string(query_options)}"
+      end  
+      
+      def element_path(id, prefix_options = {}, query_options = nil)
+        prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+        integer_id = parse_id(id)
+        id_val = integer_id.zero? ? nil : "/#{integer_id}"
+        "#{collection_path}#{id_val}#{query_string(query_options)}"
+      end
+      
+      # Slight modification to AR::Base.find_every to handle instances
+      # where a single element is returned. This enables calling
+      # <tt>find(:first, {:params => {:email => 'sample@example.com'}})
+      def find_every(options)
+        case from = options[:from]
+        when Symbol
+          instantiate_collection(get(from, options[:params]))
+        when String
+          path = "#{from}#{query_string(options[:params])}"
+          instantiate_collection(connection.get(path, headers) || [])
+        else
+          prefix_options, query_options = split_options(options[:params])
+          path = collection_path(prefix_options, query_options)
+          result = connection.get(path, headers)
+          case result.class.name
+          when 'Hash': instantiate_collection( [ result ], prefix_options )
+          else
+            instantiate_collection( (result || []), prefix_options )
+          end
+        end
+      end
+    end
+    
+    # Slightly tweaked ARes::Base's implementation so all the
+    # attribute names are looked up using camelcase since
+    # that's how the CC API returns them.
+    def method_missing(method_symbol, *arguments) #:nodoc:
+      method_name = method_symbol.to_s
+
+      case method_name.last
+        when "="
+          attributes[method_name.first(-1).camelize] = arguments.first
+        when "?"
+          attributes[method_name.first(-1).camelize]
+        else
+          attributes.has_key?(method_name.camelize) ? attributes[method_name.camelize] : super
+      end
+    end        
+
+    # Caching accessor for the the id integer
+    def int_id
+      @id ||= self.class.parse_id(self.attributes['id'])
+    end
+    
+    # Mimics ActiveRecord's version
+    def update_attributes(atts={})
+      camelcased_hash = {}
+      atts.each{|key, val| camelcased_hash[key.to_s.camelize] = val}
+      self.attributes.update(camelcased_hash)
+      save
+    end
+    
+    # Mimic ActiveRecord (snagged from HyperactiveResource).
+    def save
+      return false unless valid?
+      before_save    
+      successful = super
+      after_save if successful
+      successful
+    end 
+    
+    def before_save
+    end
+    
+    def after_save
+    end
+    
+    def validate      
+    end
+
+    # So client-side validations run
+    def valid? 
+      errors.clear
+      validate 
+      super 
+    end
+    
+    def encode
+      "<entry xmlns=\"http://www.w3.org/2005/Atom\">
+        <title type=\"text\"> </title>
+        <updated>#{Time.now.strftime(DATE_FORMAT)}</updated>
+        <author>Bluesteel</author>
+        <id>#{id.blank? ? 'data:,none' : id}</id>
+        <summary type=\"text\">Bluesteel</summary>
+        <content type=\"application/vnd.ctct+xml\">
+        #{self.to_xml}
+        </content>
+      </entry>"      
+    end
+    
+    # TODO: Move this out to a lib
+    def html_encode(txt)
+      mapping = { '&' => '&amp;', '>' => '&gt;', '<' => '&lt;', '"' => '&quot;' }
+      txt.to_s.gsub(/[&"><]/) { |special| mapping[special] }
+    end
+  end
+end

data/lib/constant_contact/campaign.rb

@@ -0,0 +1,112 @@
+# http://developer.constantcontact.com/doc/manageCampaigns
+module ConstantContact
+  class Campaign < Base
+    STATUS_CODES = ['SENT', 'SCHEDULED', 'DRAFT', 'RUNNING']
+    # SENT  All campaigns that have been sent and not currently scheduled for resend
+    # SCHEDULED   All campaigns that are currently scheduled to be sent some time in the future
+    # DRAFT   All campaigns that have not yet been scheduled for delivery
+    # RUNNING   All campaigns that are currently being processed and delivered
+    @@column_names = [:archive_status, :archive_url, :bounces, :campaign_type, :clicks, :contact_lists, :date, 
+                      :email_content, :email_content_format, :email_text_content, :forward_email_link_text, :forwards, 
+                      :from_email, :from_name, :greeting_name, :greeting_salutation, :greeting_string, 
+                      :include_forward_email, :include_subscribe_link, :last_edit_date, :name, :opens, :opt_outs, 
+                      :organization_address1, :organization_address2, :organization_address3, :organization_city, 
+                      :organization_country, :organization_international_state, :organization_name, :organization_postal_code, 
+                      :organization_state, :permission_reminder, :reply_to_email, :sent, :spam_reports, :status, 
+                      :style_sheet, :subject, :subscribe_link_text, :view_as_webpage, :view_as_webpage_link_text, :view_as_webpage_text] 
+    
+
+    # Setup defaults when creating a new object since
+    # CC requires so many extraneous fields to be present
+    # when creating a new Campaign.
+    def initialize
+      obj = super
+      obj.set_defaults
+      obj
+    end
+        
+    def to_xml
+      xml = Builder::XmlMarkup.new
+      xml.tag!("Campaign", :xmlns => "http://ws.constantcontact.com/ns/1.0/") do
+      	self.attributes.each{ |k, v| xml.tag!(k.to_s.camelize, v) }
+        # Overrides the default formatting above to CC's required format.
+      	xml.tag!("ReplyToEmail") do
+      	  xml.tag!('Email', :id => self.reply_to_email_url)
+    	  end
+      	xml.tag!("FromEmail") do
+      	  xml.tag!('Email', :id => self.from_email_url)
+    	  end
+      	xml.tag!("ContactLists") do 
+      	  xml.tag!("ContactList", :id => self.list_url)
+      	end
+      end        
+    end
+    
+    def list_url
+      id = defined?(self.list_id) ? self.list_id : 1
+      List.find(id).id
+    end
+
+    def from_email_url
+      id = defined?(self.from_email_id) ? self.from_email_id : 1
+      EmailAddress.find(id).id
+    end
+
+    def reply_to_email_url
+      from_email_url
+    end
+    
+    
+    protected
+    def set_defaults
+      self.view_as_webpage                  = 'NO' unless attributes.has_key?('ViewAsWebpage')
+      self.from_name                        = self.class.user unless attributes.has_key?('FromName')
+      self.permission_reminder              = 'YES' unless attributes.has_key?('PermissionReminder')
+      self.permission_reminder_text         = %Q{You're receiving this email because of your relationship with us. Please <ConfirmOptin><a style="color:#0000ff;">confirm</a></ConfirmOptin> your continued interest in receiving email from us.} unless attributes.has_key?('PermissionReminderText')
+      self.greeting_salutation              = 'Dear' unless attributes.has_key?('GreetingSalutation')
+      self.greeting_name                    = "FirstName"  unless attributes.has_key?('GreetingName')
+      self.greeting_string                  = 'Greetings!' unless attributes.has_key?('GreetingString')
+      self.status                           = 'DRAFT' unless attributes.has_key?('Status')
+      self.style_sheet                      = '' unless attributes.has_key?('StyleSheet')
+      self.include_forward_email            = 'NO' unless attributes.has_key?('IncludeForwardEmail')
+      self.forward_email_link_text          = '' unless attributes.has_key?('ForwardEmailLinkText')
+      self.subscribe_link_text              = '' unless attributes.has_key?('SubscribeLinkText')
+      self.include_subscribe_link           = 'NO' unless attributes.has_key?('IncludeSubscribeLink')
+      self.organization_name                = self.class.user unless attributes.has_key?('OrganizationName')
+      self.organization_address1            = '123 Main' unless attributes.has_key?('OrganizationAddress1')
+      self.organization_address2            = '' unless attributes.has_key?('OrganizationAddress2')
+      self.organization_address3            = '' unless attributes.has_key?('OrganizationAddress3')
+      self.organization_city                = 'Kansas City' unless attributes.has_key?('OrganizationCity')
+      self.organization_state               = 'KS' unless attributes.has_key?('OrganizationState')
+      self.organization_international_state = '' unless attributes.has_key?('OrganizationInternationalState')
+      self.organization_country             = 'US' unless attributes.has_key?('OrganizationCountry')
+      self.organization_postal_code         = '64108' unless attributes.has_key?('OrganizationPostalCode')
+    end
+    
+    # Formats data if present.
+    def before_save
+      self.email_text_content = "<Text>#{email_text_content}</Text>" unless email_text_content.match /^\<Text/
+      self.date               = self.date.strftime(DATE_FORMAT) if attributes.has_key?('Date')      
+    end
+    
+    
+    def validate
+      # NOTE: Needs to be uppercase!
+      unless attributes.has_key?('EmailContentFormat') && ['HTML', 'XHTML'].include?(email_content_format)
+        errors.add(:email_content_format, 'must be either HTML or XHTML (the latter for advanced email features)') 
+      end
+      
+      if attributes.has_key?('ViewAsWebpage') && view_as_webpage.downcase == 'yes'
+        unless attributes['ViewAsWebpageLinkText'].present? && attributes['ViewAsWebpageText'].present?
+          errors.add(:view_as_webpage, "You need to set view_as_webpage_link_text and view_as_webpage_link if view_as_webpage is YES")
+        end
+      end
+
+      errors.add(:email_content, 'cannot be blank') unless attributes.has_key?('EmailContent')       
+      errors.add(:email_text_content, 'cannot be blank') unless attributes.has_key?('EmailTextContent') 
+      errors.add(:name, 'cannot be blank') unless attributes.has_key?('Name') 
+      errors.add(:subject, 'cannot be blank') unless attributes.has_key?('Subject') 
+    end
+    
+  end
+end

data/lib/constant_contact/contact.rb

@@ -0,0 +1,82 @@
+# Value limits: http://constantcontact.custhelp.com/cgi-bin/constantcontact.cfg/php/enduser/std_adp.php?p_faqid=2217
+module ConstantContact
+  class Contact < Base
+    attr_accessor :opt_in_source
+    
+    # NOTE: All column names are available only when finding a contact by id.
+    # @@column_names = [ :addr1, :addr2, :addr3, :city, :company_name, :country_code, :country_name, 
+    #                       :custom_field1, :custom_field10, :custom_field11, :custom_field12, :custom_field13, 
+    #                       :custom_field14, :custom_field15, :custom_field2, :custom_field3, :custom_field4, :custom_field5, 
+    #                       :custom_field6, :custom_field7, :custom_field8, :custom_field9, :email_address, :email_type, 
+    #                       :first_name, :home_phone, :insert_time, :job_title, :last_name, :last_update_time, :name, :note, 
+    #                       :postal_code, :state_code, :state_name, :status, :sub_postal_code, :work_phone ]
+    
+    def to_xml
+      xml = Builder::XmlMarkup.new
+      xml.tag!("Contact", :xmlns => "http://ws.constantcontact.com/ns/1.0/") do
+        self.attributes.reject {|k,v| k == 'ContactLists'}.each{|k, v| xml.tag!( k.to_s.camelize, v )}
+        xml.tag!("OptInSource", self.opt_in_source)
+        xml.tag!("ContactLists") do
+          @contact_lists = [1] if @contact_lists.nil? && self.new?
+          self.contact_lists.sort.each do |list_id|
+            xml.tag!("ContactList", :id=> self.list_url(list_id))
+          end
+        end
+      end
+    end
+    
+    def opt_in_source
+      @opt_in_source ||= "ACTION_BY_CUSTOMER"
+    end
+    
+    # see http://developer.constantcontact.com/doc/manageContacts#create_contact for more info about the two values.
+    def opt_in_source=(val)
+      @opt_in_source = val if ['ACTION_BY_CONTACT','ACTION_BY_CUSTOMER'].include?(val)
+    end
+    
+    def list_url(id=nil)
+      id ||= defined?(self.list_id) ? self.list_id : 1
+      "http://api.constantcontact.com/ws/customers/#{self.class.user}/lists/#{id}"
+    end
+    
+    # Can we email them?
+    def active?
+      status.downcase == 'active'
+    end
+    
+    def contact_lists
+      return @contact_lists if defined?(@contact_lists)
+      # otherwise, attempt to assign it
+      @contact_lists = if self.attributes.keys.include?('ContactLists')
+        if self.ContactLists
+          if self.ContactLists.ContactList.is_a?(Array)
+            self.ContactLists.ContactList.collect { |list|
+              ConstantContact::Base.parse_id(list.id)
+            }
+          else
+            [ ConstantContact::Base.parse_id(self.ContactLists.ContactList.id) ]
+          end
+        else
+          [] # => Contact is not a member of any lists (legitimatly empty!)
+        end
+      else
+        nil
+      end
+    end
+    
+    def contact_lists=(val)
+      @contact_lists = val.kind_of?(Array) ? val : [val]
+    end
+    
+    def self.find_by_email(email_address)
+      find :first, {:params => {:email => email_address.downcase}}
+    end
+    
+    protected
+    def validate
+      # errors.add(:opt_in_source, 'must be either ACTION_BY_CONTACT or ACTION_BY_CUSTOMER') unless ['ACTION_BY_CONTACT','ACTION_BY_CUSTOMER'].include?(attributes['OptInSource'])
+      # errors.add(:email_address, 'cannot be blank') unless attributes.has_key?('EmailAddress')
+    end
+    
+  end
+end