sms_broker 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0b28741c2cf164576894b6b876444ae070f7303f
+  data.tar.gz: f0549e93ac7bbe3b87fff76d101a6f06152c192a
+SHA512:
+  metadata.gz: fcd96dffdafb77800af5a3798be97beff7ec3a921fcdbc061c0ad1f069f5ea127a976e0dace58624742c5ad510b400fadd866a3d6eba884d22a179d7577ae3c2
+  data.tar.gz: c6b9c850c13c0c43e2cc324b12fb6bf884bda46a3f0ab709a6ca13a06df0412a82341fd7e4e87d07aa0d47dfd100352906f9a685f6bf9a464c342a1c0cdccf10

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.rvmrc
+.ruby-version
+.ruby-gemset
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+spec/support/services_keys.yml
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--require spec_helper

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'codeclimate-test-reporter'
+  gem 'simplecov', require: false
+  gem 'rack-test'
+end

data/README.md

@@ -0,0 +1,56 @@
+Sms broker
+==========================
+
+### Usage
+
+```ruby
+SmsBroker.setup do |config|
+  config.services ['nexmo', 'twilio']
+
+  config.default_service 'nexmo'
+
+  config.nexmo_setup \
+    key: 'NEXMO_API_KEY',
+    secret: 'NEXMO_API_SECRET',
+    sender_id: 'NEXMO_SENDER_ID',
+    phone_number: 'NEXMO_PHONE_NUMBER'
+
+  config.twilio_setup \
+    auth_token: 'TWILIO_AUTH_TOKEN',
+    account_sid: 'TWILIO_ACCOUNT_SID',
+    sender_id: 'TWILIO_SENDER_ID',
+    phone_number: 'TWILIO_PHONE_NUMBER'
+end
+```
+
+#### Basic usage
+```ruby
+message = SmsBroker.message('Get paid doing small tasks!').to('441234567890')
+
+if message.valid?
+  response = message.deliver
+
+  # response.success?
+  # response.serialized
+end
+```
+
+#### Specifying the provider
+```ruby
+SmsBroker.service(:twilio).message('Get paid doing small tasks!').to('441234567890')
+```
+
+###Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sms_broker'
+
+And then execute:
+
+    $ bundle
+
+### Get in touch
+
+If you have any questions, write an issue or get in touch dev@streetbees.com
+

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+task :default => :test
+RSpec::Core::RakeTask.new(:test)

data/lib/sms_broker/client/base.rb

@@ -0,0 +1,24 @@
+module SmsBroker
+  module Client
+
+    class Base
+
+      attr_reader :name,
+                  :client,
+                  :options,
+                  :sender_id,
+                  :phone_number
+
+      def initialize(name, client)
+        @name = name
+        @client = client
+      end
+
+      def serialize_number(number)
+        "#{number}".delete("+")
+      end
+
+    end
+
+  end
+end

data/lib/sms_broker/client/nexmo.rb

@@ -0,0 +1,44 @@
+module SmsBroker
+  module Client
+
+    class Nexmo < Base
+
+      def initialize(options)
+        nexmo_options = options.dup
+
+        auth_options = {
+          key:    nexmo_options.delete(:key),
+          secret: nexmo_options.delete(:secret)
+        }
+
+        @sender_id = nexmo_options.delete(:sender_id)
+        @phone_number = nexmo_options.delete(:phone_number)
+
+        super(:nexmo, ::Nexmo::Client.new(auth_options))
+      end
+
+      def send_message(message)
+        response = client.send_message \
+          text: message[:text],
+          from: serialize_number(message[:from]),
+          to: serialize_number(message[:to])
+
+        if success_response?(response)
+          Response::NexmoSuccess.new(response)
+        else
+          Response::NexmoError.new(response)
+        end
+      end
+
+      private
+
+      def success_response?(response)
+        # just looking for the first message,
+        # right now only one message per call
+        response['messages'].length > 0 && response['messages'][0]['status'] == '0'
+      end
+
+    end
+
+  end
+end

data/lib/sms_broker/client/response/error.rb

@@ -0,0 +1,32 @@
+module SmsBroker
+  module Client
+    module Response
+
+      class Error
+
+        attr_reader :service,
+                    :response,
+                    :serialized
+
+        def initialize(service, response, serialized = {})
+          @service = service
+          @response = response
+          @serialized = { errors: serialized }
+        end
+
+        def success?
+          false
+        end
+
+        def invalid_sender_id?
+          (@serialized[:errors]['sender_id'] || {}).include?('is invalid')
+        end
+
+      end
+
+    end
+  end
+end
+
+require 'sms_broker/client/response/nexmo_error'
+require 'sms_broker/client/response/twilio_error'

data/lib/sms_broker/client/response/nexmo_error.rb

@@ -0,0 +1,35 @@
+module SmsBroker
+  module Client
+    module Response
+
+      class NexmoError < Error
+
+        SENDER_ID_NOT_SUPPORTED = '15'
+
+        def initialize(nexmo_response)
+          super :nexmo, nexmo_response, serialize_error_response(nexmo_response)
+        end
+
+        private
+
+        def serialize_error_response(nexmo_response)
+          errors = {}.tap do |hash|
+            nexmo_response['messages'].each do |message|
+              hash[message['status']] = [message['error-text']]
+            end
+
+            hash
+          end
+
+          if errors.keys.include?(SENDER_ID_NOT_SUPPORTED)
+            errors['sender_id'] = ['is invalid']
+          end
+
+          errors
+        end
+
+      end
+
+    end
+  end
+end

data/lib/sms_broker/client/response/nexmo_success.rb

@@ -0,0 +1,37 @@
+module SmsBroker
+  module Client
+    module Response
+
+      class NexmoSuccess < Success
+
+        def initialize(nexmo_response)
+          super :nexmo, nexmo_response, serialize(nexmo_response)
+        end
+
+        private
+
+        def serialize(response)
+          single_response = response['messages'][0]
+
+          {
+            to: single_response['to'],
+            from: single_response['from'],
+            message_id: single_response['message-id'],
+            raw: {
+              to: single_response['to'],
+              from: single_response['from'],
+              status: single_response['status'],
+              network: single_response['network'],
+              message_id: single_response['message-id'],
+              client_ref: single_response['client-ref'],
+              remaining_balance: single_response['remaining-balance'],
+              message_price: single_response['message-price']
+            }
+          }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/sms_broker/client/response/success.rb

@@ -0,0 +1,40 @@
+module SmsBroker
+  module Client
+    module Response
+
+      class Success
+
+        attr_reader :raw,
+                    :service,
+                    :serialized
+
+        def initialize(service, response, serialized)
+          @raw = response
+          @service = service
+          @serialized = serialized
+        end
+
+        def success?
+          true
+        end
+
+        def to
+          serialized[:to]
+        end
+
+        def from
+          serialized[:from]
+        end
+
+        def message_id
+          serialized[:message_id]
+        end
+
+      end
+
+    end
+  end
+end
+
+require 'sms_broker/client/response/nexmo_success'
+require 'sms_broker/client/response/twilio_success'

data/lib/sms_broker/client/response/twilio_error.rb

@@ -0,0 +1,51 @@
+module SmsBroker
+  module Client
+    module Response
+
+      class TwilioError < Error
+
+        SENDER_ID_NOT_SUPPORTED = '21212'
+
+        def initialize(twilio_response)
+          super :twilio, twilio_response, serialize(twilio_response)
+        end
+
+        private
+
+        def serialize(twilio_response)
+          if twilio_response.is_a?(::Twilio::REST::RequestError)
+            serialize_exeception_errors(twilio_response)
+          else
+            serialize_response_error(twilio_response)
+          end
+        end
+
+        def serialize_response_error(response)
+          errors = {
+            "#{response.error_code}" => [response.error_message]
+          }
+
+          if "#{response.error_code}" == SENDER_ID_NOT_SUPPORTED
+            errors['sender_id'] = ['is invalid']
+          end
+
+          errors
+        end
+
+        def serialize_exeception_errors(exception)
+          errors = {
+            "#{exception.code}" => [exception.message]
+          }
+
+          if "#{exception.code}" == SENDER_ID_NOT_SUPPORTED
+            errors['sender_id'] = ['is invalid']
+          end
+
+          errors
+        end
+
+      end
+
+    end
+  end
+end

data/lib/sms_broker/client/response/twilio_success.rb

@@ -0,0 +1,41 @@
+module SmsBroker
+  module Client
+    module Response
+
+      class TwilioSuccess < Success
+
+        def initialize(twilio_response)
+          super :twilio, twilio_response, serialize(twilio_response)
+        end
+
+        private
+
+        def serialize(response)
+          {
+            to: response.to,
+            from: response.from,
+            message_id: response.sid,
+            raw: {
+              to: response.to,
+              sid: response.sid,
+              uri: response.uri,
+              from: response.from,
+              body: response.body,
+              price: response.price,
+              status: response.status,
+              price_unit: response.price_unit,
+              error_code: response.error_code,
+              account_sid: response.account_sid,
+              api_version: response.api_version,
+              date_created: response.date_created,
+              error_message: response.error_message,
+              messaging_service_sid: response.messaging_service_sid
+            }
+          }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/sms_broker/client/twilio.rb

@@ -0,0 +1,49 @@
+module SmsBroker
+  module Client
+
+    class Twilio < Base
+
+      def initialize(options)
+        twilio_options = options.dup
+
+        auth_options = {
+          account_sid: twilio_options.delete(:account_sid),
+          auth_token:  twilio_options.delete(:auth_token)
+        }
+
+        @sender_id = twilio_options.delete(:sender_id)
+        @phone_number = twilio_options.delete(:phone_number)
+
+        super \
+          :twilio,
+          ::Twilio::REST::Client.new(auth_options[:account_sid], auth_options[:auth_token])
+      end
+
+      def send_message(message)
+        begin
+          response = client.messages.create \
+            body: message[:text],
+            from: serialize_number(message[:from]),
+            to: serialize_number(message[:to])
+
+          if failed_response?(response)
+            Response::TwilioError.new(response)
+          else
+            Response::TwilioSuccess.new(response)
+          end
+
+        rescue ::Twilio::REST::RequestError => exception
+          Response::TwilioError.new(exception)
+        end
+      end
+
+      private
+
+      def failed_response?(response)
+        ['undelivered', 'failed'].include?(response.status)
+      end
+
+    end
+
+  end
+end

data/lib/sms_broker/configuration.rb

@@ -0,0 +1,56 @@
+require 'sms_broker/setup'
+require 'sms_broker/exceptions/invalid_setup'
+
+module SmsBroker
+
+  module Configuration
+
+    @@configuration = nil
+
+    def default_service
+      configuration[:default_service]
+    end
+
+    def clear_setup
+      @@configuration = nil
+    end
+
+    def configuration
+      exception = \
+        Exceptions::InvalidSetup.new('setup does not exists')
+
+      @@configuration || (raise exception)
+    end
+
+    def setup(&block)
+      setup = Setup.new
+      yield setup if block_given?
+
+      @@configuration = setup.options
+
+      setup
+    end
+
+    def setup!(&block)
+      setup = Setup.new
+      yield setup if block_given?
+
+      unless setup.valid?
+        exception = \
+          Exceptions::InvalidSetup.new('setup is invalid, check exception.errors')
+
+        exception.errors = setup.errors
+
+        raise exception
+      end
+
+      @@configuration = setup.options
+
+      setup
+    end
+
+    extend self
+
+  end
+
+end

data/lib/sms_broker/exceptions/invalid_service.rb

@@ -0,0 +1,9 @@
+module SmsBroker
+  module Exceptions
+
+    class InvalidService < StandardError
+
+    end
+
+  end
+end

data/lib/sms_broker/exceptions/invalid_setup.rb

@@ -0,0 +1,11 @@
+module SmsBroker
+  module Exceptions
+
+    class InvalidSetup < StandardError
+
+      attr_accessor :errors
+
+    end
+
+  end
+end

data/lib/sms_broker/message_sender.rb

@@ -0,0 +1,81 @@
+module SmsBroker
+
+  class MessageSender
+
+    attr_reader :client,
+                :errors
+
+    def initialize(client)
+      @client = client
+    end
+
+    def to(number)
+      @message_to = number
+
+      self
+    end
+
+    def message(text)
+      @message_text = text
+
+      self
+    end
+
+    def deliver
+      unless valid?
+        return Client::Response::Error.new(client.name, errors, errors)
+      end
+
+      response = client.send_message(build_message)
+
+      if should_try_again_with_phone_number?(response)
+        return client.send_message(build_message(:phone_number))
+      end
+
+      response
+    end
+
+    def valid?
+      schema = {
+        message: Compel.string.required.max_length(140),
+        to: Compel.string.required
+      }
+
+      object = {
+        message: @message_text,
+        to: @message_to
+      }
+
+      result = Compel.hash.keys(schema).validate(object)
+
+      @errors = result.errors
+
+      result.valid?
+    end
+
+    private
+
+    def build_message(from = :sender_id)
+      sender = \
+        if client.sender_id && from == :sender_id
+          client.sender_id
+        else
+          client.phone_number
+        end
+
+      {
+        text: @message_text,
+        from: sender,
+        to:   @message_to
+      }
+    end
+
+    def should_try_again_with_phone_number?(response)
+      response.is_a?(Client::Response::Error) &&
+        response.invalid_sender_id? &&
+          !!client.sender_id
+    end
+
+  end
+
+end

data/lib/sms_broker/service.rb

@@ -0,0 +1,50 @@
+require 'sms_broker/message_sender'
+
+require 'sms_broker/client/base'
+require 'sms_broker/client/nexmo'
+require 'sms_broker/client/twilio'
+
+require 'sms_broker/exceptions/invalid_service'
+
+module SmsBroker
+
+  CLIENTS = {
+    nexmo:  Client::Nexmo,
+    twilio: Client::Twilio
+  }
+
+  class Service
+
+    def self.get(name)
+      options = service_configuration(name)
+
+      result = Service.validate(name, options)
+
+      unless result.valid?
+        raise Exceptions::InvalidService, { name.to_sym => result.errors }
+      end
+
+      new CLIENTS[name.to_sym].new(options)
+    end
+
+    def self.service_configuration(name)
+      SmsBroker.configuration[:services_setups][name.to_sym]
+    end
+
+    def self.validate(name, options)
+      Setup.service_validation_schemas[name.to_sym].validate(options)
+    end
+
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def message(message)
+      MessageSender.new(client).message(message)
+    end
+
+  end
+
+end