twilio_contactable 0.7.1

data/lib/controller.rb

@@ -0,0 +1,78 @@
+module TwilioContactable
+  module Controller
+
+    def self.included(controller)
+      controller.instance_eval do
+        # the developer should specify which model(s) will be sought
+        # when the app receives incoming requests
+        protected
+        def twilio_contactable(*klasses)
+          @@contactable_classes = klasses
+          klasses.each do |klass|
+            klass.twilio_contactable.controller = self.class.name.underscore.chomp('_controller')
+          end
+        end
+      end
+    end
+
+    def receive_sms_message
+      unless defined?(@@contactable_classes) && !@@contactable_classes.blank?
+        raise RuntimeError, "Please define which model(s) this controller should receive for via the 'twilio_contactable' method"
+      end
+
+      request = params[:request]
+      render :text => 'unknown format', :status => 500 and return unless request
+      case request['type']
+      when 'BLOCK'
+        @contactable = find_contactable_by_phone_number(request[:block][:recipient][:id])
+        @contactable._TC_sms_blocked = true
+        @contactable.save!
+      when 'MESSAGE'
+        @contactable = find_contactable_by_phone_number(request[:message][:sender][:id])
+        if @contactable.respond_to?(:receive_sms)
+          @contactable.receive_sms(request[:message][:text])
+        else
+          warn "An SMS message was received but #{@contactable.class.name.inspect} doesn't have a receive_sms method!"
+        end
+      end
+      render :text => 'OK', :status => 200
+    end
+
+    def start_voice_confirmation
+      render :xml => (Twilio::Response.new.tap do |response|
+        response.addGather(
+              :action => url_for(
+                :action => 'receive_voice_confirmation',
+                :contactable_type => params[:contactable_type],
+                :contactable_id   => params[:contactable_id]
+              )
+            ).tap do |gather|
+          gather.addSay "Please type the numbers that appear on your screen, followed by the pound sign"
+        end
+      end.respond)
+    end
+
+    def receive_voice_confirmation
+      @contactable = params[:contactable_type].constantize.find(params[:contactable_id])
+      @contactable.voice_confirm_with(params['Digits'])
+    end
+
+    protected
+
+      def find_contactable_by_phone_number(number)
+        [number, number.sub(/^\+/,''), number.sub(/^\+1/,'')].uniq.compact.each do |possible_phone_number|
+          @@contactable_classes.each do |klass|
+            found = klass.find(
+              :first,
+              :conditions => 
+                { klass.twilio_contactable.formatted_phone_number_column => possible_phone_number }
+            )
+            return found if found
+          end
+        end
+        nil
+      # rescue => error
+      #   render :text => error.inspect
+      end
+  end
+end

data/lib/gateway.rb

@@ -0,0 +1,105 @@
+module TwilioContactable
+  module Gateway
+    class WebsiteAddressNotConfiguredError < ArgumentError
+      def initialize
+        super "Please define your `website_address` config parameter "+
+              "in the TwilioContactable initializer. "+
+              "It should be in the format of: \"http://example.com/\""
+
+      end
+    end
+    class ControllerNotConfiguredError < ArgumentError
+      def initialize(record)
+        super "You're initiating a voice call for a "+
+              record.class.name.inspect +
+              " but you have not specified this class "+
+              "as a possible recipient in a controller."
+      end
+    end
+    class Response
+      def initialize(*args)
+        @options = args.last
+      end
+
+      def success?
+        :success == @options[:status]
+      end
+    end
+    Success = Response.new(:status => :success)
+    Error   = Response.new(:status => :error)
+
+    API_VERSION   = '2010-04-01'
+
+    class << self
+
+      def initiate_voice_call(record, to, from = nil)
+
+        unless TwilioContactable.configuration.website_address
+          raise WebsiteAddressNotConfiguredError.new
+        end
+        unless controller = record.class.twilio_contactable.controller
+          raise ControllerNotConfiguredError.new(record)
+        end
+
+        url = TwilioContactable.configuration.website_address.chomp('/')
+        url = "#{url}/#{record.class.twilio_contactable.controller}"
+        url = "#{url}/start_voice_confirmation?contactable_type=#{record.class}&contactable_id=#{record.id}"
+
+        deliver :voice,
+                'To' => to,
+                'From' => from,
+                'Url' => url
+      end
+
+      def deliver_sms(message, to, from = nil)
+        deliver :sms,
+                'Message' => message,
+                'To' => to,
+                'From' => from
+      end
+
+      def account
+        @account ||= begin
+          if TwilioContactable.configuration.client_id.blank? ||
+             TwilioContactable.configuration.client_key.blank?
+             raise "Add your Twilio account id (as client_id) and token (as client_key) to the TwilioContactable.configure block"
+          end
+          Twilio::RestAccount.new(
+                      TwilioContactable.configuration.client_id,
+                      TwilioContactable.configuration.client_key
+                    )
+        end
+      end
+
+      protected
+
+        def deliver(type, data = {})
+
+          data['From'] = TwilioContactable.configuration.default_from_phone_number if data['From'].blank?
+          raise "'From' number required for Twilio" unless data['From']
+
+          service = case type
+          when :sms
+            'SMS/Messages'
+          when :voice
+            'Calls'
+          end
+
+          response = post service, data
+ 
+          Net::HTTPCreated == response.code_type ?
+                                TwilioContactable::Gateway::Success :
+                                TwilioContactable::Gateway::Error
+        end
+
+        def post(service, data = {})
+          url = "/#{API_VERSION}/Accounts/#{TwilioContactable.configuration.client_id}/#{service}"
+          puts "putting data: #{data.inspect}"
+          puts "to url: #{url}"
+          account.request url,
+                          "POST",
+                          data
+        end
+    end
+  end
+end

data/lib/twilio_contactable.rb

@@ -0,0 +1,40 @@
+module TwilioContactable
+  class << self
+    def numerize(numberish)
+      numberish.to_s.scan(/\d+/).join
+    end
+
+    def internationalize(given_number)
+      number = numerize(given_number)
+      case number.size
+      when 10
+        "+1#{number}"
+      when 11
+        "+#{number}"
+      when 12
+        number =~ /\+\d(11)/ ? number : nil
+      else
+        nil
+      end
+    end
+
+    def confirmation_message(confirmation_code)
+      "Code: #{confirmation_code} Enter code on web to verify phone. Msg&data rates may apply. Freq set by u. T&C & support on web site. Txt HELP for help"
+    end
+
+    def generate_confirmation_code
+      chars = (0..9).to_a + ('A'..'Z').to_a
+      (0...6).collect { chars[Kernel.rand(chars.length)] }.join
+    end
+  end
+end
+
+gem 'twiliolib'
+require 'twiliolib'
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'configuration'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'gateway'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'contactable'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'controller'))
+
+ActiveRecord::Base.send :include, TwilioContactable::Contactable

data/test/.gitignore

@@ -0,0 +1 @@
+debug.log

data/test/database.yml

@@ -0,0 +1,18 @@
+sqlite:
+  :adapter: sqlite
+  :database: plugin.sqlite.db
+sqlite3:
+  :adapter: sqlite3
+  :database: ":memory:"
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: plugin_test
+  :min_messages: ERROR
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password:
+  :database: plugin_test

data/test/test_helper.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+gem 'test-unit'
+require 'test/unit'
+require 'mocha'
+gem 'activesupport', '< 3.0.0'
+require 'active_support'
+require 'active_support/test_case'
+gem 'activerecord', '< 3.0.0'
+require 'active_record'
+gem 'actionpack', '< 3.0.0'
+require 'actionpack'
+require 'action_controller'
+require 'shoulda'
+require 'shoulda/action_controller'
+require 'shoulda/action_controller/macros'
+require 'shoulda/action_controller/matchers'
+require File.join(File.dirname(__FILE__), "..", 'lib', 'twilio_contactable')
+
+# default test configuration
+TwilioContactable.configure do |config|
+  config.client_id  = '1'
+  config.client_key = 'ABCDEF'
+  config.website_address = 'http://example.com'
+  config.default_from_phone_number = '1 (206) 867-5309'
+end
+
+TwilioContactable.mode = :test
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+require 'logger'
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite3'])
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :users do |t|
+    t.column :phone_number,                 :string
+    t.column :formatted_phone_number,       :string
+    t.column :sms_blocked,                  :boolean
+    t.column :sms_confirmation_code,        :string
+    t.column :sms_confirmation_attempted,   :datetime
+    t.column :sms_confirmed_phone_number,   :string
+    t.column :voice_blocked,                :boolean
+    t.column :voice_confirmation_code,      :string
+    t.column :voice_confirmation_attempted, :datetime
+    t.column :voice_confirmed_phone_number, :string
+
+    t.column :custom_column,                :string
+
+    t.column :type, :string
+  end
+end
+
+class User < ActiveRecord::Base
+  include TwilioContactable::Contactable
+end
+
+# kill all network access
+module TwilioContactable
+  module Gateway
+    def post
+      raise "You forgot to stub out your net requests!"
+    end
+  end
+end

data/test/twilio_contactable_contactable_test.rb

@@ -0,0 +1,308 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class TwilioContactableContactableTest < ActiveSupport::TestCase
+
+  Success = TwilioContactable::Gateway::Response.new(:status => :success)
+  Error   = TwilioContactable::Gateway::Response.new(:status => :error)
+
+  context "configuration" do
+    TwilioContactable::Contactable::Attributes.each do |attr|
+      context "attribute: #{attr}" do
+        should "begin with appropriate default for #{attr}_column and allow overwriting" do
+          klass = Class.new
+          klass.send :include, TwilioContactable::Contactable
+          assert_equal attr, klass.twilio_contactable.send("#{attr}_column")
+          klass.twilio_contactable do |config|
+            config.send("#{attr}_column=", :custom_column)
+          end
+          assert_equal :custom_column, klass.twilio_contactable.send("#{attr}_column")
+        end
+      end
+    end
+  end
+
+  context "contactable instance" do
+    setup {
+      User.delete_all
+      @user = User.create! :phone_number => '(555) 123-4567'
+    }
+
+    should "normalize phone number" do
+      assert_equal '+15551234567', @user.formatted_phone_number
+    end
+    context "when phone number is blank" do
+      setup { @user._TC_phone_number = nil}
+      context "confirming phone number" do
+        setup { @user.send_sms_confirmation! }
+        should_not_change "any attributes" do
+          @user.attributes.inspect
+        end
+      end
+      context "sending message" do
+        setup {
+          TwilioContactable::Gateway.stubs(:perform).returns(Success)
+          @worked = @user.send_sms!('message')
+        }
+        should "not work" do assert !@worked end
+        should_not_change "any attributes" do
+          @user.attributes.inspect
+        end
+      end
+    end
+
+    context "when phone number exists" do
+      setup { @user._TC_phone_number = "206-555-5555"}
+      context "confirming phone number" do
+        context "via sms" do
+          setup {
+            TwilioContactable::Gateway.stubs(:deliver).returns(Success)
+            @worked = @user.send_sms_confirmation!
+          }
+          should "work" do assert @worked end
+          should "save confirmation number in proper attribute" do
+            assert @user._TC_sms_confirmation_code
+          end
+          should "set confirmation attempted time" do
+            assert @user._TC_sms_confirmation_attempted > 3.minutes.ago
+          end
+          should_change "stored code" do
+            @user._TC_sms_confirmation_code
+          end
+          should "not have number confirmed yet" do
+            assert !@user.sms_confirmed?
+          end
+          context "calling sms_confirm_with(right_code)" do
+            setup { @user.sms_confirm_with(@user._TC_sms_confirmation_code) }
+            should "work" do
+              assert @worked
+            end
+            should "save the phone number into the confirmed attribute" do
+              assert_equal @user._TC_phone_number,
+                           @user._TC_sms_confirmed_phone_number,
+                           @user.reload.inspect
+            end
+            should_change "confirmed phone number attribute" do
+              @user._TC_sms_confirmed_phone_number
+            end
+            context "and then attempting to confirm another number" do
+              setup {
+                @user._TC_phone_number = "206-555-8990"
+                TwilioContactable::Gateway.stubs(:deliver).returns(Success).once
+                @user.send_sms_confirmation!
+              }
+              should "eliminate the previous confirmed phone number" do
+                assert @user._TC_sms_confirmed_phone_number.blank?
+              end
+              should "un-confirm the record" do
+                assert !@user.sms_confirmed?
+              end
+            end
+          end
+          context "calling sms_confirm_with(right code, wrong case)" do
+            setup {
+              @downcased_code = @user._TC_sms_confirmation_code.downcase
+              @worked = @user.sms_confirm_with(@downcased_code)
+            }
+            should "have good test data" do
+              assert_not_equal @downcased_code,
+                               @user._TC_sms_confirmation_code
+            end
+            should "work" do
+              assert @worked
+            end
+            should "save the phone number into the confirmed attribute" do
+              assert_equal @user._TC_sms_confirmed_phone_number,
+                           @user._TC_phone_number
+            end
+          end
+          context "calling sms_confirm_with(wrong_code)" do
+            setup { @worked = @user.sms_confirm_with('wrong_code') }
+            should "not work" do
+              assert !@worked
+            end
+            should "not save the phone number into the confirmed attribute" do
+              assert_not_equal @user._TC_sms_confirmed_phone_number,
+                               @user._TC_phone_number
+            end
+            should_not_change "confirmed phone number attribute" do
+              @user.reload._TC_sms_confirmed_phone_number
+            end
+          end
+        end
+        context "confirming phone number with a custom short code" do
+          context "with expectations" do
+            setup {
+              message = "long message blah blah MYCODE blah"
+              TwilioContactable.expects(:generate_confirmation_code).returns('MYCODE').once
+              TwilioContactable.expects(:confirmation_message).returns(message).once
+              TwilioContactable::Gateway.expects(:deliver).with(message, @user._TC_phone_number).once
+              @user.send_sms_confirmation!
+            }
+          end
+          context "(normal)" do
+            setup {
+              TwilioContactable::Gateway.stubs(:deliver).returns(Success)
+              @worked = @user.send_sms_confirmation!
+            }
+            should "work" do
+              assert @worked
+            end
+          end
+        end
+        context "confirming phone number when the confirmation fails for some reason" do
+          setup {
+            TwilioContactable::Gateway.stubs(:deliver).returns(Error)
+            @worked = @user.send_sms_confirmation!
+          }
+          should "not work" do assert !@worked end
+          should "not save confirmation number" do
+            assert @user._TC_sms_confirmation_code.blank?
+          end
+          should_not_change "stored code" do
+            @user._TC_sms_confirmation_code
+          end
+        end
+        context "via voice" do
+          setup {
+            TwilioContactable::Gateway.stubs(:deliver).returns(Success)
+            # To start any voice call we'll need to first initialize
+            # this model in a controller
+            class TestController < ActionController::Base
+              include TwilioContactable::Controller
+              twilio_contactable User
+              self
+            end
+            @worked = @user.send_voice_confirmation!
+          }
+          should "work" do assert @worked end
+          should "save confirmation number in proper attribute" do
+            assert @user._TC_voice_confirmation_code
+          end
+          should "set confirmation attempted time" do
+            assert @user._TC_voice_confirmation_attempted > 3.minutes.ago
+          end
+          should_change "stored code" do
+            @user._TC_voice_confirmation_code
+          end
+          should "not have number confirmed yet" do
+            assert !@user.voice_confirmed?
+          end
+          context "calling voice_confirm_with(right_code)" do
+            setup { @user.voice_confirm_with(@user._TC_voice_confirmation_code) }
+            should "work" do
+              assert @worked
+            end
+            should "save the phone number into the confirmed attribute" do
+              assert_equal @user._TC_phone_number,
+                           @user._TC_voice_confirmed_phone_number,
+                           @user.reload.inspect
+            end
+            should_change "confirmed phone number attribute" do
+              @user._TC_voice_confirmed_phone_number
+            end
+            context "and then attempting to confirm another number" do
+              setup {
+                @user._TC_phone_number = "206-555-8990"
+                TwilioContactable::Gateway.stubs(:deliver).returns(Success).once
+                @user.send_voice_confirmation!
+              }
+              should "eliminate the previous confirmed phone number" do
+                assert @user._TC_voice_confirmed_phone_number.blank?
+              end
+              should "un-confirm the record" do
+                assert !@user.voice_confirmed?
+              end
+            end
+          end
+          context "calling voice_confirm_with(right code, wrong case)" do
+            setup {
+              @downcased_code = @user._TC_voice_confirmation_code.downcase
+              @worked = @user.voice_confirm_with(@downcased_code)
+            }
+            should "have good test data" do
+              assert_not_equal @downcased_code,
+                               @user._TC_voice_confirmation_code
+            end
+            should "work" do
+              assert @worked
+            end
+            should "save the phone number into the confirmed attribute" do
+              assert_equal @user._TC_voice_confirmed_phone_number,
+                           @user._TC_phone_number
+            end
+          end
+          context "calling voice_confirm_with(wrong_code)" do
+            setup { @worked = @user.voice_confirm_with('wrong_code') }
+            should "not work" do
+              assert !@worked
+            end
+            should "not save the phone number into the confirmed attribute" do
+              assert_not_equal @user._TC_voice_confirmed_phone_number,
+                               @user._TC_phone_number
+            end
+            should_not_change "confirmed phone number attribute" do
+              @user.reload._TC_voice_confirmed_phone_number
+            end
+          end
+        end
+      end
+    end
+
+    context "when the number is not confirmed" do
+      context "sending a message" do
+        setup {
+          TwilioContactable::Gateway.stubs(:deliver).returns(Success)
+          @result = @user.send_sms!('message')
+        }
+        should "send send no messages" do
+          assert_equal false, @result
+        end
+      end
+    end
+    context "when the number is blocked" do
+      setup {
+        @user._TC_sms_blocked = true
+        @user.save!
+      }
+      context "sending a message" do
+        setup { @result = @user.send_sms!('message') }
+        should "send nothing" do
+          assert_equal false, @result
+        end
+      end
+    end
+    context "when the number is confirmed" do
+      setup {
+        TwilioContactable::Gateway.stubs(:deliver).returns(Success)
+        @user.stubs(:sms_confirmed?).returns(true)
+      }
+      context "sending a message" do
+        setup { @result = @user.send_sms!('message') }
+        should "send send exactly one message" do
+          assert_equal [7], @result
+        end
+      end
+      context "sending a blank message" do
+        setup { @result = @user.send_sms!('') }
+        should "send send zero messages" do
+          assert_equal false, @result
+        end
+      end
+      context "sending a huge message" do
+        context "without the allow_multiple flag" do
+          should "raise an error" do
+            assert_raises ArgumentError do
+              @user.send_sms!("A"*200)
+            end
+          end
+        end
+        context "with the allow_multiple flag" do
+          setup { @result = @user.send_sms!("A"*200, true) }
+          should "send multiple messages" do
+            assert_equal [160, 40], @result
+          end
+        end
+      end
+    end
+  end
+end