kosapi_client 0.5.0

data/lib/kosapi_client/request_builder_delegator.rb

@@ -0,0 +1,52 @@
+module KOSapiClient
+  class RequestBuilderDelegator
+
+    def initialize(request_builder)
+      @request_builder = request_builder
+      @response = nil
+    end
+
+    alias :super_method_missing :method_missing
+
+    def method_missing(method, *args, &block)
+      if @response
+        delegate_to_response(method, *args, &block)
+      else
+        delegate_to_builder(method, *args, &block)
+      end
+    end
+
+    def respond_to_missing?(method, include_all)
+      if @response
+        @response.respond_to?(method, include_all)
+      else
+        @request_builder.respond_to?(method, include_all)
+      end
+    end
+
+    private
+    def delegate_to_response(method, *args, &block)
+      if @response.respond_to?(method)
+        @response.send(method, *args, &block)
+      else
+        super_method_missing(method, *args)
+      end
+    end
+
+    def delegate_to_builder(method, *args, &block)
+      if @request_builder.respond_to?(method)
+        res = @request_builder.send(method, *args, &block)
+        if res.equal?(@request_builder)
+          self
+        else
+          res
+        end
+      else
+        @request_builder.finalize
+        @response = @request_builder.response
+        delegate_to_response(method, *args, &block)
+      end
+    end
+
+  end
+end

data/lib/kosapi_client/resource.rb

@@ -0,0 +1,12 @@
+require 'kosapi_client/request_builder'
+require 'kosapi_client/resource/courses_builder'
+require 'kosapi_client/resource/parallels_builder'
+require 'kosapi_client/resource/exams_builder'
+require 'kosapi_client/resource/course_events_builder'
+require 'kosapi_client/resource/teachers_builder'
+
+module KOSapiClient
+  module Resource
+
+  end
+end

data/lib/kosapi_client/resource/course_events_builder.rb

@@ -0,0 +1,13 @@
+module KOSapiClient
+  module Resource
+    class CourseEventsBuilder < RequestBuilder
+
+      def attendees
+        raise 'Call #find({course_event_id}) before asking for attendees' unless id_set?
+        url_builder.set_path(id, 'attendees')
+        self
+      end
+
+    end
+  end
+end

data/lib/kosapi_client/resource/courses_builder.rb

@@ -0,0 +1,12 @@
+module KOSapiClient
+  module Resource
+    class CoursesBuilder < RequestBuilder
+
+      def detail(level = 1)
+        @url_builder.set_query_param(:detail, level)
+        self
+      end
+
+    end
+  end
+end

data/lib/kosapi_client/resource/exams_builder.rb

@@ -0,0 +1,13 @@
+module KOSapiClient
+  module Resource
+    class ExamsBuilder < RequestBuilder
+
+      def attendees
+        raise 'Call #find({exam_id}) before asking for attendees' unless id_set?
+        url_builder.set_path(id, 'attendees')
+        self
+      end
+
+    end
+  end
+end

data/lib/kosapi_client/resource/parallels_builder.rb

@@ -0,0 +1,20 @@
+module KOSapiClient
+  module Resource
+    class ParallelsBuilder < RequestBuilder
+
+      def related
+        raise 'Call #find before asking for related parallels' unless id_set?
+        url_builder.set_path(id, 'related')
+        self
+      end
+
+      def students
+        raise 'Call #find before asking for students' unless id_set?
+        url_builder.set_path(id, 'students')
+        self
+      end
+
+    end
+  end
+end
+

data/lib/kosapi_client/resource/teachers_builder.rb

@@ -0,0 +1,16 @@
+module KOSapiClient
+  module Resource
+    class TeachersBuilder < RequestBuilder
+
+      # XXX: This is quite insane, we need some support to DRY subresources.
+      %w[courses parallels exams timetable].each do |resource|
+        define_method(resource) do |semester: 'current'|
+          raise "Call #find({username}) before asking for #{resource}" unless id_set?
+          url_builder.set_path(id, resource)
+          url_builder.set_query_param(:sem, semester)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/kosapi_client/resource_mapper.rb

@@ -0,0 +1,20 @@
+module KOSapiClient
+  module ResourceMapper
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def resource(name)
+        define_method name do
+          builder = create_builder name
+          RequestBuilderDelegator.new(builder)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/kosapi_client/response_converter.rb

@@ -0,0 +1,65 @@
+using Corefines::String::camelcase
+
+module KOSapiClient
+
+  # This class converts parsed response in hash format
+  # (wrapped in Response) into domain Ruby objects.
+  # Root domain object type is
+  # determined at runtime based on API response.
+
+  class ResponseConverter
+
+    def initialize(client)
+      @client = client
+    end
+
+    def convert(response)
+      if response.is_paginated?
+        convert_paginated(response)
+      else
+        convert_single(response.item)
+      end
+    end
+
+    # Returns processed entries converted into domain objects
+    # wrapped into ResultPage class instance.
+    # @param response [KOSapiResponse] Response object wrapping array of hashes corresponding to entries
+    # @return [ResultPage] ResultPage of domain objects
+
+    def convert_paginated(response)
+      items = response.items || []
+      converted_items = items.map{ |p| convert_single(p) }
+      Entity::ResultPage.new(converted_items, create_links(response))
+    end
+
+    def convert_single(item)
+      type = detect_type(item)
+      convert_type(item, type)
+    end
+
+    private
+    def convert_type(hash, type)
+      type.parse(hash)
+    end
+
+    def detect_type(hash)
+      type_str = hash[:xsi_type]
+      extract_type(type_str)
+    end
+
+    def extract_type(type_str)
+      type_name = type_str.camelcase(:upper)
+      begin
+        entity_type = Entity.const_get(type_name)
+      rescue
+        raise "Unknown entity type: #{type_name}"
+      end
+      entity_type
+    end
+
+    def create_links(response)
+      ResponseLinks.parse(response.links_hash, @client)
+    end
+
+  end
+end

data/lib/kosapi_client/response_links.rb

@@ -0,0 +1,40 @@
+require 'kosapi_client/entity/link'
+
+module KOSapiClient
+  class ResponseLinks
+
+    attr_reader :prev, :next
+
+    def initialize(prev_link, next_link)
+      @prev = prev_link
+      @next = next_link
+    end
+
+    class << self
+
+      def parse(hash, client)
+        prev_link = parse_link(hash, 'prev', client)
+        next_link = parse_link(hash, 'next', client)
+        new(prev_link, next_link)
+      end
+
+      private
+      def parse_link(hash, rel, client)
+        return nil unless hash
+        link_hash = extract_link_hash(hash, rel)
+        if link_hash
+          link = Entity::Link.parse(link_hash)
+          link.inject_client(client)
+          link
+        end
+      end
+
+      def extract_link_hash(hash, rel)
+        hash = [hash] unless hash.instance_of?(Array)
+        hash.find { |it| it[:rel] == rel }
+      end
+
+    end
+
+  end
+end

data/lib/kosapi_client/response_preprocessor.rb

@@ -0,0 +1,48 @@
+using Corefines::String::snake_case
+
+module KOSapiClient
+  class ResponsePreprocessor
+
+    def preprocess(result)
+      response = extract_parsed(result)
+      result = stringify_keys(response)
+      entries_to_array(result)
+      merge_contents(result)
+      result
+    end
+
+
+    private
+    def extract_parsed(result)
+      parsed_contents = result.parsed
+      raise 'Wrong type of parsed response. HTTP response body is probably invalid or incomplete.' unless parsed_contents.instance_of?(Hash)
+      parsed_contents
+    end
+
+    def stringify_keys(response)
+      HashUtils.deep_transform_hash_keys(response) { |key| key.snake_case.sub(':', '_').to_sym rescue key }
+    end
+
+    def entries_to_array(hash)
+      if hash[:atom_feed] && hash[:atom_feed][:atom_entry].instance_of?(Hash)
+        hash[:atom_feed][:atom_entry] = [hash[:atom_feed][:atom_entry]]
+      end
+    end
+
+    def merge_contents(hash)
+      entries = if hash[:atom_feed]
+        hash[:atom_feed][:atom_entry]
+      else
+        [hash[:atom_entry]]
+      end
+      if entries
+        entries.each do |entry|
+          content = entry.delete(:atom_content)
+          entry.merge! content if content
+        end
+      end
+
+    end
+
+  end
+end

data/lib/kosapi_client/url_builder.rb

@@ -0,0 +1,24 @@
+module KOSapiClient
+  class URLBuilder
+
+    def initialize(root_url)
+      @root_url = root_url
+      @template = URITemplate.new(root_url + '{/segments*}{?query*}')
+      @segments = []
+      @query = {}
+    end
+
+    def set_path(*segments)
+      @segments = segments
+    end
+
+    def set_query_param(param, value)
+      @query[param] = value
+    end
+
+    def url
+      @template.expand(segments: @segments, query: @query)
+    end
+
+  end
+end

data/lib/kosapi_client/version.rb

@@ -0,0 +1,3 @@
+module KOSapiClient
+  VERSION = '0.5.0'
+end

data/spec/integration/course_events_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'Course events resource', :vcr, :integration do
+  subject(:client) { create_kosapi_client }
+
+  it 'returns course events' do
+    expect(client.course_events.offset(0).limit(10).count).to be 10
+  end
+
+  it 'returns course event attendees' do
+    expect(client.course_events.find(220200484405).attendees.count).to be > 0
+  end
+end

data/spec/integration/courses_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe 'Courses resource', :vcr, :integration do
+  let(:credentials) { { client_id: ENV['KOSAPI_OAUTH_CLIENT_ID'], client_secret: ENV['KOSAPI_OAUTH_CLIENT_SECRET'] } }
+  subject(:client) {  KOSapiClient.new(credentials) }
+
+
+  it 'downloads courses data' do
+    page = client.courses.offset(0).limit(15).query(department: '18*')
+    expect(page.items.count).to eq 15
+  end
+
+  it 'provides courses data details' do
+    page = client.courses.offset(20).query(department: '18*', completion: 'EXAM').detail
+    expect(page.items.last.description).not_to be_nil
+  end
+
+  it 'parses entry title' do
+    page = client.courses
+    expect(page.items.first.title).not_to be_nil
+  end
+
+  it 'parses empty response' do
+    page = client.courses.offset(1000000)
+    expect(page.items).to eq []
+  end
+
+end

data/spec/integration/exams_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'Exams resource', :vcr, :integration do
+  
+  subject(:client) { create_kosapi_client }
+
+  it 'fetches exams' do
+    expect(client.exams.offset(0).limit(10).count).to be > 0
+  end
+
+  it 'fetches exam students' do
+    expect(client.exams.find(193156727405).attendees.count).to be > 0
+  end
+
+  it 'allows multiple examiners' do
+    exam = client.exams.find(613664749005)
+    expect(exam.examiners.count).to be 2
+    expect(exam.examiners.first.link_id).to eq 'zhoufjar'
+  end
+end

data/spec/integration/parallels_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe 'Parallels resource', :vcr, :integration do
+
+  let(:credentials) { { client_id: ENV['KOSAPI_OAUTH_CLIENT_ID'], client_secret: ENV['KOSAPI_OAUTH_CLIENT_SECRET'] } }
+  subject(:client) {  KOSapiClient.new(credentials) }
+
+  it 'fetches parallels list' do
+    page = client.parallels.offset(0).limit(50).query('course.department' => '18*')
+    expect(page.items.count).to eq 50
+  end
+
+  it 'parses relationship links properly' do
+    page = client.parallels
+    course = page.items.first.course
+    expect(course.link_title).not_to be_nil
+    expect(course.link_href).not_to be_nil
+  end
+
+  it 'parses entry ID properly' do
+    page = client.parallels
+    parallel = page.items.first
+    expect(parallel.id).not_to be_nil
+  end
+
+  it 'parses updated properly' do
+    page = client.parallels
+    parallel = page.items.first
+    expect(parallel.updated).not_to be_nil
+  end
+
+  it 'parses author properly' do
+    page = client.parallels
+    parallel = page.items.first
+    expect(parallel.author.name).not_to be_nil
+  end
+
+  it 'parses entry link properly' do
+    page = client.parallels
+    parallel = page.items.first
+    expect(parallel.link).not_to be_nil
+    expect(parallel.link.link_href).not_to be_nil
+    expect(parallel.link.link_rel).not_to be_nil
+  end
+
+  it 'parses timetable slot ID' do
+    page = client.parallels
+    slot = page.items.first.timetable_slots.first
+    expect(slot.id).not_to be_nil
+  end
+
+  it 'returns following result page with next callback' do
+    page = client.parallels
+    following_page = page.next
+    expect(following_page.items.count).to be > 0
+  end
+
+  it 'follows next link with RSQL query' do
+    page = client.parallels.where('(lastUpdatedDate>=2014-07-01T00:00:00;lastUpdatedDate<=2014-07-10T00:00:00)')
+    expect(page.next.items.count).to be > 0
+  end
+
+  it 'returns students for a parallel' do
+    students = client.parallels.find(339540000).students.limit(20)
+    expect(students.count).to eq 15
+  end
+
+end