module Plivo::Utils

Utils module

Constants

TYPE_WHITELIST

Public Instance Methods

GetSortedQueryParamString?(params, queryParams) click to toggle source
# File lib/plivo/utils.rb, line 266
def GetSortedQueryParamString?(params, queryParams)
  url = ""
  if queryParams
    params.keys.sort.each { |key|
      url += key + "=" + params[key] + "&"
    }
    url = url.chomp("&")
  else
    params.keys.sort.each { |key|
      url += key.to_s + params[key].to_s
    }
  end
  return url
end
compute_signatureV3?(url, auth_token, nonce) click to toggle source
# File lib/plivo/utils.rb, line 282
def compute_signatureV3?(url, auth_token, nonce)
  sha256_digest = OpenSSL::Digest.new('sha256')
  new_url = url + "." + nonce
  return Base64.encode64(OpenSSL::HMAC.digest(sha256_digest, auth_token, new_url)).strip()
end
expected_type?(param_name, expected_types, param_value) click to toggle source
# File lib/plivo/utils.rb, line 181
def expected_type?(param_name, expected_types, param_value)
  return true if expected_types.nil?
  param_value_class = param_value.class
  param_value_class = Integer if TYPE_WHITELIST.include? param_value_class
  if expected_types.is_a? Array
    return true if expected_types.include? param_value_class
    raise_invalid_request("#{param_name}: Expected one of #{expected_types}"\
      " but received #{param_value.class} instead")
  else
    return true if expected_types == param_value_class
    raise_invalid_request("#{param_name}: Expected a #{expected_types}"\
      " but received #{param_value.class} instead")
  end
end
expected_value?(param_name, expected_values, param_value) click to toggle source
# File lib/plivo/utils.rb, line 196
def expected_value?(param_name, expected_values, param_value)
  return true if expected_values.nil?
  if expected_values.is_a? Array
    return true if expected_values.include? param_value
    raise_invalid_request("#{param_name}: Expected one of #{expected_values}"\
      " but received '#{param_value}' instead")
  else
    return true if expected_values == param_value
    raise_invalid_request("#{param_name}: Expected '#{expected_values}'"\
      " but received '#{param_value}' instead")
  end
end
generate_url?(uri, params, method) click to toggle source
# File lib/plivo/utils.rb, line 222
def generate_url?(uri, params, method)
  uri.sub!("+", "%20")
  parsed_uri = URI.parse(uri)
  uri = parsed_uri.scheme + "://" + parsed_uri.host + parsed_uri.path
  if params.to_s.length > 0 || parsed_uri.query.to_s.length > 0
    uri += "?"
  end
  if parsed_uri.query.to_s.length > 0
    parsed_uri_query = URI.decode_www_form_component(parsed_uri.query)
    if method == "GET"
      queryParamMap = getMapFromQueryString?(parsed_uri_query)
      params.keys.sort.each { |key|
        queryParamMap[key] = params[key]
      }
      uri += GetSortedQueryParamString?(queryParamMap, true)
    else
      uri += GetSortedQueryParamString?(getMapFromQueryString?(parsed_uri_query), true) + "." + GetSortedQueryParamString?(params, false)
      uri = uri.chomp(".")
    end
  else
    if method == "GET"
      uri += GetSortedQueryParamString?(params, true)
    else
      uri += GetSortedQueryParamString?(params, false)
    end
  end
  return uri
end
getMapFromQueryString?(query) click to toggle source
# File lib/plivo/utils.rb, line 251
def getMapFromQueryString?(query)
  mp = Hash.new
  if query.to_s.length == 0
    return mp
  end
  keyValuePairs = query.split("&")
  keyValuePairs.each { |key|
    params = key.split("=", 2)
    if params.length == 2
      mp[params[0]] = params[1]
    end
  }
  return mp
end
is_one_among_string_url?(param_name, param_value, mandatory = false, expected_values= nil) click to toggle source
# File lib/plivo/utils.rb, line 164
def is_one_among_string_url?(param_name, param_value, mandatory = false, expected_values= nil)
  if mandatory && param_value.nil?
    raise_invalid_request("#{param_name} is a required parameter")
  end

  return true if param_value.nil?
  return raise_invalid_request("#{param_name}: Expected a String but received #{param_value.class} instead") unless expected_type?(param_name, String, param_value)

  if expected_values.include? param_value.downcase or expected_values.include? param_value.upcase
    return true
  elsif valid_url?(param_name, param_value)
    return true
  else
    raise_invalid_request("#{param_name} neither a valid URL nor in the expected values")
  end
end
multi_valid_param?(param_name, param_value, expected_types = nil, mandatory = false, expected_values = nil, make_down_case = false, seperator = ',') click to toggle source
# File lib/plivo/utils.rb, line 131
def multi_valid_param?(param_name, param_value, expected_types = nil, mandatory = false, expected_values = nil, make_down_case = false, seperator = ',')
  if mandatory && param_value.nil?
    raise_invalid_request("#{param_name} is a required parameter")
  end

  return true if param_value.nil?

  if make_down_case
    param_value = param_value.downcase
  else
    param_value = param_value.uppercase
  end

  for val in param_value.split(seperator)
    return expected_type?(param_name, expected_types, val.strip) unless expected_values
    expected_value?(param_name, expected_values, val.strip)
  end
end
raise_invalid_request(message = '') click to toggle source
# File lib/plivo/utils.rb, line 55
def raise_invalid_request(message = '')
  raise Exceptions::InvalidRequestError, message
end
valid_account?(account_id, raise_directly = false) click to toggle source
# File lib/plivo/utils.rb, line 13
def valid_account?(account_id, raise_directly = false)
  valid_subaccount?(account_id, raise_directly) || valid_mainaccount?(account_id, raise_directly)
end
valid_date_format?(param_name, param_value, mandatory = false) click to toggle source
# File lib/plivo/utils.rb, line 150
def valid_date_format?(param_name, param_value, mandatory = false)
  if mandatory && param_value.nil?
    raise_invalid_request("#{param_name} is a required parameter")
  end

  return true if param_value.nil?

  if param_value =~ /^(\d{4}\-\d{2}\-\d{2}\ \d{2}\:\d{2}(\:\d{2}(\.\d{1,6})?)?)$/ix
    return true
  else
    return raise_invalid_request("Invalid Date Format")
  end
end
valid_mainaccount?(account_id, raise_directly = false) click to toggle source
# File lib/plivo/utils.rb, line 37
def valid_mainaccount?(account_id, raise_directly = false)
  unless account_id.is_a? String
    return false unless raise_directly
    raise_invalid_request('account_id must be a string')
  end

  if account_id.length != 20
    return false unless raise_directly
    raise_invalid_request('account_id should be of length 20')
  end

  if account_id[0..1] != 'MA'
    return false unless raise_directly
    raise_invalid_request("account_id should start with 'SA'")
  end
  true
end
valid_multiple_destination_integers?(param_name, param_value) click to toggle source
# File lib/plivo/utils.rb, line 80
def valid_multiple_destination_integers?(param_name, param_value)
  if (param_value.is_a? String)
    values = param_value.split("<")
    for i in values
      unless (Integer(i) rescue false)
        raise_invalid_request("#{param_name} Destination Value must be integer")
      end
    end
  end
end
valid_multiple_destination_nos?(param_name, param_value, options = nil) click to toggle source
# File lib/plivo/utils.rb, line 70
def valid_multiple_destination_nos?(param_name, param_value, options = nil)
  if param_value.split(options[:delimiter]).size > 1 && options[:role].downcase != 'agent'
    raise_invalid_request("Multiple #{param_name} values given for role #{options[:role]}")
  elsif param_value.split(options[:delimiter]).size >= options[:agent_limit]
    raise_invalid_request("No of #{param_name} values provided should be lesser than #{options[:agent_limit]}")
  else
    return true
  end
end
valid_param?(param_name, param_value, expected_types = nil, mandatory = false, expected_values = nil) click to toggle source
# File lib/plivo/utils.rb, line 59
def valid_param?(param_name, param_value, expected_types = nil, mandatory = false, expected_values = nil)
  if mandatory && param_value.nil?
    raise_invalid_request("#{param_name} is a required parameter")
  end

  return true if param_value.nil?

  return expected_type?(param_name, expected_types, param_value) unless expected_values
  expected_value?(param_name, expected_values, param_value)
end
valid_range?(param_name, param_value, mandatory = false, lower_bound = nil, upper_bound = nil) click to toggle source
# File lib/plivo/utils.rb, line 106
def valid_range?(param_name, param_value, mandatory = false, lower_bound = nil, upper_bound = nil)
  if mandatory && param_value.nil?
    raise_invalid_request("#{param_name} is a required parameter")
  end

  return true if param_value.nil?

  return raise_invalid_request("#{param_name}: Expected an Integer but received #{param_value.class} instead") unless expected_type?(param_name, Integer, param_value)
  if lower_bound && upper_bound
    return raise_invalid_request("#{param_name} ranges between #{lower_bound} and #{upper_bound}") if param_value < lower_bound or param_value > upper_bound

    return true if param_value >= lower_bound and param_value <= upper_bound
  elsif lower_bound
    return raise_invalid_request("#{param_name} should be greater than #{lower_bound}") if param_value < lower_bound

    return true if param_value >= lower_bound
  elsif upper_bound
    return raise_invalid_request("#{param_name} should be lesser than #{upper_bound}") if param_value > upper_bound

    return true if param_value <= upper_bound
  else
    return raise_invalid_request("Any one or both of lower and upper bound should be provided")
  end
end
valid_signature?(uri, nonce, signature, auth_token) click to toggle source

@param [String] uri @param [String] nonce @param [String] signature @param [String] auth_token

# File lib/plivo/utils.rb, line 213
def valid_signature?(uri, nonce, signature, auth_token)
  parsed_uri = URI.parse(uri)
  uri_details = {host: parsed_uri.host, path: parsed_uri.path}
  uri_builder_module = parsed_uri.scheme == 'https' ? URI::HTTPS : URI::HTTP
  data_to_sign = uri_builder_module.build(uri_details).to_s + nonce
  sha256_digest = OpenSSL::Digest.new('sha256')
  Base64.encode64(OpenSSL::HMAC.digest(sha256_digest, auth_token, data_to_sign)).strip() == signature
end
valid_signatureV3?(uri, nonce, signature, auth_token, method, params={}) click to toggle source
# File lib/plivo/utils.rb, line 288
def valid_signatureV3?(uri, nonce, signature, auth_token, method, params={})
  new_url = generate_url?(uri, params, method)
  generated_signature = compute_signatureV3?(new_url, auth_token, nonce)
  return signature.split(",").include? generated_signature
end
valid_subaccount?(account_id, raise_directly = false) click to toggle source

@param [String] account_id @param [Boolean] raise_directly

# File lib/plivo/utils.rb, line 19
def valid_subaccount?(account_id, raise_directly = false)
  unless account_id.is_a? String
    return false unless raise_directly
    raise_invalid_request('subaccount_id must be a string')
  end

  if account_id.length != 20
    return false unless raise_directly
    raise_invalid_request('subaccount_id should be of length 20')
  end

  if account_id[0..1] != 'SA'
    return false unless raise_directly
    raise_invalid_request("subaccount_id should start with 'SA'")
  end
  true
end
valid_url?(param_name, param_value, mandatory = false) click to toggle source
# File lib/plivo/utils.rb, line 91
def valid_url?(param_name, param_value, mandatory = false)
  if mandatory && param_value.nil?
    raise_invalid_request("#{param_name} is a required parameter")
  end

  return true if param_value.nil?
  return raise_invalid_request("#{param_name}: Expected a String but received #{param_value.class} instead") unless expected_type?(param_name, String, param_value)

  if param_value =~ /^(http[s]?:\/\/([a-zA-Z]|[0-9]|[\$\-\_\@\.\&\+\/\#]|[\!\*\(\)\,]|(%[0-9a-fA-F][0-9a-fA-F]))+|nil)$/ix
    return true
  else
    return raise_invalid_request("Invalid URL : Doesn't satisfy the URL format")
  end
end