telesign 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f4fb4ae5bbb4416898ea2e7c112f2d2b2a6b0034
-  data.tar.gz: 6c04091a0147ad4a043fabb157a69bd2c7783ef6
+  metadata.gz: ab9def95b96cf38a18a3da1f0bdeb190bb2b1251
+  data.tar.gz: 2b56069c25921ede2a59470e077d45b36536a60f
 SHA512:
-  metadata.gz: 76bd07cd4c2154d66fe0e6ffdf63affdeaca551de2bbddf436681721bcd213126488d5a7e9a0afa74891942a5bcf54db3dd65cbe0521b20377b053a8e97fe343
-  data.tar.gz: b98936cbed7db929f4018046e21d8201440af6b179a924cdfeff2993e68a160879fb3c308dd56bbd79b6a024d3aecc5ee614133e631ead4afcc990ce79a9c9bd
+  metadata.gz: 7717044b79a5869bf239d0c0e0f522337a8e90cdcc0be80e3cf69c56e419307a804f2c59252118d413309b0338325a5672e583f25c40f5638bcbc0c0864843af
+  data.tar.gz: 17264a1b3234d6b5dfe37a492c867200db0f2943faa6dab287d31c8313544e7629469c142ef1b6209d7c03298daeca23ee682d0033d092927bfb2846cbd3b425

data/lib/telesign.rb

@@ -1,405 +1,7 @@
-#
-# Copyright (c) 2016 TeleSign
-#
-# TeleSign Ruby SDK REST API endpoints.
-#
-# The api module contains Python classes and methods that allow you to
-# use the Ruby programming language to programmatically access the
-# Verify and PhoneId TeleSign web services.
-#
-
+require 'telesign/autoverify'
+require 'telesign/messaging'
+require 'telesign/phoneid'
 require 'telesign/rest'
-
-module Telesign
-
-  module API
-
-    # The PhoneId class exposes services that each provide detailed
-    # information about a specified phone number.
-    class PhoneId < Telesign::API::Rest
-
-      def initialize(customer_id,
-                     secret_key,
-                     ssl=true,
-                     api_host='rest.telesign.com',
-                     timeout=nil)
-
-        super(customer_id,
-              secret_key,
-              ssl,
-              api_host,
-              timeout)
-      end
-
-      # Retrieves the standard set of details about the specified phone number.
-      # This includes the type of phone (e.g., land line or mobile), and it's
-      # approximate geographic location.
-      def standard(phone_number,
-                   use_case_code=nil,
-                   extra=nil,
-                   timeout=nil)
-
-        params = {}
-
-        unless use_case_code.nil?
-          params[:ucid] = use_case_code
-        end
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Get,
-                "/v1/phoneid/standard/#{phone_number}",
-                params,
-                nil,
-                timeout)
-      end
-
-      # Retrieves a score for the specified phone number. This ranks the phone number's
-      # "risk level" on a scale from 0 to 1000, so you can code your web application to
-      # handle particular use cases (e.g., to stop things like chargebacks, identity
-      # theft, fraud, and spam).
-      def score(phone_number,
-                use_case_code,
-                extra=nil,
-                timeout=nil)
-
-        params = {:ucid => use_case_code}
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Get,
-                "/v1/phoneid/score/#{phone_number}",
-                params,
-                nil,
-                timeout)
-      end
-
-      # In addition to the information retrieved by standard, this service provides the
-      # Name & Address associated with the specified phone number.
-      def contact(phone_number,
-                  use_case_code,
-                  extra=nil,
-                  timeout=nil)
-
-        params = {:ucid => use_case_code}
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Get,
-                "/v1/phoneid/contact/#{phone_number}",
-                params,
-                nil,
-                timeout)
-      end
-
-      # In addition to the information retrieved by standard, this service provides
-      # actionable data associated with the specified phone number.
-      def live(phone_number,
-               use_case_code,
-               extra=nil,
-               timeout=nil)
-
-        params = {:ucid => use_case_code}
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Get,
-                "/v1/phoneid/live/#{phone_number}",
-                params,
-                nil,
-                timeout)
-      end
-
-      # In addition to the information retrieved by standard, this service provides
-      # data about potential sim_swaps associated with the specified phone number.
-      def sim_swap(phone_number,
-                   use_case_code,
-                   extra=nil,
-                   timeout=nil)
-
-        params = {:ucid => use_case_code}
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Get,
-                "/v1/phoneid/sim_swap/check/#{phone_number}",
-                params,
-                nil,
-                timeout)
-      end
-
-      # In addition to the information retrieved by standard, this service provides
-      # information on call forwarding for the phone number provided.
-      def call_forward(phone_number,
-                       use_case_code,
-                       extra=nil,
-                       timeout=nil)
-
-        params = {:ucid => use_case_code}
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Get,
-                "/v1/phoneid/call_forward/#{phone_number}",
-                params,
-                nil,
-                timeout)
-      end
-
-      # In addition to the information retrieved by standard, this service provides
-      # information on call forwarding for the phone number provided.
-      def number_deactivation(phone_number,
-                              use_case_code,
-                              extra=nil,
-                              timeout=nil)
-
-        params = {:ucid => use_case_code}
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Get,
-                "/v1/phoneid/number_deactivation/#{phone_number}",
-                params,
-                nil,
-                timeout)
-      end
-
-    end
-
-    # The Verify class exposes several services for sending users a verification
-    # token. You can use this mechanism to simply test whether you can reach users
-    # at the phone number they supplied, or you can have them use the token to
-    # authenticate themselves with your web application.
-    #
-    # This class also exposes a service that is used in conjunction with the first
-    # two services, in that it allows you to confirm the result of the authentication.
-    #
-    # You can use this verification factor in combination with username & password to
-    # provide two-factor authentication for higher security.
-    class Verify < Telesign::API::Rest
-
-      def initialize(customer_id,
-                     secret_key,
-                     ssl=true,
-                     api_host='rest.telesign.com',
-                     timeout=nil)
-
-        super(customer_id,
-              secret_key,
-              ssl,
-              api_host,
-              timeout)
-      end
-
-      # Sends a text message containing the verification code, to the specified
-      # phone number (supported for mobile phones only).
-      def sms(phone_number,
-              use_case_code=nil,
-              extra=nil,
-              timeout=nil)
-
-        params = {:phone_number => phone_number}
-
-        unless use_case_code.nil?
-          params[:use_case_code] = use_case_code
-        end
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Post,
-                "/v1/verify/sms",
-                nil,
-                params,
-                timeout)
-      end
-
-      # Calls the specified phone number, and using speech synthesis, speaks the
-      # verification code to the user.
-      def call(phone_number,
-               use_case_code=nil,
-               extra=nil,
-               timeout=nil)
-
-        params = {:phone_number => phone_number}
-
-        unless use_case_code.nil?
-          params[:use_case_code] = use_case_code
-        end
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Post,
-                "/v1/verify/call",
-                nil,
-                params,
-                timeout)
-      end
-
-      # Calls the specified phone number, and using speech synthesis, speaks the
-      # verification code to the user.
-      def smart(phone_number,
-                use_case_code,
-                extra=nil,
-                timeout=nil)
-
-        params = {:phone_number => phone_number,
-                  :ucid => use_case_code}
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Post,
-                "/v1/verify/smart",
-                nil,
-                params,
-                timeout)
-
-      end
-
-      # The **push** method sends a push notification containing the verification
-      # code to the specified phone number (supported for mobile phones only).
-      def push(phone_number,
-               use_case_code,
-               extra=nil,
-               timeout=nil)
-
-        params = {:phone_number => phone_number,
-                  :ucid => use_case_code}
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Post,
-                "/v2/verify/push",
-                nil,
-                params,
-                timeout)
-
-      end
-
-      # Retrieves the verification result. You make this call in your web application
-      # after users complete the authentication transaction (using either a call or sms).
-      def status(reference_id,
-                 verify_code=nil,
-                 extra=nil,
-                 timeout=nil)
-
-        params = {}
-
-        unless verify_code.nil?
-          params[:verify_code] = verify_code
-        end
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Get,
-                "/v1/verify/#{reference_id}",
-                params,
-                nil,
-                timeout)
-      end
-    end
-
-
-    # The **Telebureau** class exposes services for creating, retrieving, updating and
-    # deleting telebureau fraud events. You can use this mechanism to simply test whether
-    # you can reach telebureau services.
-    class TeleBureau < Telesign::API::Rest
-
-      def initialize(customer_id,
-                     secret_key,
-                     ssl=true,
-                     api_host='rest.telesign.com',
-                     timeout=nil)
-
-        super(customer_id,
-              secret_key,
-              ssl,
-              api_host,
-              timeout)
-      end
-
-      # Creates a telebureau event corresponding to supplied data.
-      def create(phone_number,
-                 fraud_type,
-                 occurred_at,
-                 extra=nil,
-                 timeout=nil)
-
-        params = {:phone_number => phone_number,
-                  :fraud_type => fraud_type,
-                  :occurred_at => occurred_at}
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Post,
-                "/v1/telebureau/event",
-                nil,
-                params,
-                timeout)
-      end
-
-      # Retrieves the fraud event status. You make this call in your web application after
-      # completion of create transaction for a telebureau event.
-      def retrieve(reference_id,
-                   extra=nil,
-                   timeout=nil)
-
-        params = {}
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Get,
-                "/v1/telebureau/event/#{reference_id}",
-                params,
-                nil,
-                timeout)
-      end
-
-      # Deletes a previously submitted fraud event. You make this call in your web application
-      # after completion of the create transaction for a telebureau event.
-      def delete(reference_id,
-                 extra=nil,
-                 timeout=nil)
-
-        params = {}
-
-        unless extra.nil?
-          params.merge!(extra)
-        end
-
-        execute(Net::HTTP::Delete,
-                "/v1/telebureau/event/#{reference_id}",
-                params,
-                nil,
-                timeout)
-      end
-    end
-  end
-end
+require 'telesign/score'
+require 'telesign/util'
+require 'telesign/voice'

data/lib/telesign/autoverify.rb

@@ -0,0 +1,23 @@
+require 'telesign/rest'
+
+AUTOVERIFY_STATUS_RESOURCE = '/v1/mobile/verification/status/%{external_id}'
+
+module Telesign
+
+  # AutoVerify is a secure, lightweight SDK that integrates a frictionless user verification process into existing
+  # native mobile applications.
+  class AutoVerifyClient < RestClient
+
+    # Retrieves the verification result for an AutoVerify transaction by external_id. To ensure a secure verification
+    # flow you must check the status using TeleSign's servers on your backend. Do not rely on the SDK alone to
+    # indicate a successful verification.
+    #
+    # See https://developer.telesign.com/docs/auto-verify-sdk#section-obtaining-verification-status for detailed API
+    # documentation.
+    def status(external_id, **params)
+
+      self.get(AUTOVERIFY_STATUS_RESOURCE % {:external_id => external_id},
+               **params)
+    end
+  end
+end

data/lib/telesign/messaging.rb

@@ -0,0 +1,33 @@
+require 'telesign/rest'
+
+MESSAGING_RESOURCE = '/v1/messaging'
+MESSAGING_STATUS_RESOURCE = '/v1/messaging/%{reference_id}'
+
+module Telesign
+
+  # TeleSign's Messaging API allows you to easily send SMS messages. You can send alerts, reminders, and notifications,
+  # or you can send verification messages containing one-time passcodes (OTP).
+  class MessagingClient < RestClient
+
+    # Send a message to the target phone_number.
+    #
+    # See https://developer.telesign.com/v2.0/docs/messaging-api for detailed API documentation.
+    def message(phone_number, message, message_type, **params)
+
+      self.post(MESSAGING_RESOURCE,
+                phone_number: phone_number,
+                message: message,
+                message_type: message_type,
+                **params)
+    end
+
+    # Retrieves the current status of the message.
+    #
+    # See https://developer.telesign.com/v2.0/docs/messaging-api for detailed API documentation.
+    def status(reference_id, **params)
+
+      self.get(MESSAGING_STATUS_RESOURCE % {:reference_id => reference_id},
+               **params)
+    end
+  end
+end

data/lib/telesign/phoneid.rb

@@ -0,0 +1,21 @@
+require 'telesign/rest'
+
+PHONEID_RESOURCE = '/v1/phoneid/%{phone_number}'
+
+module Telesign
+
+  # A set of APIs that deliver deep phone number data attributes that help optimize the end user
+  # verification process and evaluate risk.
+  class PhoneIdClient < RestClient
+
+    # The PhoneID API provides a cleansed phone number, phone type, and telecom carrier information to determine the
+    # best communication method - SMS or voice.
+    #
+    # See https://developer.telesign.com/docs/phoneid-api for detailed API documentation.
+    def phoneid(phone_number, **params)
+
+      self.post(PHONEID_RESOURCE % {:phone_number => phone_number},
+                **params)
+    end
+  end
+end

data/lib/telesign/rest.rb

@@ -1,181 +1,222 @@
-#
-# Copyright (c) 2016 TeleSign
-#
-# TeleSign Ruby SDK HMAC REST Auth.
-#
-
 require 'pp'
 require 'json'
 require 'time'
 require 'base64'
 require 'openssl'
-require 'net/http'
+require 'securerandom'
+require 'net/http/persistent'
 
 module Telesign
+  SDK_VERSION = '2.0.0'
+
+  # The TeleSign RestClient is a generic HTTP REST client that can be extended to make requests against any of
+  # TeleSign's REST API endpoints.
+  #
+  # RequestEncodingMixin offers the function _encode_params for url encoding the body for use in string_to_sign outside
+  # of a regular HTTP request.
+  #
+  # See https://developer.telesign.com for detailed API documentation.
+  class RestClient
+
+    @user_agent = "TeleSignSDK/ruby-{#{SDK_VERSION} #{RUBY_DESCRIPTION} net/http/persistent"
+
+    # A simple HTTP Response object to abstract the underlying net/http library response.
+
+    # * +http_response+ - A net/http response object.
+    class Response
+
+      attr_accessor :status_code, :headers, :body, :ok, :json
+
+      def initialize(http_response)
+        @status_code = http_response.code
+        @headers = http_response.to_hash
+        @body = http_response.body
+        @ok = http_response.kind_of? Net::HTTPSuccess
+
+        begin
+          @json = JSON.parse(http_response.body)
+        rescue JSON::JSONError
+          @json = nil
+        end
+      end
+    end
 
-  module API
+    # TeleSign RestClient, useful for making generic RESTful requests against the API.
+    #
+    # * +customer_id+ - Your customer_id string associated with your account.
+    # * +secret_key+ - Your secret_key string associated with your account.
+    # * +api_host+ - (optional) Override the default api_host to target another endpoint string.
+    # * +timeout+ - (optional) How long to wait for the server to send data before giving up, as a float.
+    def initialize(customer_id,
+                   secret_key,
+                   api_host: 'https://rest-api.telesign.com',
+                   proxy: nil,
+                   timeout: 10)
+
+      @customer_id = customer_id
+      @secret_key = secret_key
+      @api_host = api_host
+
+      @http = Net::HTTP::Persistent.new(name: 'telesign', proxy: proxy)
+
+      unless timeout.nil?
+        @http.open_timeout = timeout
+        @http.read_timeout = timeout
+      end
+    end
 
-    # == TeleSign Ruby SDK REST API Helper
+    # Generates the TeleSign REST API headers used to authenticate requests.
     #
-    # Telesign::API::Rest provides helper classes and functions
-    # to handle the HMAC REST authentication.
+    # Creates the canonicalized string_to_sign and generates the HMAC signature. This is used to authenticate requests
+    # against the TeleSign REST API.
     #
-    # You can use these helper functions directly or via the Telesign::API::PhoneId
-    # and Telesign::API::Verify classes. Please see the TeleSign REST API docs at
-    # http://docs.telesign.com/rest/index.html for implementation details.
+    # See https://developer.telesign.com/docs/authentication-1 for detailed API documentation.
     #
-    class Rest
-
-      # Creates a new Telesign::API::Rest object with the specified credentials
-      # and HTTP configuration.
-      # The +api_host+ should be a DNS hostname or IP address.
-      def initialize(customer_id,
-                     secret_key,
-                     ssl,
-                     api_host,
-                     timeout=nil)
-
-        @customer_id = customer_id
-        @secret_key = secret_key
-        @ssl = ssl
-        @base_uri = URI("http#{ssl ? 's' : ''}://#{api_host}")
-        @timeout = timeout
-        @user_agent = 'Net::HTTP TeleSignSDK/ruby-1.0.0'
+    # * +customer_id+ - Your account customer_id.
+    # * +secret_key+ - Your account secret_key.
+    # * +method_name+ - The HTTP method name of the request as a upper case string, should be one of 'POST', 'GET',
+    #   'PUT' or 'DELETE'.
+    # * +resource+ - The partial resource URI to perform the request against, as a string.
+    # * +url_encoded_fields+ - HTTP body parameters to perform the HTTP request with, must be a urlencoded string.
+    # * +date_rfc2616+ - The date and time of the request formatted in rfc 2616, as a string.
+    # * +nonce+ - A unique cryptographic nonce for the request, as a string.
+    # * +user_agent+ - (optional) User Agent associated with the request, as a string.
+    def self.generate_telesign_headers(customer_id,
+                                       secret_key,
+                                       method_name,
+                                       resource,
+                                       url_encoded_fields,
+                                       date_rfc2616: nil,
+                                       nonce: nil,
+                                       user_agent: nil)
+
+      if date_rfc2616.nil?
+        date_rfc2616 = Time.now.httpdate
       end
 
-      # Executes the REST API request based on the given configuration.
-      # See Telesign::API::PhoneId and Telesign::API::Verify for specific
-      # usage.
-      def execute(verb,
-                  resource,
-                  params=nil,
-                  form_data=nil,
-                  timeout=nil)
-
-        # generate the headers
-        headers = generate_auth_headers(
-            @customer_id,
-            @secret_key,
-            resource,
-            verb,
-            form_data.nil? ? nil : URI.encode_www_form(form_data))
-
-        uri = URI.join(@base_uri, resource)
-
-        # set query params
-        uri.query = URI.encode_www_form(params) unless params.nil?
-
-        # configure HTTP object
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = @ssl
-
-        http.open_timeout = timeout.nil? ? @timeout : timeout
-        http.read_timeout = http.open_timeout
-        http.ssl_timeout = http.open_timeout
-        http.continue_timeout = http.open_timeout
-
-        #set headers
-        request = verb.new uri.request_uri
-        headers.each do |k, v|
-          request[k] = v
-        end
+      if nonce.nil?
+        nonce = SecureRandom.uuid
+      end
 
-        # set post data
-        request.set_form_data(form_data) unless form_data.nil?
+      content_type = (%w[POST PUT].include? method_name) ? 'application/x-www-form-urlencoded' : ''
 
-        # do the request
-        http_response = http.request(request)
+      auth_method = 'HMAC-SHA256'
 
-        # check response
-        unless http_response.is_a? Net::HTTPSuccess
-          if http_response.is_a? Net::HTTPUnauthorized
-            raise Telesign::API::AuthError.new(http_response)
-          else
-            raise Telesign::API::APIError.new(http_response)
-          end
-        end
+      string_to_sign = "#{method_name}"
 
-        Telesign::API::APIResponse.new(http_response)
-      end
+      string_to_sign << "\n#{content_type}"
 
-      # Function to generate the REST API authentication headers. A signature is
-      # computed based on the contents of the request and the client's secret key.
-      def generate_auth_headers (customer_id,
-                                 secret_key,
-                                 resource,
-                                 verb,
-                                 form_data=nil,
-                                 content_type='')
+      string_to_sign << "\n#{date_rfc2616}"
 
-        datetime_stamp = Time.now.utc.to_datetime.rfc822
-        nonce = rand.to_s
+      string_to_sign << "\nx-ts-auth-method:#{auth_method}"
+
+      string_to_sign << "\nx-ts-nonce:#{nonce}"
+
+      if !content_type.empty? and !url_encoded_fields.empty?
+        string_to_sign << "\n#{url_encoded_fields}"
+      end
 
-        content_type = 'application/x-www-form-urlencoded' if verb == Net::HTTP::Post or verb == Net::HTTP::Put
+      string_to_sign << "\n#{resource}"
 
-        string_to_sign = "#{verb.name.split('::').last.upcase}\n" +
-            "#{content_type}\n\n" +
-            "x-ts-auth-method:#{'HMAC-SHA256'}\n" +
-            "x-ts-date:#{datetime_stamp}\n" +
-            "x-ts-nonce:#{nonce}"
+      digest = OpenSSL::Digest.new('sha256')
+      key = Base64.decode64(secret_key)
 
-        string_to_sign = "#{string_to_sign}\n#{form_data}" unless form_data.nil?
+      signature = Base64.encode64(OpenSSL::HMAC.digest(digest, key, string_to_sign)).strip
 
-        string_to_sign = string_to_sign + "\n#{resource}"
+      authorization = "TSA #{customer_id}:#{signature}"
 
-        signature = Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'),
-                                                         Base64.decode64(secret_key), string_to_sign)).chomp
+      headers = {
+          'Authorization': authorization,
+          'Date': date_rfc2616,
+          'x-ts-auth-method': auth_method,
+          'x-ts-nonce': nonce
+      }
 
-        {
-            'Authorization' => "TSA #{customer_id}:#{signature}",
-            'x-ts-date' => datetime_stamp,
-            'x-ts-auth-method' => 'HMAC-SHA256',
-            'x-ts-nonce' => nonce,
-            'User-Agent' => @user_agent
-        }
+      unless user_agent.nil?
+        headers['User-Agent'] = user_agent
       end
+
+      headers
+
     end
 
-    class APIResponse
+    # Generic TeleSign REST API POST handler.
+    #
+    # * +resource+ - The partial resource URI to perform the request against, as a string.
+    # * +params+ - Body params to perform the POST request with, as a hash.
+    def post(resource, **params)
 
-      attr_accessor :body, :headers, :status, :verify_code
+      execute(Net::HTTP::Post, 'POST', resource, **params)
 
-      def initialize(http_response,
-                     verify_code=nil)
+    end
+
+    # Generic TeleSign REST API GET handler.
+    #
+    # * +resource+ - The partial resource URI to perform the request against, as a string.
+    # * +params+ - Body params to perform the GET request with, as a hash.
+    def get(resource, **params)
+
+      execute(Net::HTTP::Get, 'GET', resource, **params)
 
-        @body = JSON.parse(http_response.body)
-        @headers = http_response.to_hash
-        @status = http_response.code
-        @verify_code = verify_code
-      end
     end
 
-    class APIError < StandardError
+    # Generic TeleSign REST API PUT handler.
+    #
+    # * +resource+ - The partial resource URI to perform the request against, as a string.
+    # * +params+ - Body params to perform the PUT request with, as a hash.
+    def put(resource, **params)
 
-      attr_accessor :errors, :headers, :status, :body
+      execute(Net::HTTP::Put, 'PUT', resource, **params)
 
-      def initialize(http_response)
+    end
 
-        @errors = JSON.parse(http_response.body)['errors']
-        @headers = http_response.to_hash
-        @status = http_response.code
-        @body = http_response.body
-      end
+    # Generic TeleSign REST API DELETE handler.
+    #
+    # * +resource+ - The partial resource URI to perform the request against, as a string.
+    # * +params+ - Body params to perform the DELETE request with, as a hash.
+    def delete(resource, **params)
 
-      def to_s
-        result = ''
-        @errors.each do |error|
-          result = "#{result}#{error['description']}\n"
-        end
+      execute(Net::HTTP::Delete, 'DELETE', resource, **params)
 
-        result
-      end
     end
 
-    class AuthError < Telesign::API::APIError
+    private
+    # Generic TeleSign REST API request handler.
+    #
+    # * +method_function+ - The net/http request to perform the request.
+    # * +method_name+ - The HTTP method name, as an upper case string.
+    # * +resource+ - The partial resource URI to perform the request against, as a string.
+    # * +params+ - Body params to perform the HTTP request with, as a hash.
+    def execute(method_function, method_name, resource, **params)
+
+      resource_uri = URI.parse("#{@api_host}#{resource}")
+
+      url_encoded_fields = URI.encode_www_form(params)
+
+      headers = RestClient.generate_telesign_headers(@customer_id,
+                                                     @secret_key,
+                                                     method_name,
+                                                     resource,
+                                                     url_encoded_fields,
+                                                     user_agent: @user_agent)
+
+      request = method_function.new(resource_uri.request_uri)
+
+      unless params.empty?
+        if %w[POST PUT].include? method_name
+          request.set_form_data(params)
+        else
+          resource_uri.query = url_encoded_fields
+        end
+      end
 
-      def initialize(http_response)
-        super(http_response)
+      headers.each do |k, v|
+        request[k] = v
       end
+
+      http_response = @http.request(resource_uri, request)
+
+      Response.new(http_response)
     end
   end
-end
+end

data/lib/telesign/score.rb

@@ -0,0 +1,21 @@
+require 'telesign/rest'
+
+SCORE_RESOURCE = '/v1/score/%{phone_number}'
+
+module Telesign
+
+  # Score provides risk information about a specified phone number.
+  class ScoreClient < RestClient
+
+    # Score is an API that delivers reputation scoring based on phone number intelligence, traffic patterns, machine
+    # learning, and a global data consortium.
+    #
+    # See https://developer.telesign.com/docs/rest_api-phoneid-score for detailed API documentation.
+    def score(phone_number, account_lifecycle_event, **params)
+
+      self.post(SCORE_RESOURCE % {:phone_number => phone_number},
+                account_lifecycle_event: account_lifecycle_event,
+                **params)
+    end
+  end
+end

data/lib/telesign/util.rb

@@ -0,0 +1,39 @@
+require 'base64'
+require 'openssl'
+require 'securerandom'
+
+module Telesign
+  class Util
+
+    def self.random_with_n_digits(n)
+      n.times.map { SecureRandom.random_number(10) }.join
+    end
+
+    # Verify that a callback was made by TeleSign and was not sent by a malicious client by verifying the signature.
+    #
+    # * +secret_key+ - the TeleSign API secret_key associated with your account.
+    # * +signature+ - the TeleSign Authorization header value supplied in the callback, as a string.
+    # * +json_str+ - the POST body text, that is, the JSON string sent by TeleSign describing the transaction status.
+    def verify_telesign_callback_signature(secret_key, signature, json_str)
+
+      digest = OpenSSL::Digest.new('sha256')
+      key = Base64.decode64(secret_key)
+
+      your_signature = Base64.encode64(OpenSSL::HMAC.digest(digest, key, json_str)).strip
+
+      unless signature.length == your_signature.length
+        return false
+      end
+
+      # avoid timing attack with constant time equality check
+      signatures_equal = true
+      signature.split('').zip(your_signature.split('')).each do |x, y|
+        unless x == y
+          signatures_equal = false
+        end
+      end
+
+      signatures_equal
+    end
+  end
+end

data/lib/telesign/voice.rb

@@ -0,0 +1,33 @@
+require 'telesign/rest'
+
+VOICE_RESOURCE = '/v1/voice'
+VOICE_STATUS_RESOURCE = '/v1/voice/%{reference_id}'
+
+module Telesign
+
+  # TeleSign's Voice API allows you to easily send voice messages. You can send alerts, reminders, and notifications,
+  # or you can send verification messages containing time-based, one-time passcodes (TOTP).
+  class VoiceClient < RestClient
+
+    # Send a voice call to the target phone_number.
+    #
+    # See https://developer.telesign.com/docs/voice-api for detailed API documentation.
+    def call(phone_number, message, message_type, **params)
+
+      self.post(VOICE_RESOURCE,
+                phone_number: phone_number,
+                message: message,
+                message_type: message_type,
+                **params)
+    end
+
+    # Retrieves the current status of the voice call.
+    #
+    # See https://developer.telesign.com/docs/voice-api for detailed API documentation.
+    def status(reference_id, **params)
+
+      self.get(VOICE_STATUS_RESOURCE % {:reference_id => reference_id},
+               **params)
+    end
+  end
+end

metadata

@@ -1,23 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: telesign
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.0
 platform: ruby
 authors:
-- Jarrad Lee
+- TeleSign
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-22 00:00:00.000000000 Z
-dependencies: []
+date: 2017-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 description: TeleSign Ruby SDK
-email: jarrad@telesign.com
+email: support@telesign.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/telesign.rb
+- lib/telesign/autoverify.rb
+- lib/telesign/messaging.rb
+- lib/telesign/phoneid.rb
 - lib/telesign/rest.rb
+- lib/telesign/score.rb
+- lib/telesign/util.rb
+- lib/telesign/voice.rb
 homepage: http://rubygems.org/gems/telesign
 licenses:
 - MIT