Module: Plivo::Utils

Included in:
Plivo, Base::Resource, Base::ResourceInterface, Resources, Token
Defined in:
lib/plivo/utils.rb

Overview

Utils module

Constant Summary collapse

TYPE_WHITELIST = 
[Integer]

Class Method Summary collapse

Class Method Details

.compute_signatureV3?(url, auth_token, nonce) ⇒ Boolean

Returns:

  • (Boolean) 


171
172
173
174
175
 
# File 'lib/plivo/utils.rb', line 171

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) ⇒ Boolean

Returns:

  • (Boolean) 


70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/plivo/utils.rb', line 70

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) ⇒ Boolean

Returns:

  • (Boolean) 


85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/plivo/utils.rb', line 85

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) ⇒ Boolean

Returns:

  • (Boolean) 


111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/plivo/utils.rb', line 111

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(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) ⇒ Boolean

Returns:

  • (Boolean) 


140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/plivo/utils.rb', line 140

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

.GetSortedQueryParamString?(params, queryParams) ⇒ Boolean

Returns:

  • (Boolean) 


155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/plivo/utils.rb', line 155

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

.raise_invalid_request(message = '') ⇒ Object

Raises:



55
56
57
 
# File 'lib/plivo/utils.rb', line 55

def raise_invalid_request(message = '')
  raise Exceptions::InvalidRequestError, message
end

.valid_account?(account_id, raise_directly = false) ⇒ Boolean

Returns:

  • (Boolean) 


13
14
15
 
# File 'lib/plivo/utils.rb', line 13

def valid_account?(, raise_directly = false)
  valid_subaccount?(, raise_directly) || valid_mainaccount?(, raise_directly)
end

.valid_mainaccount?(account_id, raise_directly = false) ⇒ Boolean

Returns:

  • (Boolean) 


37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/plivo/utils.rb', line 37

def valid_mainaccount?(, raise_directly = false)
  unless .is_a? String
    return false unless raise_directly
    raise_invalid_request('account_id must be a string')
  end

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

  if [0..1] != 'MA'
    return false unless raise_directly
    raise_invalid_request("account_id should start with 'SA'")
  end
  true
end

.valid_param?(param_name, param_value, expected_types = nil, mandatory = false, expected_values = nil) ⇒ Boolean

Returns:

  • (Boolean) 


59
60
61
62
63
64
65
66
67
68
 
# 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_signature?(uri, nonce, signature, auth_token) ⇒ Boolean

Parameters:

  • uri (String)
  • nonce (String)
  • signature (String)
  • auth_token (String)

Returns:

  • (Boolean) 


102
103
104
105
106
107
108
109
 
# File 'lib/plivo/utils.rb', line 102

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 = {}) ⇒ Boolean

Returns:

  • (Boolean) 


177
178
179
180
181
 
# File 'lib/plivo/utils.rb', line 177

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) ⇒ Boolean

Parameters:

  • account_id (String)
  • raise_directly (Boolean) (defaults to: false)

Returns:

  • (Boolean) 


19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/plivo/utils.rb', line 19

def valid_subaccount?(, raise_directly = false)
  unless .is_a? String
    return false unless raise_directly
    raise_invalid_request('subaccount_id must be a string')
  end

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

  if [0..1] != 'SA'
    return false unless raise_directly
    raise_invalid_request("subaccount_id should start with 'SA'")
  end
  true
end