nexmo 4.8.0 → 5.0.0.pre1

data/lib/nexmo/conversions.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Nexmo
+  class Conversions < Namespace
+    include Keys
+
+    def track_sms(params)
+      request('/conversions/sms', params: hyphenate(params), type: Post)
+    end
+
+    def track_voice(params)
+      request('/conversions/voice', params: hyphenate(params), type: Post)
+    end
+  end
+end

data/lib/nexmo/entity.rb

@@ -0,0 +1,53 @@
+module Nexmo
+  class Entity
+    def initialize(**kwargs)
+      @attributes = kwargs
+    end
+
+    def []=(key, value)
+      name = self.class.attribute_names[key]
+
+      @attributes[name] = value
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @attributes.key?(name) or super
+    end
+
+    def method_missing(name, *args)
+      return super unless @attributes.key?(name)
+
+      @attributes[name]
+    end
+
+    def ==(entity)
+      entity.class == self.class && entity.attributes == @attributes
+    end
+
+    def to_h
+      @attributes
+    end
+
+    attr_reader :attributes
+
+    protected :attributes
+
+    private
+
+    def self.attribute_names
+      @attribute_names ||= Hash.new do |hash, key|
+        hash[key] = attribute_name(key)
+      end
+    end
+
+    def self.attribute_name(key)
+      return key if key.is_a?(Symbol)
+
+      key.split(PATTERN).join(UNDERSCORE).downcase.to_sym
+    end
+
+    PATTERN = /[\-_]|(?<=\w)(?=[A-Z])/
+
+    UNDERSCORE = '_'
+  end
+end

data/lib/nexmo/files.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Nexmo
+  class Files < Namespace
+    def get(id)
+      request('/v1/files/' + id.split('/').last)
+    end
+
+    def save(id, filename)
+      request('/v1/files/' + id.split('/').last) do |response|
+        File.open(filename, 'wb') do |file|
+          response.read_body do |chunk|
+            file.write(chunk)
+          end
+        end
+      end
+    end
+
+    private
+
+    def authorization_header?
+      true
+    end
+  end
+end

data/lib/nexmo/jwt.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 require 'securerandom'
 require 'openssl'
 require 'jwt'
 
 module Nexmo
   module JWT
-    def self.auth_token(payload, private_key)
+    def self.generate(payload, private_key)
       payload[:iat] = iat = Time.now.to_i unless payload.key?(:iat) || payload.key?('iat')
       payload[:exp] = iat + 60 unless payload.key?(:exp) || payload.key?('exp')
       payload[:jti] = SecureRandom.uuid unless payload.key?(:jti) || payload.key?('jti')

data/lib/nexmo/keys.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Nexmo
+  module Keys
+    if {}.respond_to?(:transform_keys)
+      def hyphenate(hash)
+        hash.transform_keys { |k| hyphenate_key(k) }
+      end
+
+      def camelcase(hash)
+        hash.transform_keys { |k| camelcase_key(k) }
+      end
+    else
+      def hyphenate(hash)
+        hash.each_with_object({}) { |(k, v), h| h[hyphenate_key(k)] = v }
+      end
+
+      def camelcase(hash)
+        hash.each_with_object({}) { |(k, v), h| h[camelcase_key(k)] = v }
+      end
+    end
+
+    def hyphenate_key(k)
+      k.to_s.tr('_', '-')
+    end
+
+    def camelcase_key(k)
+      k.to_s.gsub(/_(\w)/) { $1.upcase }
+    end
+  end
+end

data/lib/nexmo/messages.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Nexmo
+  class Messages < Namespace
+    def get(id)
+      request('/search/message', params: {id: id})
+    end
+
+    def search(params)
+      request('/search/messages', params: params)
+    end
+
+    def rejections(params)
+      request('/search/rejections', params: params)
+    end
+
+    private
+
+    def host
+      'rest.nexmo.com'
+    end
+  end
+end

data/lib/nexmo/namespace.rb

@@ -0,0 +1,83 @@
+require 'net/http'
+require 'json'
+
+module Nexmo
+  class Namespace
+    def initialize(client)
+      @client = client
+    end
+
+    private
+
+    Get = Net::HTTP::Get
+    Put = Net::HTTP::Put
+    Post = Net::HTTP::Post
+    Delete = Net::HTTP::Delete
+
+    def host
+      'api.nexmo.com'
+    end
+
+    def authorization_header?
+      false
+    end
+
+    def request(path, params: nil, type: Get, &block)
+      uri = URI('https://' + host + path)
+
+      unless authorization_header?
+        params ||= {}
+        params[:api_key] = @client.api_key
+        params[:api_secret] = @client.api_secret
+      end
+
+      unless type::REQUEST_HAS_BODY || params.nil? || params.empty?
+        uri.query = Params.encode(params)
+      end
+
+      message = type.new(uri.request_uri)
+
+      if type::REQUEST_HAS_BODY
+        message['Content-Type'] = 'application/json'
+        message.body = JSON.generate(params)
+      end
+
+      message['Authorization'] = @client.authorization if authorization_header?
+      message['User-Agent'] = @client.user_agent
+
+      http = Net::HTTP.new(uri.host, Net::HTTP.https_default_port)
+      http.use_ssl = true
+
+      response = http.request(message)
+
+      parse(response, &block)
+    end
+
+    def parse(response, &block)
+      case response
+      when Net::HTTPNoContent
+        :no_content
+      when Net::HTTPSuccess
+        parse_success(response, &block)
+      when Net::HTTPUnauthorized
+        raise AuthenticationError, "#{response.code} response from #{host}"
+      when Net::HTTPClientError
+        raise ClientError, "#{response.code} response from #{host}"
+      when Net::HTTPServerError
+        raise ServerError, "#{response.code} response from #{host}"
+      else
+        raise Error, "#{response.code} response from #{host}"
+      end
+    end
+
+    def parse_success(response)
+      if response['Content-Type'].split(';').first == 'application/json'
+        JSON.parse(response.body, object_class: Nexmo::Entity)
+      elsif block_given?
+        yield response
+      else
+        response.body
+      end
+    end
+  end
+end

data/lib/nexmo/number_insight.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Nexmo
+  class NumberInsight < Namespace
+    def basic(params)
+      request('/ni/basic/json', params: params)
+    end
+
+    def standard(params)
+      request('/ni/standard/json', params: params)
+    end
+
+    def advanced(params)
+      request('/ni/advanced/json', params: params)
+    end
+
+    def advanced_async(params)
+      request('/ni/advanced/async/json', params: params)
+    end
+  end
+end

data/lib/nexmo/numbers.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Nexmo
+  class Numbers < Namespace
+    include Keys
+
+    def list(params)
+      request('/account/numbers', params: params)
+    end
+
+    def search(params)
+      request('/number/search', params: params)
+    end
+
+    def buy(params)
+      request('/number/buy', params: params, type: Post)
+    end
+
+    def cancel(params)
+      request('/number/cancel', params: params, type: Post)
+    end
+
+    def update(params)
+      request('/number/update', params: camelcase(params), type: Post)
+    end
+
+    private
+
+    def host
+      'rest.nexmo.com'
+    end
+  end
+end

data/lib/nexmo/pricing.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Nexmo
+  class Pricing < Namespace
+    def initialize(client, type: nil)
+      raise ArgumentError if type.nil?
+
+      @client, @type = client, type
+    end
+
+    attr_reader :type
+
+    def get(country)
+      request('/get-pricing/outbound/' + @type, params: {country: country})
+    end
+
+    def list
+      request('/get-full-pricing/outbound/' + @type)
+    end
+
+    def prefix(prefix)
+      request('/get-prefix-pricing/outbound/' + @type, params: {prefix: prefix})
+    end
+
+    private
+
+    def host
+      'rest.nexmo.com'
+    end
+  end
+end

data/lib/nexmo/pricing_types.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Nexmo
+  class PricingTypes
+    def initialize(client)
+      @client = client
+    end
+
+    def sms
+      @sms ||= Pricing.new(@client, type: 'sms')
+    end
+
+    def voice
+      @voice ||= Pricing.new(@client, type: 'voice')
+    end
+  end
+end

data/lib/nexmo/signature.rb

@@ -2,7 +2,7 @@ require 'digest/md5'
 require 'jwt'
 
 module Nexmo
-  module Signature
+  class Signature
     def self.check(params, secret)
       params = params.dup
 
@@ -11,6 +11,14 @@ module Nexmo
       secure_compare(signature, digest(params, secret))
     end
 
+    def initialize(client)
+      @client = client
+    end
+
+    def check(params)
+      self.class.check(params, @client.signature_secret)
+    end
+
     private
 
     if defined?(::JWT::SecurityUtils) # ruby-jwt v2

data/lib/nexmo/sms.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Nexmo
+  class SMS < Namespace
+    include Keys
+
+    def send(params)
+      request('/sms/json', params: hyphenate(params), type: Post)
+    end
+
+    private
+
+    def host
+      'rest.nexmo.com'
+    end
+  end
+end

data/lib/nexmo/user_agent.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Nexmo
+  module UserAgent
+    def self.string(app_name, app_version)
+      identifiers = []
+      identifiers << 'nexmo-ruby/' + VERSION
+      identifiers << 'ruby/' + RUBY_VERSION
+      identifiers << app_name + '/' + app_version if app_name && app_version
+      identifiers.join(' ')
+    end
+  end
+end

data/lib/nexmo/verify.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Nexmo
+  class Verify < Namespace
+    alias_method :http_request, :request
+
+    def request(params)
+      http_request('/verify/json', params: params, type: Post)
+    end
+
+    def check(params)
+      http_request('/verify/check/json', params: params, type: Post)
+    end
+
+    def search(params)
+      http_request('/verify/search/json', params: params)
+    end
+
+    def control(params)
+      http_request('/verify/control/json', params: params, type: Post)
+    end
+
+    def cancel(id)
+      control(request_id: id, cmd: 'cancel')
+    end
+
+    def trigger_next_event(id)
+      control(request_id: id, cmd: 'trigger_next_event')
+    end
+  end
+end