vonage 7.2.0

data/lib/vonage/conversions.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Vonage
+  class Conversions < Namespace
+    extend T::Sig
+    include Keys
+
+    sig { params(params: T::Hash[Symbol, T.untyped]).returns(Vonage::Response) }
+    def track_sms(params)
+      request('/conversions/sms', params: hyphenate(params), type: Post)
+    end
+
+    sig { params(params: T::Hash[Symbol, T.untyped]).returns(Vonage::Response) }
+    def track_voice(params)
+      request('/conversions/voice', params: hyphenate(params), type: Post)
+    end
+  end
+end

data/lib/vonage/entity.rb

@@ -0,0 +1,51 @@
+# typed: true
+
+module Vonage
+  class Entity
+    include Keys
+
+    def initialize(attributes = nil)
+      @attributes = attributes || {}
+    end
+
+    def [](key)
+      @attributes[attribute_key(key)]
+    end
+
+    def []=(key, value)
+      @attributes[attribute_key(key)] = 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
+
+    def each_pair(&block)
+      return to_enum(:each_pair) unless block
+
+      @attributes.each_pair(&block)
+    end
+
+    alias_method :each, :each_pair
+
+    include Enumerable
+  end
+end

data/lib/vonage/error.rb

@@ -0,0 +1,6 @@
+# typed: strong
+
+module Vonage
+  class Error < StandardError
+  end
+end

data/lib/vonage/errors.rb

@@ -0,0 +1,51 @@
+# typed: strict
+# frozen_string_literal: true
+require 'json'
+
+module Vonage
+  module Errors
+    extend T::Sig
+
+    sig {params(response: T.any(Net::HTTPUnauthorized, Net::HTTPClientError, Net::HTTPServerError, T.untyped)).returns(Vonage::Error)}
+    def self.parse(response)
+      exception_class = case response
+        when Net::HTTPUnauthorized
+          AuthenticationError
+        when Net::HTTPClientError
+          ClientError
+        when Net::HTTPServerError
+          ServerError
+        else
+          Error
+        end
+
+      message = if response.content_type == 'application/json'
+        hash = ::JSON.parse(response.body)
+
+        if hash.key?('error_title')
+          hash['error_title']
+        elsif hash.key?('error-code-label')
+          hash['error-code-label']
+        elsif hash.key?('description')
+          hash['description']
+        elsif problem_details?(hash)
+          problem_details_message(hash)
+        end
+      end
+
+      exception_class.new(message)
+    end
+
+    sig { params(hash: T::Hash[String, T.untyped]).returns(T::Boolean) }
+    def self.problem_details?(hash)
+      hash.key?('title') && hash.key?('detail') && hash.key?('type')
+    end
+
+    sig { params(hash: T::Hash[String, T.untyped]).returns(String) }
+    def self.problem_details_message(hash)
+      "#{hash['title']}. #{hash['detail']} See #{hash['type']} for more info, or email support@nexmo.com if you have any questions."
+    end
+  end
+
+  private_constant :Errors
+end

data/lib/vonage/files.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Vonage
+  class Files < Namespace
+    extend T::Sig
+
+    self.authentication = BearerToken
+
+    sig { params(id: String).returns(T.nilable(Vonage::Response)) }
+    def get(id)
+      request('/v1/files/' + T.must(id.split('/').last))
+    end
+
+    sig { params(id: String, filename: String).returns(T.nilable(Vonage::Response)) }
+    def save(id, filename)
+      request('/v1/files/' + T.must(id.split('/').last)) do |response|
+        File.open(filename, 'wb') do |file|
+          response.read_body do |chunk|
+            file.write(chunk)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vonage/form_data.rb

@@ -0,0 +1,11 @@
+# typed: ignore
+
+module Vonage
+  module FormData
+    def self.update(http_request, params)
+      http_request.form_data = params
+    end
+  end
+
+  private_constant :FormData
+end

data/lib/vonage/gsm7.rb

@@ -0,0 +1,13 @@
+# typed: ignore
+
+module Vonage
+  module GSM7
+    CHARACTERS = "\n\f\r !\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_abcdefghijklmnopqrstuvwxyz{|}~ ¡£¤¥§¿ÄÅÆÉÑÖØÜßàäåæçèéìñòöøùüΓΔΘΛΞΠΣΦΨΩ€"
+
+    REGEXP = /\A[#{Regexp.escape(CHARACTERS)}]*\z/
+
+    def self.encoded?(string)
+      REGEXP =~ string
+    end
+  end
+end

data/lib/vonage/http.rb

@@ -0,0 +1,43 @@
+# typed: strict
+# frozen_string_literal: true
+require 'net/http'
+
+module Vonage
+  module HTTP
+    class Options
+      extend T::Sig
+
+      sig { params(hash: T::Hash[Symbol, T.untyped]).void }
+      def initialize(hash)
+        raise ArgumentError, 'hash parameter cannot be empty or nil' if hash == {} || hash.nil?
+
+        @hash = T.let(@hash, T::Hash[Symbol, T.untyped]) if defined? @hash
+        @hash = hash
+
+        @hash.each_key do |name|
+          next if defined_options.key?(name)
+
+          raise ArgumentError, "#{name.inspect} is not a valid option"
+        end
+      end
+
+      sig { params(http: Net::HTTP).returns(T::Hash[Symbol, T.untyped]) }
+      def set(http)
+        @hash.each do |name, value|
+          http.public_send(defined_options.fetch(name), value)
+        end
+      end
+
+      private
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def defined_options
+        @defined_options = T.let(@defined_options, T.nilable(T::Hash[Symbol, T.untyped]))
+
+        @defined_options ||= Net::HTTP.instance_methods.grep(/\w=\z/).each_with_object({}) do |name, hash|
+          hash[name.to_s.chomp('=').to_sym] = name
+        end
+      end
+    end
+  end
+end

data/lib/vonage/json.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+require 'json'
+
+module Vonage
+  module JSON
+    extend T::Sig
+
+    sig { params(http_request: T.any(Net::HTTP::Put, Net::HTTP::Post), params: T::Hash[Symbol, T.untyped]).void }
+    def self.update(http_request, params)
+      http_request['Content-Type'] = 'application/json'
+      http_request.body = ::JSON.generate(params)
+    end
+  end
+
+  private_constant :JSON
+end

data/lib/vonage/jwt.rb

@@ -0,0 +1,43 @@
+# typed: false
+# frozen_string_literal: true
+require 'securerandom'
+require 'openssl'
+require 'nexmo-jwt'
+
+module Vonage
+  class JWT
+    # Generate an encoded JSON Web Token.
+    #
+    # By default the Vonage Ruby SDK generates a short lived JWT per request.
+    #
+    # To generate a long lived JWT for multiple requests or to specify JWT claims
+    # directly call {Vonage::JWT.generate} to generate a token, and set the token
+    # attribute on the client object.
+    #
+    # Documentation for the Vonage Ruby JWT generator gem can be found at
+    # https://www.rubydoc.info/github/Nexmo/nexmo-jwt-ruby
+    #
+    # @example
+    #   claims = {
+    #     application_id: application_id,
+    #     ttl: 800,
+    #     subject: 'My_Subject'
+    #   }
+    #
+    #   private_key = File.read('path/to/private.key')
+    #
+    #   client.config.token = Vonage::JWT.generate(claims, private_key)
+    #
+    # @param [Hash] payload
+    # @param [String, OpenSSL::PKey::RSA] private_key
+    #
+    # @return [String]
+    #
+    def self.generate(payload, private_key = nil)
+      raise "Expecting 'private_key' in either the payload or as a separate parameter" if !payload[:private_key] && !private_key
+
+      payload[:private_key] = private_key if private_key && !payload[:private_key]
+      @token = Nexmo::JWTBuilder.new(payload).jwt.generate
+    end
+  end
+end

data/lib/vonage/key_secret_params.rb

@@ -0,0 +1,20 @@
+# typed: strict
+
+module Vonage
+  class KeySecretParams < AbstractAuthentication
+    extend T::Sig
+
+    sig { params(
+      object: T.any(T::Hash[T.untyped, T.untyped], URI::HTTPS, Net::HTTP::Post, Net::HTTP::Get)
+    ).void }
+    def update(object)
+      return unless object.is_a?(Hash)
+
+      @config = T.let(@config, T.nilable(Vonage::Config))
+      object[:api_key] = T.must(@config).api_key
+      object[:api_secret] = T.must(@config).api_secret
+    end
+  end
+
+  private_constant :KeySecretParams
+end

data/lib/vonage/keys.rb

@@ -0,0 +1,51 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Vonage
+  module Keys
+    extend T::Sig
+
+    sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T::Hash[String, T.untyped]) }
+    def hyphenate(hash)
+      hash.transform_keys { |k| k.to_s.tr('_', '-') }
+    end
+
+    sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T::Hash[T.untyped, T.untyped]) }
+    def camelcase(hash)
+      exceptions = [
+        'dr_call_back_url',
+        'mo_http_url',
+        'mo_smpp_sys_type',
+        'mo_call_back_url',
+        'voice_callback_type',
+        'voice_callback_value',
+        'voice_status_callback',
+        'messages_callback_value',
+        'messages_callback_type'
+      ]
+      hash.transform_keys do |k|
+        if exceptions.include?(k.to_s)
+          next k.to_s.gsub(/_(\w)/) { $1.upcase.to_s }
+        end
+          k
+      end
+    end
+
+    ATTRIBUTE_KEYS = T.let(Hash.new { |h, k| h[k] = k.split(PATTERN).join('_').downcase.to_sym }, T::Hash[T.untyped, T.untyped])
+
+    PATTERN = /[\-_]|(?<=\w)(?=[A-Z])/
+
+    private_constant :ATTRIBUTE_KEYS
+
+    private_constant :PATTERN
+
+    sig { params(k: T.any(Symbol, String)).returns(Symbol) }
+    def attribute_key(k)
+      return k if k.is_a?(Symbol)
+
+      ATTRIBUTE_KEYS[k]
+    end
+  end
+
+  private_constant :Keys
+end

data/lib/vonage/logger.rb

@@ -0,0 +1,60 @@
+# typed: strict
+# frozen_string_literal: true
+require 'logger'
+require 'forwardable'
+
+module Vonage
+  class Logger
+    extend T::Sig
+
+    sig { params(logger: T.nilable(T.any(::Logger, Vonage::Logger))).void }
+    def initialize(logger)
+      @logger = logger || ::Logger.new(nil)
+    end
+
+    extend Forwardable
+
+    ::Logger::Severity.constants.map(&:downcase).each do |name|
+      def_delegator :@logger, name, name
+    end
+
+    sig { params(request: T.any(Net::HTTP::Post, Net::HTTP::Get, Net::HTTP::Delete, Net::HTTP::Put)).void }
+    def log_request_info(request)
+      @logger = T.let(@logger, T.nilable(T.any(::Logger, Vonage::Logger)))
+
+      T.must(@logger).info do
+        format('Vonage API request', {
+          method: request.method,
+          path: request.uri.path
+        })
+      end
+    end
+
+    sig { params(
+      response: T.any(Net::HTTPOK, Net::HTTPNoContent, Net::HTTPBadRequest, Net::HTTPInternalServerError, Net::HTTPResponse),
+      host: String
+    ).void }
+    def log_response_info(response, host)
+      T.must(@logger).info do
+        format('Vonage API response', {
+          host: host,
+          status: response.code,
+          type: response.content_type,
+          length: response.content_length,
+          trace_id: response['x-Vonage-trace-id']
+        })
+      end
+    end
+
+    private
+
+    sig { params(message: String, hash: T::Hash[Symbol, T.untyped]).returns(String) }
+    def format(message, hash)
+      return message if hash.nil?
+
+      fields = hash.map { |key, value| "#{key}=#{value}" if value }.compact
+      fields.unshift(message)
+      fields.join(' ')
+    end
+  end
+end

data/lib/vonage/messages.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Vonage
+  class Messages < Namespace
+    extend T::Sig
+
+    self.host = :rest_host
+
+    sig { params(id: String).returns(Vonage::Response) }
+    def get(id)
+      request('/search/message', params: {id: id})
+    end
+
+    sig { params(params: T::Hash[Symbol, T.untyped]).returns(Vonage::Response) }
+    def search(params)
+      request('/search/messages', params: params)
+    end
+
+    sig { params(params: T::Hash[Symbol, T.untyped]).returns(Vonage::Response) }
+    def rejections(params)
+      request('/search/rejections', params: params)
+    end
+  end
+end