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
- .compute_signatureV3?(url, auth_token, nonce) ⇒ Boolean
- .expected_type?(param_name, expected_types, param_value) ⇒ Boolean
- .expected_value?(param_name, expected_values, param_value) ⇒ Boolean
- .generate_url?(uri, params, method) ⇒ Boolean
- .getMapFromQueryString?(query) ⇒ Boolean
- .GetSortedQueryParamString?(params, queryParams) ⇒ Boolean
- .is_one_among_string_url?(param_name, param_value, mandatory = false, expected_values = nil) ⇒ Boolean
- .multi_valid_param?(param_name, param_value, expected_types = nil, mandatory = false, expected_values = nil, make_down_case = false, seperator = ',') ⇒ Boolean
- .raise_invalid_request(message = '') ⇒ Object
- .valid_account?(account_id, raise_directly = false) ⇒ Boolean
- .valid_date_format?(param_name, param_value, mandatory = false) ⇒ Boolean
- .valid_mainaccount?(account_id, raise_directly = false) ⇒ Boolean
- .valid_multiple_destination_integers?(param_name, param_value) ⇒ Boolean
- .valid_multiple_destination_nos?(param_name, param_value, options = nil) ⇒ Boolean
- .valid_param?(param_name, param_value, expected_types = nil, mandatory = false, expected_values = nil) ⇒ Boolean
- .valid_range?(param_name, param_value, mandatory = false, lower_bound = nil, upper_bound = nil) ⇒ Boolean
- .valid_signature?(uri, nonce, signature, auth_token) ⇒ Boolean
- .valid_signatureV3?(uri, nonce, signature, auth_token, method, params = {}) ⇒ Boolean
- .valid_subaccount?(account_id, raise_directly = false) ⇒ Boolean
- .valid_url?(param_name, param_value, mandatory = false) ⇒ Boolean
Class Method Details
.compute_signatureV3?(url, auth_token, nonce) ⇒ 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
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
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
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
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
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
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
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
55 56 57 |
# File 'lib/plivo/utils.rb', line 55 def raise_invalid_request( = '') raise Exceptions::InvalidRequestError, end |
.valid_account?(account_id, raise_directly = false) ⇒ Boolean
13 14 15 |
# 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) ⇒ 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
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?(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) ⇒ 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
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, = nil) if param_value.split([:delimiter]).size > 1 && [:role].downcase != 'agent' raise_invalid_request("Multiple #{param_name} values given for role #{[:role]}") elsif param_value.split([:delimiter]).size >= [:agent_limit] raise_invalid_request("No of #{param_name} values provided should be lesser than #{[:agent_limit]}") else return true end end |
.valid_param?(param_name, param_value, expected_types = nil, mandatory = false, expected_values = nil) ⇒ 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
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
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
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
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?(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) ⇒ 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 |