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/kpi_log.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/utils/export_request.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, ExportRequest, GameplayUtil, Instance, KnowledgeEdge, KnowledgeGraph, KnowledgeGraphNode, KnowledgeGraphScale, KnowledgeNode, KnowledgeNodeContent, KnowledgeNodeStudent, KpiLog, 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.22'.freeze

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.configuration ⇒ Object

Returns the value of attribute configuration.



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

def configuration
  @configuration
end

Class Method Details

.api_uri(url = '') ⇒ Object 



75
76
77
 
# File 'lib/domoscio_rails.rb', line 75

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

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

Yields:



70
71
72
73
 
# File 'lib/domoscio_rails.rb', line 70

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

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

Actual HTTP call is performed here



166
167
168
169
170
171
172
 
# File 'lib/domoscio_rails.rb', line 166

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:



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

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



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

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



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

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



229
230
231
232
233
234
235
 
# File 'lib/domoscio_rails.rb', line 229

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



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

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



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

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



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

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 



197
198
199
200
201
 
# File 'lib/domoscio_rails.rb', line 197

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

.user_agent ⇒ Object 



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

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