Class: Telesign::RestClient

Inherits:
Object
  • Object
show all
Defined in:
lib/telesign/rest.rb

Overview

The TeleSign RestClient is a generic HTTP REST client that can be extended to make requests against any of TeleSign’s REST API endpoints.

RequestEncodingMixin offers the function _encode_params for url encoding the body for use in string_to_sign outside of a regular HTTP request.

See developer.telesign.com for detailed API documentation.

Defined Under Namespace

Classes: Response

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(customer_id, api_key, rest_endpoint: 'https://rest-api.telesign.com', proxy: nil, timeout: 10, source: 'ruby_telesign', sdk_version_origin: Telesign::SDK_VERSION, sdk_version_dependency: nil) ⇒ RestClient

TeleSign RestClient, useful for making generic RESTful requests against the API.

  • customer_id - Your customer_id string associated with your account.

  • api_key - Your api_key string associated with your account.

  • rest_endpoint - (optional) Override the default rest_endpoint to target another endpoint.

  • timeout - (optional) How long to wait for the server to send data before giving up, as a float.



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/telesign/rest.rb', line 48

def initialize(customer_id,
               api_key,
               rest_endpoint: 'https://rest-api.telesign.com',
               proxy: nil,
               timeout: 10,
               source: 'ruby_telesign',
               sdk_version_origin: Telesign::SDK_VERSION,
               sdk_version_dependency: nil)

  @customer_id = customer_id
  @api_key = api_key
  @rest_endpoint = rest_endpoint

  @user_agent = "TeleSignSDK/ruby Ruby/#{RUBY_VERSION} net:http:persistent/#{Net::HTTP::VERSION} OriginatingSDK/#{source} SDKVersion/#{sdk_version_origin}"

  if (source != 'ruby_telesign' && !sdk_version_dependency.nil?)
    @user_agent += " DependencySDKVersion/#{sdk_version_dependency}"
  end

  @http = Net::HTTP::Persistent.new(name: 'telesign', proxy: proxy)

  unless timeout.nil?
    @http.open_timeout = timeout
    @http.read_timeout = timeout
  end
end

Class Method Details

.generate_telesign_headers(customer_id, api_key, method_name, resource, content_type, encoded_fields, date_rfc2616: nil, nonce: nil, user_agent: nil, auth_method: 'HMAC-SHA256') ⇒ Object

Generates the TeleSign REST API headers used to authenticate requests.

Creates the canonicalized string_to_sign and generates the HMAC signature. This is used to authenticate requests against the TeleSign REST API.

See developer.telesign.com/docs/authentication for detailed API documentation.

  • customer_id - Your account customer_id.

  • api_key - Your account api_key.

  • method_name - The HTTP method name of the request as a upper case string, should be one of ‘POST’, ‘GET’, ‘PUT’, ‘PATCH’ or ‘DELETE’.

  • resource - The partial resource URI to perform the request against, as a string.

  • url_encoded_fields - HTTP body parameters to perform the HTTP request with, must be a urlencoded string.

  • date_rfc2616 - The date and time of the request formatted in rfc 2616, as a string.

  • nonce - A unique cryptographic nonce for the request, as a string.

  • user_agent - (optional) User Agent associated with the request, as a string.



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/telesign/rest.rb', line 91

def self.generate_telesign_headers(customer_id,
                                   api_key,
                                   method_name,
                                   resource,
                                   content_type,
                                   encoded_fields,
                                   date_rfc2616: nil,
                                   nonce: nil,
                                   user_agent: nil,
                                   auth_method: 'HMAC-SHA256')

  if date_rfc2616.nil?
    date_rfc2616 = Time.now.httpdate
  end

  if nonce.nil?
    nonce = SecureRandom.uuid
  end

  content_type = (%w[POST PUT PATCH].include? method_name) ? content_type : ''

  if auth_method == 'HMAC-SHA256'

    string_to_sign = "#{method_name}"

    string_to_sign << "\n#{content_type}"

    string_to_sign << "\n#{date_rfc2616}"

    string_to_sign << "\nx-ts-auth-method:#{auth_method}"

    string_to_sign << "\nx-ts-nonce:#{nonce}"

    if !content_type.empty? and !encoded_fields.empty?
      string_to_sign << "\n#{encoded_fields}"
    end

    string_to_sign << "\n#{resource}"

    digest = OpenSSL::Digest.new('sha256')
    key = Base64.decode64(api_key)

    signature = Base64.encode64(OpenSSL::HMAC.digest(digest, key, string_to_sign)).strip

    authorization = "TSA #{customer_id}:#{signature}"
  else
    credentials = Base64.strict_encode64("#{customer_id}:#{api_key}")
    
    authorization = "Basic #{credentials}"
  end

  headers = {
      'Authorization'=>authorization,
      'Date'=>date_rfc2616,
      'x-ts-auth-method'=>auth_method,
      'x-ts-nonce'=>nonce
  }

  unless user_agent.nil?
    headers['User-Agent'] = user_agent
  end

  if !content_type.empty?
    headers['Content-Type'] = content_type
  end

  headers

end

Instance Method Details

#delete(resource, **params) ⇒ Object

Generic TeleSign REST API DELETE handler.

  • resource - The partial resource URI to perform the request against, as a string.

  • params - Body params to perform the DELETE request with, as a hash.



195
196
197
198
199
 
# File 'lib/telesign/rest.rb', line 195

def delete(resource, **params)

  execute(Net::HTTP::Delete, 'DELETE', resource, **params)

end

#get(resource, **params) ⇒ Object

Generic TeleSign REST API GET handler.

  • resource - The partial resource URI to perform the request against, as a string.

  • params - Body params to perform the GET request with, as a hash.



175
176
177
178
179
 
# File 'lib/telesign/rest.rb', line 175

def get(resource, **params)

  execute(Net::HTTP::Get, 'GET', resource, **params)

end

#patch(resource, auth_method: 'HMAC-SHA256', **params) ⇒ Object

Generic Telesign REST API PATCH handler.

  • resource - The partial resource URI to perform the request against, as a string.

  • auth_method - Method to auth.

  • params - Body params to perform the PATCH request with, as a hash.



206
207
208
209
210
 
# File 'lib/telesign/rest.rb', line 206

def patch(resource, auth_method: 'HMAC-SHA256', **params)

  execute(Net::HTTP::Patch, 'PATCH', resource, auth_method: auth_method, **params)

end

#post(resource, **params) ⇒ Object

Generic TeleSign REST API POST handler.

  • resource - The partial resource URI to perform the request against, as a string.

  • params - Body params to perform the POST request with, as a hash.



165
166
167
168
169
 
# File 'lib/telesign/rest.rb', line 165

def post(resource, **params)

  execute(Net::HTTP::Post, 'POST', resource, **params)

end

#put(resource, **params) ⇒ Object

Generic TeleSign REST API PUT handler.

  • resource - The partial resource URI to perform the request against, as a string.

  • params - Body params to perform the PUT request with, as a hash.



185
186
187
188
189
 
# File 'lib/telesign/rest.rb', line 185

def put(resource, **params)

  execute(Net::HTTP::Put, 'PUT', resource, **params)

end