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) 


282
283
284
285
286
 
# 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) ⇒ Boolean

Returns:

  • (Boolean) 


181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
# 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) ⇒ Boolean

Returns:

  • (Boolean) 


196
197
198
199
200
201
202
203
204
205
206
207
 
# 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) ⇒ Boolean

Returns:

  • (Boolean) 


222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
 
# 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) ⇒ Boolean

Returns:

  • (Boolean) 


251
252
253
254
255
256
257
258
259
260
261
262
263
264
 
# 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

.GetSortedQueryParamString?(params, queryParams) ⇒ Boolean

Returns:

  • (Boolean) 


266
267
268
269
270
271
272
273
274
275
276
277
278
279
 
# 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

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

Returns:

  • (Boolean) 


164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
# 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 = ',') ⇒ Boolean

Returns:

  • (Boolean) 


131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# 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 = '') ⇒ 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_date_format?(param_name, param_value, mandatory = false) ⇒ Boolean

Returns:

  • (Boolean) 


150
151
152
153
154
155
156
157
158
159
160
161
162
 
# 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) ⇒ 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_multiple_destination_integers?(param_name, param_value) ⇒ Boolean

Returns:

  • (Boolean) 


80
81
82
83
84
85
86
87
88
89
 
# 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) ⇒ Boolean

Returns:

  • (Boolean) 


70
71
72
73
74
75
76
77
78
 
# 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) ⇒ 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_range?(param_name, param_value, mandatory = false, lower_bound = nil, upper_bound = nil) ⇒ Boolean

Returns:

  • (Boolean) 


106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# 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) ⇒ Boolean

Parameters:

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

Returns:

  • (Boolean) 


213
214
215
216
217
218
219
220
 
# 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 = {}) ⇒ Boolean

Returns:

  • (Boolean) 


288
289
290
291
292
 
# 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) ⇒ 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

.valid_url?(param_name, param_value, mandatory = false) ⇒ Boolean

Returns:

  • (Boolean) 


91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# 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