getresponse 0.1

data/README.rdoc

@@ -0,0 +1,94 @@
+== GetResponse
+
+Wrapper for GetResponse API
+
+== Usage
+
+Test connection to GetResponse API.
+
+  gr_connection = GetResponse::Connection.new("my_secret_api")
+  gr_connection.ping
+
+Get info about account
+
+  gr_connection.get_account_info
+
+Get yout active campaings. More info about operators http://dev.getresponse.com/api-doc/#operators
+
+  # get campaings with name "My campaing name"
+  gr_connection.get_campaings(:name.is_eq => "My campaing name")
+
+  # get campaings with other name than "My campaing name"
+  gr_connection.get_campaings(:name.is_not_eq => "My campaing name")
+
+  # get campaings with name like "signup" and with from_email with domain "mybiz.xx"
+  gr_connection.get_campaigns(:name.contain => "%signup%", :from_email.contain => "%mybiz.xx"
+
+Get single campaign
+
+  gr_connection.get_campaign(123456)
+  => <#GetResponse::Campaign ... >
+
+  gr_connection.get_campaign(bad_id)
+  => nil
+
+You can operate on your contacts quite the same way as on ActiveRecord objects. Before any operation
+on contacts you must connect to API.
+
+Get all contacts:
+
+  # connect to API
+  GetResponse::Connection.instance("my_secret_api_key")
+  GetResponse::Contact.find_all
+
+Create new contact:
+
+  # with connection
+  GetResponse::Contact.create("name" => "John Doe", "email" => "john.d@somewhere.com",
+    "campaign" => "campaignId", "customs" => { "source" => "mainpage" })
+
+Update your contact:
+
+  # with connection
+  # contact - existing contact
+  contact.update("name" => "John Thenewname")
+
+Delete contact:
+
+  # with connection
+  # contact - existing contact
+  contact.destroy
+
+Move contact between campaigns:
+
+  # with connection
+  # contact - existing contact
+  # zXy - existing campaign
+  contact.move("zXy")
+
+
+Get geoip location
+
+  # with connection
+  # contact - existing contact
+  contact.geoip
+
+Set contact cycle
+
+  # with connection
+  # contact - existing contact
+  contact.set_cycle(5)
+
+Get messages in account:
+
+  # get messages assigned to campaign with "N3i" ID
+  gr_connection.get_messages(:campaigns => ["N3i"])
+
+  # get messages with newsletter type
+  gr_connection.get_messages(:type => "newsletter")
+
+  # get messages from from campaigns with name like "my_biz"
+  gr_connection.get_messages(:get_campaigns => { :name.contain => "%my_biz%" })
+
+  # get one messages identifier by <tt>id</tt>
+  gr_connection.get_message("some_id")

data/lib/get_response.rb

@@ -0,0 +1,51 @@
+require "rubygems"
+require "bundler"
+Bundler.setup
+Bundler.require(:default)
+
+module GetResponse
+
+  # Operators that may be used in queries to GetResponse API service
+  OPERATORS = {
+    "is_eq"       => "EQUALS",
+    "is_not_eq"   => "NOT_EQUALS",
+    "contain"     => "CONTAINS",
+    "not_contain" => "NOT_CONTAINS",
+    "match"       => "MATCHES"
+  }
+
+end
+
+
+class SymbolOperator
+  attr_reader :field, :operator
+
+  def initialize(field, operator)
+    @field, @operator = field, operator
+  end unless method_defined?(:initialize)
+
+
+  def evaluate(value)
+    { field.to_s => { gr_operator => value } }
+  end
+
+
+  def gr_operator
+    GetResponse::OPERATORS[@operator]
+  end
+end
+
+
+class Symbol
+  GetResponse::OPERATORS.keys.each do |operator|
+    define_method(operator) do
+      SymbolOperator.new(self, operator)
+    end unless method_defined?(operator)
+  end
+end
+
+
+
+Dir.glob(File.join('**/*.rb')).each do |fname|
+  GetResponse.autoload File.basename(fname, '.rb').gsub(/(?:^|_)(.)/) { $1.upcase }, fname
+end

data/lib/get_response/account.rb

@@ -0,0 +1,15 @@
+module GetResponse
+
+  # GetResponse Account
+  class Account
+    attr_reader :login, :name, :email, :created_on
+
+
+    def initialize(params)
+      @login = params["login"]
+      @name = params["from_name"]
+      @email = params["from_email"]
+      @created_on = params["created_on"]
+    end
+  end
+end

data/lib/get_response/campaign.rb

@@ -0,0 +1,18 @@
+module GetResponse
+
+  # GetResponse email campaign
+  class Campaign
+    attr_reader :id, :name, :from_name, :from_email, :reply_to_email, :created_on
+
+
+    def initialize(params)
+      @id = params["id"]
+      @name = params["name"]
+      @from_name = params["from_name"]
+      @from_email = params["from_email"]
+      @reply_to_email = params["reply_to_email"]
+      @created_on = params["created_on"]
+    end
+  end
+
+end

data/lib/get_response/connection.rb

@@ -0,0 +1,152 @@
+require 'net/http'
+
+module GetResponse
+
+  # Simple class that simulates connection to service
+  class Connection
+    API_URI = "http://api2.getresponse.com"
+
+    attr_reader :api_key
+
+
+    private_class_method :new
+
+
+    def initialize(api_key)
+      @api_key = api_key
+    end
+
+
+    def self.instance(api_key = "")
+      @@instance ||= new(api_key)
+    end
+
+
+    # Test connection with API.
+    #
+    # returns:: Boolean
+    def ping
+      result = self.send_request("ping")
+      return result["errors"].nil?
+    end
+
+
+    # Get basic info about your account
+    #
+    # returns:: GetResponse::Account
+    def get_account_info
+      resp = self.send_request("get_account_info")
+      GetResponse::Account.new(resp["result"])
+    end
+
+
+    # Get list of active campaigns in account. There are allowed operators for building conditions.
+    # More info about operators http://dev.getresponse.com/api-doc/#operators
+    #
+    #   gr_connection.get_campaings
+    #
+    # Get list of all active campaigns with name "my_campaign" and from_email is from domain "mybiz.xx"
+    #
+    #   gr_connection.get_campaings(:name.is_eq => "my_campaign", :from_email.contain => "%mybiz.xx")
+    #
+    # get_campaings(:name.eq => "my name")
+    def get_campaigns(conditions = {})
+      req_cond = build_conditions(conditions)
+
+      response = send_request("get_campaigns", req_cond)["result"]
+      response.inject([]) do |campaings, resp|
+        campaings << Campaign.new(resp[1].merge("id" => resp[0]))
+      end
+    end
+
+
+    # Get single campaign using <tt>campaign_id</tt>.
+    #
+    # campaign_id:: Integer || String
+    #
+    # returns:: GetResponse::Campaign || nil
+    def get_campaign(campaign_id)
+      result = self.get_campaigns(:id.is_eq => campaign_id)
+      result.first
+    end
+
+
+    # TODO: untested!
+    # Get messages in account.
+    # Conditions:
+    #   * campaigns / get_campaigns (optional) – Search only in given campaigns. Uses OR logic.
+    #     If those params are not given search, is performed in all campaigns in the account.
+    #     Check IDs in conditions for detailed explanation.
+    #   * type (optional) – Use newsletter or follow-up to narrow down search results to specific
+    #     message types.
+    #   * subject (optional) – Use text operators to narrow down search results to specific message subjects.
+    #
+    # conditions::  Hash
+    #
+    # returns:: [Message]
+    def get_messages(conditions = {})
+      req_cond = build_conditions(conditions)
+
+      response = send_request("get_messages", req_cond)["result"]
+      response.inject([]) do |messages, resp|
+        messages << Message.new(resp[1].merge("id" => resp[0]))
+      end
+    end
+
+
+    # Get single message using <tt>message_id</tt>.
+    #
+    # message_id::  Integer || String
+    #
+    # returns:: Message
+    def get_message(message_id)
+      response = self.send_request("get_message", { "message" => message_id })["result"]
+      return nil if response.empty?
+      Message.new(response[message_id].merge("id" => message_id))
+    end
+
+
+    # Send request to JSON-RPC service.
+    #
+    # method::  String
+    #
+    # params::  Hash
+    def send_request(method, params = {})
+      request_params = {
+        :method => method,
+        :params => [@api_key, params]
+      }.to_json
+
+      uri = URI.parse(API_URI)
+      resp = Net::HTTP.start(uri.host, uri.port) do |conn|
+        conn.post("/", request_params)
+      end
+      response = JSON.parse(resp.body)
+      if response["error"]
+        raise GetResponse::GetResponseError.new(response["error"])
+      end
+      response
+    end
+
+
+    protected
+
+
+    def build_conditions(conditions)
+      conditions.inject({}) do |hash, cond|
+        if cond[0].respond_to?(:evaluate)
+          hash.merge!(cond[0].evaluate(cond[1]))
+        else
+          if cond[1].instance_of?(Hash)
+            hash.merge!(cond[0] => build_conditions(cond[1]))
+          else
+            hash.merge!(cond[0] => cond[1])
+          end
+        end
+        hash
+      end
+    end
+
+  end
+
+end

data/lib/get_response/contact.rb

@@ -0,0 +1,145 @@
+module GetResponse
+
+  # GetResponse contact
+  class Contact
+    attr_accessor :campaign, :name, :email, :cycle_day, :ip, :customs
+    attr_reader :id
+
+
+    def initialize(params)
+      @campaign = params["campaign"]
+      @name = params["name"]
+      @email = params["email"]
+      @cycle_day = params["cycle_day"]
+      @ip = params["ip"]
+      @customs = parse_customs(params["customs"])
+      @id = params["id"]
+    end
+
+
+    # Add contact to the list. Method raises an exception <tt>GetResponseError</tt> if contact can't
+    # be added (bad email syntax for example).
+    # Example:
+    #   GetResponse::Contact.create("email" => "john@doe.org", "name => "John D.", "campaign" => "N67")
+    #
+    # params:: Hash - attributes for new contact
+    # returns:: Boolean - true if contact queued for create
+    def self.create(params)
+      contact = Contact.new(params)
+      contact.save
+    end
+
+
+    # Find all contacts associated with GetResponse account
+    #
+    # returns:: [Contact]
+    def self.find_all
+      response = GetResponse::Connection.instance.send_request("get_contacts", {})
+
+      response["result"].inject([]) do |contacts, resp|
+        contacts << Contact.new(resp[1].merge("id" => resp[0]))
+      end
+    end
+
+
+    # Save contact object. When object can't be saved than <tt>GetResponseError</tt> is raised,
+    # otherwise returns <tt>true</tt>.
+    #
+    # returns:: Boolean
+    def save
+      connection = GetResponse::Connection.instance
+
+      result = connection.send_request(:add_contact, self.attributes)
+      result["error"].nil?
+    end
+
+
+    # Returns setted attributes as Hash.
+    #
+    # returns:: Hash
+    def attributes
+      attrs = {
+        "campaign" => @campaign,
+        "name" => @name,
+        "email" => @email
+      }
+
+      attrs["ip"] = @ip if @ip
+      attrs["cycle_day"] = @cycle_day if @cycle_day
+      attrs["customs"] = @customs if @customs
+
+      attrs
+    end
+
+
+    # Delete contact. If deleting contact was successfull method returns <tt>true</tt>. If contact
+    # object hasn't <tt>id</tt> attribute <tt>GetResponseError</tt> exception is raised. Exception
+    # is raised when try to delete already deleted contact.
+    #
+    # returns:: Boolean
+    def destroy
+      raise GetResponse::GetResponseError.new("Can't delete contact without id") unless @id
+
+      resp = GetResponse::Connection.instance.send_request("delete_contact", { "contact" => @id })
+      resp["result"]["deleted"].to_i == 1
+    end
+
+
+    # Update contact with passed attributes set. When object can't be saved than <tt>GetResponseError</tt>
+    # is raised, otherwise returns <tt>true</tt>.
+    #
+    # net_attrs:: Hash
+    def update(new_attrs)
+      new_attrs.each_pair { |key, value| self.send(key + "=", value) }
+
+      self.save
+    end
+
+
+    # Move contact from one campaign (current) to another. If move contact fails (for example: no
+    # campaign with passed id) <tt>GetResponseError</tt> exception is raised, otherwise method
+    # returns <tt>true</tt>.
+    #
+    # new_campaign_id:: String - identifier of new camapign
+    # returns:: Boolean
+    def move(new_campaign_id)
+      param = { "contact" => @id, "campaign" => new_campaign_id }
+      result = GetResponse::Connection.instance.send_request("move_contact", param)
+      result["result"]["updated"].to_i == 1
+    end
+
+
+    # Get contact geo location based on IP address from which the subscription was processed.
+    #
+    # returns:: Hash
+    def geoip
+      param = { "contact" => @id }
+      GetResponse::Connection.instance.send_request("get_contact_geoip", param)["result"]
+    end
+
+
+    # Place a contact on a desired day of the follow-up cycle or deactivate a contact. Method
+    # raises a <tt>GetResponseError</tt> exception when fails otherwise returns true.
+    #
+    # value:: String || Fixnum
+    # returns:: true
+    def set_cycle(value)
+      param = { "contact" => @id, "cycle_day" => value }
+      GetResponse::Connection.instance.send_request("set_contact_cycle", param)["result"]["updated"].to_i == 1
+    end
+
+
+    protected
+
+
+    def parse_customs(customs)
+      return unless customs
+      customs.inject([]) do |customs_hash, custom|
+        customs_hash << { "name" => custom[0], "content" => custom[1] }
+      end
+    end
+
+  end
+
+end
+

data/lib/get_response/get_response_error.rb

@@ -0,0 +1,5 @@
+# Errors for GetResponse. For example: bad requests, ...
+module GetResponse
+  class GetResponseError < StandardError
+  end
+end

data/lib/get_response/message.rb

@@ -0,0 +1,16 @@
+module GetResponse
+
+  # Class representa a message in GetResponse
+  class Message
+    attr_reader :id, :type, :subject, :day_of_cycle, :flags, :created_on
+
+    def initialize(params)
+      @id = params["id"]
+      @type = params["type"]
+      @subject = params["subject"]
+      @day_of_cycle = params["day_of_cycle"]
+      @flags = params["flags"] || []
+      @created_on = params["created_on"]
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: getresponse
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Sebastian Nowak
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-19 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 4
+        version: "1.4"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json_pure
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 4
+        version: "1.4"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rr
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :development
+  version_requirements: *id003
+description: With this gem you can manage your subscribers, campaigns, messages
+email: sebastian.nowak@implix.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/get_response/account.rb
+- lib/get_response/campaign.rb
+- lib/get_response/connection.rb
+- lib/get_response/contact.rb
+- lib/get_response/get_response_error.rb
+- lib/get_response/message.rb
+- lib/get_response.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://dev.getresponse.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 17
+      segments: 
+      - 1
+      - 3
+      - 5
+      version: 1.3.5
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby wrapper for GetResponse API
+test_files: []
+