plivo 0.3.19 → 4.0.0.beta.2

data/lib/plivo/base.rb

@@ -0,0 +1,9 @@
+require_relative 'base/resource_interface'
+require_relative 'base/resource'
+require_relative 'base/response'
+
+module Plivo
+  module Base
+    PLIVO_API_URL = 'https://api.plivo.com'.freeze
+  end
+end

data/lib/plivo/base/resource.rb

@@ -0,0 +1,85 @@
+module Plivo
+  module Base
+    class Resource
+      attr_reader :id
+      include Plivo::Utils
+
+      def initialize(client, options = nil)
+        configure_client(client)
+        configure_options(options) if options
+        configure_resource_uri
+      end
+
+      private
+
+      def configure_client(client)
+        valid_param?(:client, client, RestClient, true)
+        @_client = client
+      end
+
+      def configure_options(options)
+        valid_param?(:options, options, Hash, false)
+        @id = options[:resource_id] if options.key?(:resource_id)
+        parse_and_set(options[:resource_json]) if options.key?(:resource_json)
+      end
+
+      def configure_resource_uri
+        to_join = @id ? [@_client.auth_id, @_name, @id] : [@_client.auth_id, @_name]
+        to_join = ['', 'v1', 'Account'] << to_join
+
+        if @_name == 'Account'
+          @id = @_client.auth_id
+          to_join = ['', 'v1', 'Account', @id]
+        end
+
+        to_join << ''
+        @_resource_uri = to_join.join('/')
+      end
+
+      def parse_and_set(resource_json)
+        return unless resource_json
+
+        valid_param?(:resource_json, resource_json, Hash, true)
+
+        resource_json.each do |k, v|
+          instance_variable_set("@#{k}", v)
+          self.class.send(:attr_reader, k)
+        end
+
+        return unless @_identifier_string && (resource_json.key? @_identifier_string)
+        @id = resource_json[@_identifier_string]
+      end
+
+      def perform_update(params)
+        unless @id
+          raise_invalid_request("Cannot update a #{@_name} resource "\
+          'without an identifier')
+        end
+
+        response_json = @_client.send_request(@_resource_uri, 'POST', params)
+
+        parse_and_set(params)
+        parse_and_set(response_json)
+        self
+      end
+
+      def perform_action(action = nil, method = 'GET', params = nil, parse = false)
+        resource_path = action ? @_resource_uri + action + '/' : @_resource_uri
+        response = @_client.send_request(resource_path, method, params)
+        parse ? parse_and_set(response) : self
+        method == 'POST' ? parse_and_set(params) : self
+        self
+      end
+
+      def perform_delete
+        unless @id
+          raise_invalid_request("Cannot delete a #{@_name} resource "\
+          'without an identifier')
+        end
+
+        Response.new(@_client.send_request(@_resource_uri, 'DELETE', nil),
+                     @_identifier_string)
+      end
+    end
+  end
+end

data/lib/plivo/base/resource_interface.rb

@@ -0,0 +1,93 @@
+module Plivo
+  module Base
+    class ResourceInterface
+      include Plivo::Utils
+      def initialize(client, resource_list_json = nil)
+        configure_client(client)
+        configure_resource_uri
+        parse_and_set(resource_list_json) if resource_list_json
+      end
+
+      private
+
+      def configure_client(client)
+        valid_param?(:client, client, RestClient, true)
+        @_client = client
+      end
+
+      def configure_resource_uri
+        to_join = ['', 'v1', 'Account', @_client.auth_id, @_name, '']
+        to_join = ['', 'v1', 'Account', ''] if @_name == 'Account'
+
+        @_resource_uri = to_join.join('/')
+      end
+
+      def parse_and_set(resource_list_json)
+        return unless resource_list_json
+
+        valid_param?(:resource_list_json, resource_list_json, Hash, true)
+
+        resource_list_json.each do |k, v|
+          if k == 'objects'
+            parse_and_set_list(resource_list_json['objects'])
+          elsif k == 'meta'
+            @_meta = resource_list_json['meta']
+          else
+            instance_variable_set("@#{k}", v)
+            self.class.send(:attr_reader, k)
+          end
+        end
+      end
+
+      def perform_get(identifier, params = nil)
+        valid_param?(:identifier, identifier, [String, Symbol], true)
+        response_json = @_client.send_request(@_resource_uri + identifier.to_s + '/', 'GET', params)
+        @_resource_type.new(@_client, resource_json: response_json)
+      end
+
+      def perform_get_without_identifier(params)
+        valid_param?(:params, params, Hash, true)
+        response_json = @_client.send_request(@_resource_uri, 'GET', params)
+        @_resource_type.new(@_client, resource_json: response_json)
+      end
+
+      def perform_create(params)
+        Response.new(
+          @_client.send_request(@_resource_uri, 'POST', params),
+          @_identifier_string
+        )
+      end
+
+      def perform_post(params)
+        response_json = @_client.send_request(@_resource_uri, 'POST', params)
+
+        parse_and_set(response_json)
+        self
+      end
+
+      def parse_and_set_list(list_json)
+        return unless list_json
+        valid_param?(:list_json, list_json, Array, false)
+        @_resource_list = list_json.map do |resource|
+          @_resource_type.new(@_client, resource_json: resource)
+        end
+      end
+
+      def perform_list(params = nil)
+        response_json = @_client.send_request(@_resource_uri, 'GET', params)
+        parse_and_set(response_json)
+        {
+          api_id: @api_id,
+          meta: @_meta,
+          objects: @_resource_list
+        }
+      end
+
+      def perform_list_without_object(params = nil)
+        response_json = @_client.send_request(@_resource_uri, 'GET', params)
+        parse_and_set(response_json)
+        response_json
+      end
+    end
+  end
+end

data/lib/plivo/base/response.rb

@@ -0,0 +1,29 @@
+module Plivo
+  module Base
+    ##
+    # A class to provide a blanket response based on what is
+    # being received from Plivo servers.
+    #
+    # This will be used only during POST and DELETE requests.
+    class Response
+      ##
+      # Instantiating a new instance requires a response_hash
+      # The id_symbol should contain a Symbol that represents
+      # the identifier of the resource for which this response
+      # is being generated for.
+
+      def initialize(response_hash, id_symbol = nil)
+        return unless response_hash
+
+        response_hash.each do |k, v|
+          instance_variable_set("@#{k}", v)
+          self.class.send(:attr_reader, k)
+        end
+        return unless id_symbol && response_hash.key?(id_symbol)
+
+        self.class.send(:attr_reader, :id)
+        @id = response_hash[id_symbol]
+      end
+    end
+  end
+end

data/lib/plivo/exceptions.rb

@@ -0,0 +1,50 @@
+module Plivo
+  ##
+  # The exceptions module that helps in passing on errors to the user in a better way.
+  module Exceptions
+    ##
+    # This is Plivo's base error and will be raised when there is an unknown
+    # error that is not covered by other errors.
+    PlivoRESTError = Class.new(StandardError)
+
+    ##
+    # This will be raised when A parameter is missing or is invalid while
+    # accessing resource.
+    ValidationError = Class.new(PlivoRESTError)
+    # 'A parameter is missing or is invalid while accessing resource'
+
+    ##
+    # This will be raised when there is an an error authenticating the request.
+    #
+    # It is because there were no authentication credentials found or passed
+    # or the auth credentials that were found or passed were incorrect.
+    AuthenticationError = Class.new(PlivoRESTError)
+
+    ##
+    # This will be raised when one or more parameters passed to Plivo servers
+    # is invalid.
+    #
+    # More specific error message will be displayed wherever possible.
+    InvalidRequestError = Class.new(PlivoRESTError)
+
+    ##
+    # This will be raised when there is a server error on the Plivo end.
+    #
+    # This is rarely encountered. You might want to catch this error and
+    # retry the request if needed.
+    #
+    # If retrying doesn't help, please contact https://support.plivo.com
+    # immediately.
+    PlivoServerError = Class.new(PlivoRESTError)
+
+    ##
+    # This will be raised when there is an XML generation error.
+    #
+    # Usually, the reason why this error is raised will be included.
+    PlivoXMLError = Class.new(PlivoRESTError)
+
+    ##
+    # This will be raised when there is an authentication error
+    ResourceNotFoundError = Class.new(PlivoRESTError)
+  end
+end

data/lib/plivo/resources.rb

@@ -0,0 +1,14 @@
+require_relative 'resources/messages'
+require_relative 'resources/accounts'
+require_relative 'resources/applications'
+require_relative 'resources/recordings'
+require_relative 'resources/pricings'
+require_relative 'resources/numbers'
+require_relative 'resources/conferences'
+require_relative 'resources/calls'
+require_relative 'resources/endpoints'
+
+module Plivo
+  module Resources
+  end
+end

data/lib/plivo/resources/accounts.rb

@@ -0,0 +1,174 @@
+module Plivo
+  module Resources
+    include Plivo::Utils
+    class Subaccount < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'Subaccount'
+        @_identifier_string = 'auth_id'
+        super
+      end
+
+      def update(name, enabled = false)
+        valid_param?(:name, name, [String, Symbol], true)
+        valid_param?(:enabled, enabled, [TrueClass, FalseClass],
+                     true, [true, false])
+
+        params = {
+          name: name,
+          enabled: enabled
+        }
+        perform_update(params)
+      end
+
+      def delete
+        perform_delete
+      end
+
+      def to_s
+        {
+          account: @account,
+          api_id: @api_id,
+          auth_id: @auth_id,
+          auth_token: @auth_token,
+          new_auth_token: @new_auth_token,
+          created: @created,
+          enabled: @enabled,
+          modified: @modified,
+          name: @name,
+          resource_uri: @resource_uri
+        }.to_s
+      end
+    end
+
+    # @!method get
+    # @!method create
+    # @!method list
+    class SubaccountInterface < Base::ResourceInterface
+      def initialize(client, resource_list_json = nil)
+        @_name = 'Subaccount'
+        @_resource_type = Subaccount
+        @_identifier_string = 'auth_id'
+        super
+      end
+
+      # @param [String] subaccount_id
+      def get(subaccount_id)
+        valid_subaccount?(subaccount_id, true)
+        perform_get(subaccount_id)
+      end
+
+      # @param [String] name
+      # @param [Boolean] enabled
+      def create(name, enabled = false)
+        valid_param?(:name, name, [String, Symbol], true)
+        valid_param?(:enabled, enabled, [TrueClass, FalseClass],
+                     true, [true, false])
+
+        params = {
+          name: name,
+          enabled: enabled
+        }
+
+        perform_create(params)
+      end
+
+      # @param [Array] options
+      def list(options = nil)
+        return perform_list if options.nil?
+
+        params = {}
+
+        %i[offset limit].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [Integer, Integer], true)
+            params[param] = options[param]
+          end
+        end
+
+        if options.key?(:limit) && (options[:limit] > 20 || options[:limit] <= 0)
+          raise_invalid_request('The maximum number of results that can be '\
+          "fetched is 20. limit can't be more than 20 or less than 1")
+        end
+
+        raise_invalid_request("Offset can't be negative") if options.key?(:offset) && options[:offset] < 0
+
+        perform_list(params)
+      end
+
+      def each
+        offset = 0
+        loop do
+          subaccount_list = list(offset: offset)
+          subaccount_list[:objects].each { |subaccount| yield subaccount }
+          offset += 20
+          return unless subaccount_list.length == 20
+        end
+      end
+
+      def update(subaccount_id, name, enabled = false)
+        Subaccount.new(@_client, resource_id: subaccount_id).update(name, enabled)
+      end
+
+      def delete(subaccount_id)
+        valid_subaccount?(subaccount_id, true)
+        Subaccount.new(@_client, resource_id: subaccount_id).delete
+      end
+    end
+
+    class Account < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'Account'
+        @_identifier_string = 'auth_id'
+        super
+      end
+
+      def update(details)
+        valid_param?(:details, details, Hash, true)
+
+        params = {}
+        %i[name city address].each do |param|
+          if details.key?(param) && valid_param?(param, details[param], [String, Symbol], true)
+            params[param] = details[param]
+          end
+        end
+
+        raise_invalid_request('One parameter of name, city and address is required') if params == {}
+        perform_update(params)
+      end
+
+      def to_s
+        {
+          account_type: @account_type,
+          address: @address,
+          api_id: @api_id,
+          auth_id: @auth_id,
+          auto_recharge: @auto_recharge,
+          billing_mode: @billing_mode,
+          cash_credits: @cash_credits,
+          city: @city,
+          name: @name,
+          resource_uri: @resource_uri,
+          state: @state,
+          timezone: @timezone
+        }.to_s
+      end
+    end
+
+    class AccountInterface < Base::ResourceInterface
+      def initialize(client, resource_list_json = nil)
+        @_name = 'Account'
+        @_resource_type = Account
+        @_identifier_string = 'auth_id'
+        super
+      end
+
+      def details
+        perform_get(@_client.auth_id)
+      end
+
+      def update(details)
+        Account.new(@_client, resource_id: @_client.auth_id).update(details)
+      end
+    end
+  end
+end