Module: DomoscioRails

Defined in:
lib/domoscio_rails.rb,
lib/domoscio_rails/json.rb,
lib/domoscio_rails/errors.rb,
lib/domoscio_rails/tag/tag.rb,
lib/domoscio_rails/version.rb,
lib/domoscio_rails/resource.rb,
lib/domoscio_rails/utils/lxp.rb,
lib/domoscio_rails/data/event.rb,
lib/domoscio_rails/data/scorm.rb,
lib/domoscio_rails/http_calls.rb,
lib/domoscio_rails/data/device.rb,
lib/domoscio_rails/tag/tag_set.rb,
lib/domoscio_rails/tag/tagging.rb,
lib/domoscio_rails/data/content.rb,
lib/domoscio_rails/data/student.rb,
lib/domoscio_rails/tag/tag_edge.rb,
lib/domoscio_rails/utils/export.rb,
lib/domoscio_rails/data/instance.rb,
lib/domoscio_rails/data/question.rb,
lib/domoscio_rails/utils/analytic.rb,
lib/domoscio_rails/knowledge/scale.rb,
lib/domoscio_rails/utils/stats_util.rb,
lib/domoscio_rails/utils/review_util.rb,
lib/domoscio_rails/data/student_group.rb,
lib/domoscio_rails/authorization_token.rb,
lib/domoscio_rails/data/recommendation.rb,
lib/domoscio_rails/objective/objective.rb,
lib/domoscio_rails/utils/gameplay_util.rb,
lib/domoscio_rails/data/learning_session.rb,
lib/domoscio_rails/objective/subscription.rb,
lib/domoscio_rails/knowledge/knowledge_edge.rb,
lib/domoscio_rails/knowledge/knowledge_node.rb,
lib/domoscio_rails/knowledge/knowledge_graph.rb,
lib/domoscio_rails/utils/recommendation_util.rb,
lib/domoscio_rails/objective/learning_program.rb,
lib/domoscio_rails/objective/objective_student.rb,
lib/domoscio_rails/knowledge/knowledge_graph_node.rb,
lib/domoscio_rails/knowledge/knowledge_graph_scale.rb,
lib/domoscio_rails/knowledge/knowledge_node_content.rb,
lib/domoscio_rails/knowledge/knowledge_node_student.rb,
lib/domoscio_rails/objective/learning_program_student.rb,
lib/domoscio_rails/objective/objective_knowledge_node.rb,
lib/domoscio_rails/data/learning_session_knowledge_node.rb,
lib/domoscio_rails/data/learning_session_recommendation.rb,
lib/domoscio_rails/objective/objective_knowledge_node_student.rb

Defined Under Namespace

Modules: AuthorizationToken, HTTPCalls, JSON Classes: Analytic, Configuration, Content, Device, Error, Event, Export, GameplayUtil, Instance, KnowledgeEdge, KnowledgeGraph, KnowledgeGraphNode, KnowledgeGraphScale, KnowledgeNode, KnowledgeNodeContent, KnowledgeNodeStudent, LearningProgram, LearningProgramStudent, LearningSession, LearningSessionKnowledgeNode, LearningSessionRecommendation, Lxp, Objective, ObjectiveKnowledgeNode, ObjectiveKnowledgeNodeStudent, ObjectiveStudent, ProcessingError, Question, Recommendation, RecommendationUtil, Resource, ResponseError, ReviewUtil, Scale, Scorm, StatsUtil, Student, StudentGroup, Subscription, Tag, TagEdge, TagSet, Tagging

Constant Summary collapse

VERSION = 
'0.4.19'.freeze

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.configuration ⇒ Object

Returns the value of attribute configuration.



65
66
67
 
# File 'lib/domoscio_rails.rb', line 65

def configuration
  @configuration
end

Class Method Details

.api_uri(url = '') ⇒ Object 



73
74
75
 
# File 'lib/domoscio_rails.rb', line 73

def self.api_uri(url = '')
  URI(configuration.root_url + url)
end

.configure {|configuration| ... } ⇒ Object

Yields:



68
69
70
71
 
# File 'lib/domoscio_rails.rb', line 68

def self.configure
  self.configuration ||= Configuration.new
  yield configuration
end

.perform_call(uri, method, params, headers) ⇒ Object

Actual HTTP call is performed here



164
165
166
167
168
169
170
 
# File 'lib/domoscio_rails.rb', line 164

def self.perform_call(uri, method, params, headers)
  Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
    req = Net::HTTP.const_get(method.capitalize).new(uri.request_uri, headers)
    req.body = DomoscioRails::JSON.dump(params)
    http.request req
  end
end

.raise_http_failure(uri, response, params) ⇒ Object

This helper will check the response status and build the correcponding DomoscioRails::ResponseError

Raises:



151
152
153
154
155
156
157
158
159
160
 
# File 'lib/domoscio_rails.rb', line 151

def self.raise_http_failure(uri, response, params)
  return if response.is_a? Net::HTTPSuccess

  raise ResponseError.new(
    uri,
    response.code.to_i,
    DomoscioRails::JSON.load((response.body.nil? ? '' : response.body), symbolize_keys: true),
    response.body, params
  )
end

.request(method, url, params = {}) ⇒ Object

  • method: HTTP method; lowercase symbol, e.g. :get, :post etc.

  • url: the part after Configuration#root_url

  • params: hash; entity data for creation, update etc.; will dump it by JSON and assign to Net::HTTPRequest#body

Performs HTTP requests to Adaptive Engine On token issues, will try once to get a new token then will output a DomoscioRails::ReponseError with details

Raises DomoscioRails::ResponseError on Adaptive Error Status Raises DomoscioRails::ProcessingError on Internal Error



88
89
90
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
 
# File 'lib/domoscio_rails.rb', line 88

def self.request(method, url, params = {})
  params ||= {}
  store_tokens, headers = request_headers
  params.merge!({ 'per_page': 1000 }) unless params[:per_page]
  uri = api_uri(url)
  response = DomoscioRails.send_request(uri, method, params, headers)
  return response if response.is_a? DomoscioRails::ProcessingError

  begin
    raise_http_failure(uri, response, params)

    if response['Content-Type'] == 'application/zip' || response['Content-Type'] == 'application/xlsx'
      data = response
    else
      data = DomoscioRails::JSON.load(response.body.nil? ? '' : response.body)
    end

    if store_tokens
      DomoscioRails::AuthorizationToken::Manager.storage.store({
                                                                 access_token: response['Accesstoken'],
                                                                 refresh_token: response['Refreshtoken']
                                                               })
    end
  rescue MultiJson::LoadError => e
    data = ProcessingError.new(uri, 500, e, response.body, params)
  rescue ResponseError => e
    data = e
  end

  if response['Total']
    pagetotal = (response['Total'].to_i / response['Per-Page'].to_f).ceil
    (2..pagetotal).each do |j|
      response = DomoscioRails.send_request(uri, method, params.merge({ page: j }), headers)
      return response if response.is_a? DomoscioRails::ProcessingError

      begin
        raise_http_failure(uri, response, params)
        body = DomoscioRails::JSON.load(response.body.nil? ? '' : response.body)
        data += body
        data.flatten!
      rescue MultiJson::LoadError => e
        return ProcessingError.new(uri, 500, e, response.body, params)
      rescue ResponseError => e
        return e
      end
    end
  end
  data
end

.request_headers ⇒ Object

Process the token loading and analyze will return the processed headers and a token store flag



204
205
206
207
208
209
210
211
212
213
 
# File 'lib/domoscio_rails.rb', line 204

def self.request_headers
  auth_token = DomoscioRails::AuthorizationToken::Manager.token
  if auth_token && auth_token[:access_token] && auth_token[:refresh_token]
    [false, send_current_tokens(auth_token)]
  else
    [true, request_new_tokens]
  end
rescue SyntaxError, StandardError
  [true, request_new_tokens]
end

.request_new_tokens ⇒ Object

If we cant find tokens of they are corrupted / expired, then we set headers to request new ones



227
228
229
230
231
232
233
 
# File 'lib/domoscio_rails.rb', line 227

def self.request_new_tokens
  {
    'user_agent' => DomoscioRails.user_agent.to_s,
    'Authorization' => "Token token=#{DomoscioRails.configuration.client_passphrase}",
    'Content-Type' => 'application/json'
  }
end

.retry_call_and_store_tokens(uri, method, params) ⇒ Object

This method is called when AdaptiveEngine returns tokens errors Action on those errors is to retry and request new tokens, those new token are then stored



174
175
176
177
178
179
180
181
182
 
# File 'lib/domoscio_rails.rb', line 174

def self.retry_call_and_store_tokens(uri, method, params)
  headers = request_new_tokens
  response = perform_call(uri, method, params, headers)
  DomoscioRails::AuthorizationToken::Manager.storage.store({
                                                             access_token: response['Accesstoken'],
                                                             refresh_token: response['Refreshtoken']
                                                           })
  response
end

.send_current_tokens(auth_token) ⇒ Object

If stored token successfully loaded we build the header with them



217
218
219
220
221
222
223
224
 
# File 'lib/domoscio_rails.rb', line 217

def self.send_current_tokens(auth_token)
  {
    'user_agent' => DomoscioRails.user_agent.to_s,
    'AccessToken' => auth_token[:access_token].to_s,
    'RefreshToken' => auth_token[:refresh_token].to_s,
    'Content-Type' => 'application/json'
  }
end

.send_request(uri, method, params, headers) ⇒ Object

This function catches usual Http errors during callsheaders



140
141
142
143
144
145
146
147
 
# File 'lib/domoscio_rails.rb', line 140

def self.send_request(uri, method, params, headers)
  response = perform_call(uri, method, params, headers)
  response = retry_call_and_store_tokens(uri, method, params) if %w[401 403].include? response.code
  response
rescue Timeout::Error, Errno::EINVAL, Errno::ECONNREFUSED, Errno::ECONNRESET,
       EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
  ProcessingError.new(uri, 500, e, response)
end

.uname ⇒ Object 



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

def self.uname
  `uname -a 2>/dev/null` if RUBY_PLATFORM =~ /linux|darwin/i
rescue Errno::ENOMEM
  'uname lookup failed'
end

.user_agent ⇒ Object 



184
185
186
187
188
189
190
191
192
193
 
# File 'lib/domoscio_rails.rb', line 184

def self.user_agent
  @uname ||= uname
  {
    bindings_version: DomoscioRails::VERSION,
    lang: 'ruby',
    lang_version: "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
    platform: RUBY_PLATFORM,
    uname: @uname
  }.to_s
end