intercom-rails 0.0.7 → 0.0.8

data/lib/intercom-rails.rb

@@ -1,6 +1,7 @@
 require 'intercom-rails/script_tag_helper'
 require 'intercom-rails/auto_include_filter'
 require 'intercom-rails/config'
+require 'intercom-rails/import'
 require 'intercom-rails/railtie' if defined? Rails
 
 module IntercomRails

data/lib/intercom-rails/config.rb

@@ -2,6 +2,7 @@ module IntercomRails
 
   module Config
 
+    # Your Intercom app_id
     def self.app_id=(value)
       @app_id = value
     end
@@ -10,6 +11,25 @@ module IntercomRails
       @app_id
     end
 
+    # Intercom api secret, for secure mode
+    def self.api_secret=(value)
+      @api_secret = value
+    end
+
+    def self.api_secret
+      @api_secret
+    end
+
+    # Intercom API key, for some rake tasks
+    def self.api_key=(value)
+      @api_key = value
+    end
+
+    def self.api_key
+      @api_key
+    end
+
+    # How is the current logged in user accessed in your controllers?
     def self.current_user=(value)
       raise ArgumentError, "current_user should be a Proc" unless value.kind_of?(Proc)
       @current_user = value
@@ -19,6 +39,16 @@ module IntercomRails
       @current_user
     end
 
+    # What class defines your user model?
+    def self.user_model=(value)
+      raise ArgumentError, "user_model should be a Proc" unless value.kind_of?(Proc)
+      @user_model = value
+    end
+
+    def self.user_model
+      @user_model
+    end
+
   end
 
 end

data/lib/intercom-rails/import.rb

@@ -0,0 +1,153 @@
+require 'net/http'
+require 'json'
+require 'uri'
+
+module IntercomRails
+  class ImportError < StandardError; end
+  class IntercomAPIError < StandardError; end
+
+  class Import
+
+    def self.bulk_create_api_endpoint
+      host = (ENV['INTERCOM_RAILS_DEV'] ? "http://api.intercom.dev" : "https://api.intercom.io")
+      URI.parse(host + "/v1/users/bulk_create")
+    end
+
+    def self.run(*args)
+      new(*args).run
+    end
+
+    attr_reader :uri, :http
+    attr_accessor :failed, :total_sent
+
+    def initialize(options = {})
+      @uri = Import.bulk_create_api_endpoint
+      @http = Net::HTTP.new(@uri.host, @uri.port)
+      @failed = []
+      @total_sent = 0
+
+      @status_enabled = !!options[:status_enabled]
+
+      if uri.scheme == 'https'
+        http.use_ssl = true 
+        http.ca_file = File.join(File.dirname(__FILE__), '../data/ca_cert.pem')
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+    end
+
+    def assert_runnable
+      raise ImportError, "You can only import your users from your production environment" unless Rails.env.production?
+      raise ImportError, "We couldn't find your user class, please set one in config/initializers/intercom_rails.rb" unless user_klass.present?
+      info "Found user class: #{user_klass}"
+      raise ImportError, "Only ActiveRecord models are supported" unless (user_klass < ActiveRecord::Base)
+      raise ImportError, "Please add an Intercom API Key to config/initializers/intercom.rb" unless IntercomRails.config.api_key.present?
+      info "Intercom API key found"
+    end
+
+    def run
+      assert_runnable
+
+      info "Sending users in batches of #{MAX_BATCH_SIZE}:"
+      batches do |batch, number_in_batch|
+        failures = send_users(batch)['failed']
+        self.failed += failures
+        self.total_sent += number_in_batch
+
+        progress '.' * (number_in_batch - failures.count)
+        progress 'F' * failures.count
+      end
+      info "Successfully created #{self.total_sent - self.failed.count} users", :new_line => true
+      info "Failed to create #{self.failed.count} #{(self.failed.count == 1) ? 'user' : 'users'}, this is likely due to bad data" unless failed.count.zero?
+      
+      self
+    end
+
+    def total_failed
+      self.failed.count
+    end
+
+    private
+    MAX_BATCH_SIZE = 100
+    def batches
+      user_klass.find_in_batches(:batch_size => MAX_BATCH_SIZE) do |users|
+        users_for_wire = users.map { |u| user_for_wire(u) }.compact
+        yield(prepare_batch(users_for_wire), users_for_wire.count) unless users_for_wire.count.zero?
+      end
+    end
+
+    def prepare_batch(batch)
+      {:users => batch}.to_json
+    end
+
+    def user_for_wire(user)
+      wired = {}.tap do |h|
+        h[:user_id] = user.id if user.respond_to?(:id) && user.id.present?
+        h[:email] = user.email if user.respond_to?(:email) && user.email.present?
+        h[:name] = user.name if user.respond_to?(:name) && user.name.present?
+      end
+
+      (wired[:user_id] || wired[:email]) ? wired : nil
+    end
+
+    def user_klass
+      if IntercomRails.config.user_model.present?
+        IntercomRails.config.user_model.call
+      else
+        User
+      end
+    rescue NameError
+      # Rails lazy loads constants, so this is how we check 
+      nil
+    end
+
+    def send_users(users)
+      request = Net::HTTP::Post.new(uri.request_uri) 
+      request.basic_auth(IntercomRails.config.app_id, IntercomRails.config.api_key)
+      request["Content-Type"] = "application/json"
+      request.body = users 
+
+      response = perform_request(request)
+      JSON.parse(response.body)
+    end
+
+    MAX_REQUEST_ATTEMPTS = 3
+    def perform_request(request, attempts = 0, error = {})
+      if (attempts > 0) && (attempts < MAX_REQUEST_ATTEMPTS)
+        sleep(0.5) 
+      elsif error.present?
+        raise error[:exception] if error[:exception]
+        raise exception_for_failed_response(error[:failed_response])
+      end
+
+      response = http.request(request)
+
+      return response if successful_response?(response)
+      perform_request(request, attempts + 1, :failed_response => response)
+    rescue Timeout::Error, Errno::ECONNREFUSED => e
+      perform_request(request, attempts + 1, :exception => e)
+    end
+
+    def successful_response?(response)
+      raise ImportError, "App ID or API Key are incorrect, please check them in config/initializers/intercom.rb" if response.code == '403'
+      ['200', '201'].include?(response.code)
+    end
+
+    def exception_for_failed_response(response)
+      code = response.code
+      IntercomAPIError.new("The Intercom API request failed with the code: #{code}, after #{MAX_REQUEST_ATTEMPTS} attempts.")
+    end
+
+    def status_enabled?
+      @status_enabled
+    end
+
+    def progress(str)
+      print(str) if status_enabled?
+    end
+
+    def info(str, options = {})
+      puts "#{"\n" if options[:new_line]}* #{str}" if status_enabled?
+    end
+
+  end
+end

data/lib/intercom-rails/intercom.rake

@@ -0,0 +1,12 @@
+namespace :intercom do
+
+  desc "Import your users into intercom"
+  task :import => :environment do
+    begin
+      IntercomRails::Import.run(:status_enabled => true)
+    rescue IntercomRails::ImportError => e
+      puts e.message
+    end
+  end
+
+end

data/lib/intercom-rails/railtie.rb

@@ -7,5 +7,9 @@ module IntercomRails
     initializer "intercom_on_rails.auto_include_filter.rb" do |app|
       ActionController::Base.send :after_filter, AutoIncludeFilter 
     end
+
+    rake_tasks do
+      load 'intercom-rails/intercom.rake'
+    end
   end
 end

data/lib/intercom-rails/version.rb

@@ -1,3 +1,3 @@
 module IntercomRails
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/lib/rails/generators/intercom/config/config_generator.rb

@@ -7,9 +7,14 @@ module Intercom
       end
 
       argument :app_id, :desc => "Your Intercom app-id, which can be found here: https://www.intercom.io/apps/api_keys"
+      argument :api_secret, :desc => "Your Intercom api-secret, used for secure mode"
+      argument :api_key, :desc => "An Intercom API key, for various rake tasks"
 
       def create_config_file
         @app_id = app_id
+        @api_secret = api_secret
+        @api_key = api_key
+
         template("intercom.rb.erb", "config/initializers/intercom.rb")
       end
 

data/lib/rails/generators/intercom/config/intercom.rb.erb

@@ -1,8 +1,36 @@
 IntercomRails.config do |config|
-  # Your Intercom app_id
+  # == Intercom app_id
+  # 
   config.app_id = "<%= @app_id %>"
 
+  # == Intercom secret key 
+  # This is reuqired to enable secure mode, you can find it on your Intercom 
+  # "security" configuration page.
+  # 
+  <%- if @api_secret -%>
+  config.api_secret = "<%= @api_secret %>"
+  <%- else -%>
+  # config.api_secret = '...'
+  <%- end -%>
+
+  # == Intercom API Key
+  # This is required for some Intercom rake tasks like importing your users;
+  # you can generate one at https://www.intercom.io/apps/api_keys.
+  #
+  <%- if @api_key -%>
+  config.api_key = "<%= @api_key %>"
+  <%- else -%>
+  # config.api_key = "..."
+  <%- end -%>
+
+  # == Curent user name
   # The method/variable that contains the logged in user in your controllers.
   # If it is `current_user` or `@user`, then you can ignore this
+  #
   # config.current_user = Proc.new { current_user }
+  
+  # == User model class
+  # The class which defines your user model
+  #
+  # config.user_model = Proc.new { User }
 end

data/test/action_controller_test_setup.rb

@@ -1,6 +1,5 @@
 require 'test_setup'
 
-require 'pry'
 require 'action_controller'
 require 'action_controller/test_case'
 

data/test/import_test_setup.rb

@@ -0,0 +1,62 @@
+require 'test_setup'
+require 'active_support/string_inquirer'
+
+class Rails
+  def self.env
+    ActiveSupport::StringInquirer.new("production")
+  end
+end
+
+module ActiveRecord
+  class Base; end
+end
+
+class User
+
+  attr_reader :id, :email, :name
+
+  def initialize(options = {})
+    options.each do |k,v|
+      instance_variable_set(:"@#{k}", v)
+    end
+  end
+
+  MOCK_USERS = [
+    {:id => 1, :email => "ben@intercom.io", :name => "Ben McRedmond"},
+    {:id => 2, :email => "ciaran@intercom.io", :name => "Ciaran Lee"}
+  ]
+
+  def self.find_in_batches(*args)
+    yield(MOCK_USERS.map {|u| new(u)})
+  end
+
+  def self.all
+    MOCK_USERS.map { |u| new(u) }
+  end
+
+  def self.first
+    new(MOCK_USERS.first)
+  end
+
+  def self.<(other)
+    other == ActiveRecord::Base
+  end
+
+end
+
+module ImportTest
+
+  def setup
+    super
+    IntercomRails.config.stub(:api_key).and_return("abcd")
+  end
+
+  def teardown
+    super
+    Rails.rspec_reset
+    User.rspec_reset
+    IntercomRails::Import.rspec_reset
+    IntercomRails::Import.unstub_all_instance_methods
+  end
+
+end

data/test/intercom-rails/import_network_test.rb

@@ -0,0 +1,121 @@
+require 'import_test_setup'
+require 'sinatra/base'
+
+class MockIntercom < Sinatra::Base
+
+  set :server, 'thin'
+
+  before do
+    content_type 'application/json'
+  end
+
+  get '/health_check' do
+    content_type 'plain/text'
+    'hello world'
+  end
+
+  post '/all_successful' do
+    {:failed => []}.to_json 
+  end
+
+  post '/one_failure' do
+    {:failed => ['ben@intercom.io']}.to_json
+  end
+
+  post '/bad_auth' do
+    status 403
+    {"error" => {"type" => "not_authenticated", "message" => "HTTP Basic: Access denied."}}.to_json
+  end
+
+  post '/500_error' do
+    status 500
+    {"error" => {"type" => "server_error", "message" => "Danger deploy, gone wrong?"}}.to_json
+  end
+
+end
+
+class InterRunner < MiniTest::Unit
+
+  self.runner = self.new
+  
+  def _run(*args)
+    @mock_intercom_pid = start_mock_intercom
+    super
+  ensure
+    Process.kill('INT', @mock_intercom_pid)
+    Process.wait(@mock_intercom_pid) rescue SystemError
+  end
+
+  private
+
+  def start_mock_intercom
+    pid = fork do 
+      MockIntercom.run!(:port => 46837) do |server|
+        server.silent = true
+      end
+    end
+
+    response = nil
+    uri = URI.parse("http://localhost:46837/health_check")
+
+    begin
+      response = Net::HTTP.get_response(uri).body until(response == 'hello world')
+    rescue Errno::ECONNREFUSED
+      sleep(0.5)
+      retry
+    end
+
+    pid
+  end
+
+end
+
+class ImportNetworkTest < InterRunner::TestCase
+
+  include ImportTest
+
+  def api_path=(path)
+    IntercomRails::Import.stub(:bulk_create_api_endpoint) {
+      URI.parse("http://localhost:46837/#{path}")
+    }
+
+    @import = IntercomRails::Import.new
+  end
+
+  def test_empty_failed
+    self.api_path = '/all_successful'
+
+    @import.run
+    assert_equal [], @import.failed
+    assert_equal 2, @import.total_sent
+  end
+
+  def test_sets_failed_correctly
+    self.api_path = '/one_failure'
+
+    @import.run
+    assert_equal ["ben@intercom.io"], @import.failed
+    assert_equal 2, @import.total_sent
+  end
+
+  def test_raises_import_error_on_bad_auth
+    self.api_path = '/bad_auth'
+
+    exception = assert_raises(IntercomRails::ImportError) { 
+      @import.run
+    }
+
+    assert_equal "App ID or API Key are incorrect, please check them in config/initializers/intercom.rb", exception.message
+  end
+
+  def test_throws_exception_when_intercom_api_is_being_a_dick
+    self.api_path = '/500_error'
+
+    exception = assert_raises(IntercomRails::IntercomAPIError) {
+      @import.run
+    }
+
+    assert_equal "The Intercom API request failed with the code: 500, after 3 attempts.", exception.message
+  end
+
+end