absorb_api 0.2.0 → 0.9.1

data/lib/absorb_api/api.rb

@@ -1,15 +1,79 @@
+# frozen_string_literal: true
+
 module AbsorbApi
   class Api
-    attr_reader :connection, :token
+    attr_writer :connection
 
-    def initialize
-      @token = AbsorbApi::Authorize.new.token
+    delegate :get, :put, :patch, :post, :delete, to: :connection
 
-      @connection ||= Faraday.new(url: AbsorbApi.configuration.url, parallel_manager: Typhoeus::Hydra.new(max_concurrency: 200)) do |faraday|
+    def connection
+      Faraday.new(
+        url: AbsorbApi.configuration.url,
+        parallel_manager: Typhoeus::Hydra.new(max_concurrency: 200)
+      ) do |faraday|
         faraday.request :json
         faraday.response :json, content_type: /\bjson$/
         faraday.adapter :typhoeus
-        faraday.headers = { 'Authorization' => @token }
+        faraday.headers = { "Authorization" => AbsorbApi.token }
+      end
+    end
+
+    def get(path, params = {})
+      request(:get, path, params)
+    end
+
+    def put(path, params = {})
+      request(:put, path, params)
+    end
+
+    def patch(path, params = {})
+      request(:patch, path, params)
+    end
+
+    def post(path, params = {})
+      request(:post, path, params)
+    end
+
+    def delete(path, params = {})
+      request(:delete, path, params)
+    end
+
+    private
+
+    def request(http_method, path, params)
+      ignore_resource_not_found = params.delete(:ignore_resource_not_found)
+      response = connection.send(http_method, path, params)
+      handle_errored_response(response, ignore_resource_not_found)
+
+      if response.status == 401
+        response = fetch_new_token_and_try_again(http_method, path, params)
+        handle_errored_response(response, ignore_resource_not_found)
+      end
+
+      fetch_response_body(response, ignore_resource_not_found)
+    end
+
+    def fetch_new_token_and_try_again(http_method, path, params)
+      AbsorbApi.authorization = nil
+      connection.send(http_method, path, params)
+    end
+
+    def handle_errored_response(response, ignore_resource_not_found = false)
+      unless ignore_resource_not_found
+        raise RouteNotFound    if [404, 405].include?(response.status)
+        raise ResourceNotFound if [400].include?(response.status)
+      end
+
+      raise ValidationError if [500].include?(response.status)
+    end
+
+    def fetch_response_body(response, ignore_resource_not_found = false)
+      return response.body unless ignore_resource_not_found
+
+      if [404, 405, 400].include?(response.status)
+        []
+      else
+        response.body
       end
     end
   end

data/lib/absorb_api/authorize.rb

@@ -1,17 +1,47 @@
+# frozen_string_literal: true
+
 module AbsorbApi
   class Authorize
-    attr_reader :token
+    attr_accessor :created_at
 
     def initialize
-      @token ||= Faraday.new(url: AbsorbApi.configuration.url) do |faraday|
+      token
+    end
+
+    def expired?
+      return true if created_at.blank?
+
+      DateTime.now >= created_at + 4.hours
+    end
+
+    def token
+      return @token unless expired?
+
+      @token = ActiveSupport::JSON.decode(connection.post do |req|
+        req.url "Authenticate"
+        req.headers["Content-Type"] = "application/json"
+        req.headers["accept"] = "json"
+        req.body = payload.to_json
+      end.body)
+      @created_at = DateTime.now
+    end
+
+    private
+
+    def connection
+      Faraday.new(url: AbsorbApi.configuration.url) do |faraday|
         faraday.request :url_encoded
         faraday.response :logger
         faraday.adapter :typhoeus
-      end.post do |req|
-        req.url 'Authenticate', username: AbsorbApi.configuration.absorbuser, password: AbsorbApi.configuration.absorbpass, privateKey: AbsorbApi.configuration.absorbkey
-        req.headers['Content-Type'] = 'application/json'
-        req.headers['accept'] = 'json'
-      end.body.delete('\\"')
+      end
+    end
+
+    def payload
+      {
+        "Username"   => AbsorbApi.configuration.absorbuser,
+        "Password"   => AbsorbApi.configuration.absorbpass,
+        "PrivateKey" => AbsorbApi.configuration.absorbkey
+      }
     end
   end
 end

data/lib/absorb_api/category.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module AbsorbApi
-  class Category < Base
+  class Category < Record
     attr_accessor :id, :parent_id, :name, :description
   end
 end

data/lib/absorb_api/certificate.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module AbsorbApi
-  class Certificate < Base
-    attr_accessor :id, :enrollment_id, :full_name, :course_name, :acquired_date, :expiry_date, :notes
+  class Certificate < Record
+    attr_accessor :id, :enrollment_id, :full_name, :course_name, :acquired_date,
+                  :expiry_date, :notes
   end
 end

data/lib/absorb_api/chapter.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module AbsorbApi
-  class Chapter < Base
+  class Chapter < Record
     attr_accessor :id, :name, :lesson_ids
   end
 end

data/lib/absorb_api/collection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AbsorbApi
   class Collection < ::Array
     attr_reader :metadata
@@ -6,24 +8,5 @@ module AbsorbApi
       super(elements)
       @metadata = metadata
     end
-
-    # private
-      # def method_missing(method_name, *arguments, &block)
-      #   if "AbsorbApi::#{metadata[:klass]}".constantize.new.respond_to? method_name
-      #     collection = []
-      #     Base.api.in_parallel do
-      #       self.each do |object|
-      #         collection << Base.api.get("#{metadata[:klass].to_s.pluralize}/#{object.id}/#{method_name}")
-      #       end
-      #     end
-      #     collection.map { |response| response.body.map { |attrs| CourseEnrollment.new(attrs) } }.flatten
-      #   else
-      #     super
-      #   end
-      # end
-      #
-      # def respond_to_missing?(method_name, include_private = false)
-      #   self.first.respond_to? method_name || super
-      # end
   end
 end

data/lib/absorb_api/configuration.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 module AbsorbApi
   class Configuration
-    attr_accessor :url, :absorbuser, :absorbpass, :absorbkey, :ignored_lesson_types, :ignored_course_ids
+    attr_accessor :url, :absorbuser, :absorbpass, :absorbkey
   end
 
-  class << self
-    attr_accessor :configuration
-  end
+  cattr_accessor :configuration
 
-  def self.configuration
-    @configuration ||= Configuration.new
-  end
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
 
-  def self.reset
-    @configuration = Configuration.new
-  end
+    def reset
+      @configuration = Configuration.new
+    end
 
-  def self.configure
-    yield(configuration)
+    def configure
+      yield(configuration)
+    end
   end
 end

data/lib/absorb_api/course.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module AbsorbApi
-  class Course < Base
-    include Relations
+  class Course < Record
+    with_relationships
+    can_search
 
     attr_accessor :id, :name, :description, :notes, :external_id, :access_date,
                   :expire_type, :expire_duration, :expiry_date, :active_status,
@@ -10,28 +13,11 @@ module AbsorbApi
                   :category_id, :certificate_url, :audience, :goals, :vendor,
                   :company_cost, :learner_cost, :company_time, :learner_time
 
-    has_many :certificates
-    has_many :chapters
-    has_many :enrollments, :course_enrollment
-    has_many :resources
-    has_many :prerequisites
-    has_many :lessons
-
-    # gets all associated enrollments given a collection of courses
-    # all calls are called in parallel
-    def self.enrollments_from_collection(courses, **conditions)
-      enrollments = []
-      connection = AbsorbApi::Api.new.connection
-      courses.reject! do |course|
-        AbsorbApi.configuration.ignored_course_ids.include? course.id
-      end
-
-      connection.in_parallel do
-        courses.each do |course|
-          enrollments << connection.get("courses/#{course.id}/enrollments", conditions)
-        end
-      end
-      enrollments.map { |response| response.body.map { |attrs| CourseEnrollment.new(attrs) } }.flatten
-    end
+    with_many :certificates
+    with_many :chapters
+    with_many :enrollments, :course_enrollment
+    with_many :resources
+    with_many :prerequisites
+    with_many :lessons
   end
 end

data/lib/absorb_api/course_enrollment.rb

@@ -1,35 +1,22 @@
+# frozen_string_literal: true
+
 module AbsorbApi
-  class CourseEnrollment < Base
-    attr_accessor :id, :course_id, :course_name, :course_version_id, :user_id, :full_name, :status, :progress, :score, :accepted_terms_and_conditions, :time_spent, :date_started, :date_completed, :enrollment_key_id, :certificate_id, :credits
+  class CourseEnrollment < Record
+    attr_accessor :id, :course_id, :course_name, :course_version_id, :user_id,
+                  :full_name, :status, :progress, :score,
+                  :accepted_terms_and_conditions, :time_spent, :date_started,
+                  :date_completed, :enrollment_key_id, :certificate_id, :credits
 
     def lessons(**conditions)
-      AbsorbApi::Api.new.connection.get("users/#{self.user_id}/enrollments/#{self.course_id}/lessons", conditions).body.map! do |lesson_attributes|
-        LessonEnrollment.new(lesson_attributes)
+      get(url, conditions.merge(ignore_resource_not_found: true)).map do |attrs|
+        LessonEnrollment.new(attrs)
       end
     end
 
-    # gets all associated lessons given a collection of enrollments
-    # all calls are called in parallel
-    # enrollments are chunked in groups of 105 to keep typhoeus from getting bogged down
-    # modifiedSince must be a DateTime object
-    def self.lessons_from_collection(course_enrollments, **filters)
-      lessons = []
-      connection = AbsorbApi::Api.new.connection
-      course_enrollments.each_slice(105) do |enrollment_slice|
-        connection.in_parallel do
-          enrollment_slice.each do |enrollment|
-            lessons << connection.get("users/#{enrollment.user_id}/enrollments/#{enrollment.course_id}/lessons", filters)
-          end
-        end
-      end
-      lessons.map! do |response|
-        response.body.map do |body|
-          LessonEnrollment.new(body)
-        end
-      end
-      lessons.flatten.reject do |lesson|
-        AbsorbApi.configuration.ignored_lesson_types.include? lesson.type
-      end
+    private
+
+    def url
+      "users/#{user_id}/enrollments/#{course_id}/lessons"
     end
   end
 end

data/lib/absorb_api/create.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AbsorbApi
+  module Create
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def create(attributes = {})
+        object = new(attributes)
+        yield(object) if block_given?
+
+        attrs = object.as_json.transform_keys(&:camelize)
+        response = api.post(to_s.demodulize.pluralize.to_s, attrs)
+        object.id = response.body["Id"]
+        object
+      end
+    end
+  end
+end

data/lib/absorb_api/curriculum.rb

@@ -1,5 +1,14 @@
+# frozen_string_literal: true
+
 module AbsorbApi
-  class Curriculum < Base
-    attr_accessor :is_pacing_enabled, :curriculum_group_ids, :id, :name, :description, :notes, :external_id, :access_date, :expire_type, :expire_duration, :expiry_date, :active_status, :tag_ids, :resource_ids, :editor_ids, :prices, :competency_definition_ids, :prerequisite_course_ids, :post_enrollment_course_ids, :allow_course_evaluation, :category_id, :certificate_url, :audience, :goals, :vendor, :company_cost, :learner_cost, :company_time, :learner_time
+  class Curriculum < Record
+    attr_accessor :is_pacing_enabled, :curriculum_group_ids, :id, :name,
+                  :description, :notes, :external_id, :access_date,
+                  :expire_type, :expire_duration, :expiry_date, :active_status,
+                  :tag_ids, :resource_ids, :editor_ids, :prices,
+                  :competency_definition_ids, :prerequisite_course_ids,
+                  :post_enrollment_course_ids, :allow_course_evaluation,
+                  :category_id, :certificate_url, :audience, :goals, :vendor,
+                  :company_cost, :learner_cost, :company_time, :learner_time
   end
 end

data/lib/absorb_api/department.rb

@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
 module AbsorbApi
-  class Department < Base
-    include Relations
+  class Department < Record
+    with_relationships
+    can_create
+    can_search
 
-    attr_accessor :id, :name, :use_department_contact_details, :company_name, :phone_number, :email_address, :external_id, :parent_id, :currency_id
+    attr_accessor :id, :name, :use_department_contact_details, :company_name,
+                  :phone_number, :email_address, :external_id, :parent_id,
+                  :currency_id
 
-    has_one :parent, :department
+    with_one :parent, :department
   end
 end

data/lib/absorb_api/lesson.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module AbsorbApi
-  class Lesson < Base
-    attr_accessor :id, :chapter_id, :name, :description, :notes, :type, :width, :height, :url, :use_popup, :passing_score, :weight, :ref_id
+  class Lesson < Record
+    attr_accessor :id, :chapter_id, :name, :description, :notes, :type, :width,
+                  :height, :url, :use_popup, :passing_score, :weight, :ref_id
   end
 end

data/lib/absorb_api/lesson_enrollment.rb

@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
 module AbsorbApi
-  class LessonEnrollment < Base
-    attr_accessor :lesson_id, :chapter_enrollment_id, :type, :attempts, :failures, :last_attempt, :id, :course_enrollment_id, :chapter_id, :session_id, :name, :user_id, :full_name, :status, :progress, :score, :time_spent, :date_enrolled, :date_started, :date_completed
+  class LessonEnrollment < Record
+    attr_accessor :lesson_id, :chapter_enrollment_id, :type, :attempts,
+                  :failures, :last_attempt, :id, :course_enrollment_id,
+                  :chapter_id, :session_id, :name, :user_id, :full_name,
+                  :status, :progress, :score, :time_spent, :date_enrolled,
+                  :date_started, :date_completed
   end
 end

data/lib/absorb_api/prerequisite.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module AbsorbApi
-  class Prerequisite < Base
-    attr_accessor :id, :name, :required_number, :prerequisite_type, :course_ids, :competency_definition_ids
+  class Prerequisite < Record
+    attr_accessor :id, :name, :required_number, :prerequisite_type, :course_ids,
+                  :competency_definition_ids
   end
 end

data/lib/absorb_api/record.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module AbsorbApi
+  class Record
+    delegate :connection, :get, :put, :patch, :post, :delete, to: :api
+    delegate :in_parallel, to: :connection
+
+    def initialize(params = {})
+      params.each do |attr, value|
+        next unless respond_to?("#{attr.to_s.underscore}=")
+
+        public_send("#{attr.to_s.underscore}=", value)
+      end
+
+      yield self if block_given?
+    end
+
+    class << self
+      def find(id)
+        raise ResourceNotFound if id.blank?
+
+        new(api.get("#{to_s.demodulize.pluralize}/#{id}"))
+      end
+
+      def all
+        objs = api.get(to_s.demodulize.pluralize).map do |attrs|
+          new(attrs)
+        end
+
+        Collection.new(objs, klass: to_s.demodulize)
+      end
+
+      def with_relationships
+        include Relations
+      end
+
+      def can_create
+        include Create
+      end
+
+      def can_search
+        include Where
+      end
+
+      private
+
+      def api
+        AbsorbApi::Api.new
+      end
+    end
+
+    private
+
+    def api
+      @api ||= AbsorbApi::Api.new
+    end
+  end
+end