active_public_resources 0.0.2

data/lib/active_public_resources/drivers/khan_academy.rb

@@ -0,0 +1,143 @@
+require 'net/https'
+
+module ActivePublicResources
+  module Drivers
+    class KhanAcademy < Driver
+
+      BASE_URL = "https://www.khanacademy.org/api/v1/"
+
+      def perform_request(request_criteria)
+        request_criteria.folder ||= 'root'
+        results, videos, exercises = get_folder(request_criteria.folder)
+        parse_results(request_criteria, results, videos, exercises)
+      end
+
+    private
+
+      def perform_rest_request(path)
+        uri = URI( BASE_URL + path )
+        res = Net::HTTP.get_response(uri)
+        JSON.parse(res.body)
+      end
+
+      def get_folder(folder_id)
+        results = perform_rest_request("topic/#{folder_id}")
+        child_data_types  = results['child_data'].map { |item| item['kind'] }.uniq
+        videos = []
+        if child_data_types.include? "Video"
+          videos = get_videos(folder_id)
+        end
+        exercises = []
+        if child_data_types.include? "Exercise"
+          exercises = get_exercises(folder_id)
+        end
+        [results, videos, exercises]
+      end
+
+      def get_videos(folder_id)
+        perform_rest_request("topic/#{folder_id}/videos")
+      end
+
+      def get_exercises(folder_id)
+        perform_rest_request("topic/#{folder_id}/exercises")
+      end
+
+      def parse_results(request_criteria, results, videos=[], exercises=[])
+        parent_id = parse_parent_id(results['slug'], results['extended_slug'])
+        
+        driver_response = DriverResponse.new(
+          :criteria      => request_criteria,
+          :next_criteria => nil,
+          :total_items   => results['children'].length
+        )
+
+        topics = results['children'].find_all { |item| item['kind'] == 'Topic' }
+        topics.each do |topic|
+          driver_response.items << parse_folder(topic, parent_id)
+        end
+
+        videos.each do |video_data|
+          driver_response.items << parse_video(video_data)
+        end
+
+        exercises.each do |exercise_data|
+          driver_response.items << parse_exercise(exercise_data)
+        end
+
+        driver_response
+      end
+
+      def parse_folder(data, parent_id)
+        folder = ActivePublicResources::ResponseTypes::Folder.new
+        folder.id        = data['id']
+        folder.title     = data['title']
+        folder.parent_id = parent_id
+        folder
+      end
+
+      def parse_video(data)
+        video = ActivePublicResources::ResponseTypes::Video.new
+        video.id            = data['readable_id']
+        video.title         = data['title']
+        video.description   = data['description']
+        video.thumbnail_url = data['image_url']
+        video.url           = data['url']
+        video.duration      = data['duration'] ? data['duration'].to_i : 0
+        video.num_views     = 0
+        video.num_likes     = 0
+        video.num_comments  = 0
+        video.created_date  = data['date_added'].present? ? Date.parse(data['date_added']) : nil
+        video.username      = data['author_names'].present? ? data['author_names'].first : ''
+        video.width         = 640
+        video.height        = 360
+
+        # Return Types
+        video.return_types << APR::ReturnTypes::Url.new(
+          :url   => video.url,
+          :text  => video.title,
+          :title => video.title
+        )
+        video.return_types << APR::ReturnTypes::Iframe.new(
+          :url    => "//www.youtube.com/embed/#{data['youtube_id']}?feature=oembed",
+          :text   => video.title,
+          :title  => video.title,
+          :width  => 640,
+          :height => 360
+        )
+        video
+      end
+
+      def parse_exercise(data)
+        exercise = ActivePublicResources::ResponseTypes::Exercise.new
+        exercise.id            = data['global_id']
+        exercise.title         = data['display_name']
+        exercise.description   = data['description']
+        exercise.thumbnail_url = data['image_url_256']
+        exercise.url           = data['ka_url']
+
+        exercise.return_types << APR::ReturnTypes::Url.new(
+          :url   => exercise.url,
+          :text  => exercise.title,
+          :title => exercise.title
+        )
+
+        exercise
+      end
+
+      def parse_parent_id(slug, extended_slug)
+        if extended_slug.present?
+          if extended_slug != slug
+            parts = extended_slug.split("/")
+            parts.pop
+            parts.last
+          else
+            'root'
+          end
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/active_public_resources/drivers/quizlet.rb

@@ -0,0 +1,92 @@
+require 'net/https'
+
+module ActivePublicResources
+  module Drivers
+    class Quizlet < Driver
+
+      def initialize(config_options={})
+        validate_options(config_options, [:client_id])
+        @client_id = config_options[:client_id]
+      end
+
+      def perform_request(request_criteria)
+        raise StandardError.new("driver has not been initialized properly") unless @client_id.present?
+        request_criteria.validate_presence!([:query])
+
+        uri = URI('https://api.quizlet.com/2.0/search/sets')
+        params = {
+          'q'         => request_criteria.query,
+          'page'      => request_criteria.page     || 1,
+          'per_page'  => request_criteria.per_page || 25,
+          'client_id' => @client_id
+        }
+        uri.query = URI.encode_www_form(params)
+        res = Net::HTTP.get_response(uri)
+        results = JSON.parse(res.body)
+
+        return parse_results(request_criteria, results)
+      end
+
+    private
+
+      def parse_results(request_criteria, results)
+        @driver_response = DriverResponse.new(
+          :criteria      => request_criteria,
+          :next_criteria => next_criteria(request_criteria, results),
+          :total_items   => results['total_results'],
+          :items         => results['sets'].map { |data| parse_quiz(data) }
+        )
+      end
+
+      def next_criteria(request_criteria, results)
+        if results['total_pages'] > results['page']
+          return RequestCriteria.new({
+            :query    => request_criteria.query,
+            :page     => (request_criteria.page || 1) + 1,
+            :per_page => (request_criteria.per_page || 25)
+          })
+        end
+      end
+
+      def parse_quiz(data)
+        quiz = ActivePublicResources::ResponseTypes::Quiz.new
+        quiz.id            = data['id']
+        quiz.title         = data['title']
+        quiz.description   = data['description']
+        quiz.url           = data['url']
+        quiz.term_count    = data['term_count']
+        quiz.created_date  = Time.at(data['created_date']).utc.to_date
+        quiz.has_images    = data['has_images']
+        quiz.subjects      = data['subjects']
+        
+        # Return Types
+
+        quiz.return_types << APR::ReturnTypes::Url.new(
+          :url   => quiz.url,
+          :text  => quiz.title,
+          :title => quiz.title
+        )
+
+        # See http://quizlet.com/help/can-i-embed-quizlet-on-my-website
+        { flashcards: "Flashcards",
+          learn: "Learn",
+          scatter: "Scatter",
+          speller: "Speller",
+          test: "Test",
+          spacerace: "Space Race" }.each do |k,v|
+
+          quiz.return_types << APR::ReturnTypes::Iframe.new(
+            :url    => "https://quizlet.com/#{data['id']}/#{k}/embedv2",
+            :text   => v,
+            :title  => quiz.title,
+            :width  => "100%",
+            :height => 410
+          )
+        end
+
+        quiz
+      end
+
+    end
+  end
+end

data/lib/active_public_resources/drivers/schooltube.rb

@@ -0,0 +1,99 @@
+require 'net/https'
+
+module ActivePublicResources
+  module Drivers
+    class Schooltube < Driver
+
+      def perform_request(request_criteria)
+        request_criteria.validate_presence!([:query])
+        uri = URI('http://www.schooltube.com/api/v1/video/search/')
+        params = {
+          'term' => request_criteria.query,
+          'orderby' => normalize_request_criteria(request_criteria, 'sort') || '-view_count',
+          'offset' => offset(request_criteria.page, request_criteria.per_page),
+          'limit' => request_criteria.per_page || 25
+        }
+        uri.query = URI.encode_www_form(params)
+        res = Net::HTTP.get_response(uri)
+        results = JSON.parse(res.body)
+
+        return parse_results(request_criteria, results)
+      end
+
+    private
+
+      def offset(page, per_page)
+        p = page || 1
+        pp = per_page || 25
+        p * pp - pp
+      end
+
+      def normalize_request_criteria(request_criteria, field_name)
+        case field_name
+          when 'sort'
+            case request_criteria.instance_variable_get("@#{field_name}")
+              when 'views'
+                return '-view_count'
+              else
+                return '-view_count'
+            end
+          else
+            request_criteria.instance_variable_get("@#{field_name}")
+        end
+      end
+
+      def parse_results(request_criteria, results)
+        @driver_response = DriverResponse.new(
+          :criteria      => request_criteria,
+          :next_criteria => next_criteria(request_criteria, results),
+          :total_items   => nil,
+          :items         => results['objects'].map { |data| parse_video(data) }
+        )
+      end
+
+      def next_criteria(request_criteria, results)
+        if results['meta']['has_next']
+          return RequestCriteria.new({
+            :query    => request_criteria.query,
+            :page     => (request_criteria.page || 1) + 1,
+            :per_page => results['meta']['limit'].to_i
+          })
+        end
+      end
+
+      def parse_video(data)
+        video = ActivePublicResources::ResponseTypes::Video.new
+        video.id            = data['vkey']
+        video.title         = data['title']
+        video.description   = data['description']
+        video.thumbnail_url = data['thumbnail_url']
+        video.url           = data['short_url']
+        video.duration      = data['duration'] ? data['duration'].to_i : 0
+        video.num_views     = data['view_count'] ? data['view_count'].to_i : 0
+        video.num_likes     = data['thumbs_up'] ? data['thumbs_up'].to_i : 0
+        video.num_comments  = 0
+        video.created_date  = Date.parse(data['create_date'])
+        video.username      = data['username']
+        video.width         = 640
+        video.height        = 360
+
+        # Return Types
+        video.return_types << APR::ReturnTypes::Url.new(
+          :url   => video.url,
+          :text  => video.title,
+          :title => video.title
+        )
+        video.return_types << APR::ReturnTypes::Iframe.new(
+          :url    => "//www.schooltube.com/embed/#{data['vkey']}",
+          :text   => video.title,
+          :title  => video.title,
+          :width  => 640,
+          :height => 360
+        )
+
+        video
+      end
+
+    end
+  end
+end

data/lib/active_public_resources/drivers/vimeo.rb

@@ -0,0 +1,181 @@
+require 'vimeo'
+
+module ActivePublicResources
+  module Drivers
+    class Vimeo < Driver
+      attr_reader :client
+
+      DEFAULT_CRITERIA = {
+        :page           => 1,
+        :per_page       => 25,
+        :sort           => 'relevant',
+        :content_filter => 'safe'
+      }
+
+      # Constructor
+      #
+      # @param [Hash] config_options the options which the vimeo gem requires
+      # @option config_options [String] :consumer_key        Vimeo consumer key (required)
+      # @option config_options [String] :consumer_secret     Vimeo consumer secret (required)
+      # @option config_options [String] :access_token        Vimeo access token (required)
+      # @option config_options [String] :access_token_secret Vimeo access token secret (required)
+      def initialize(config_options={})
+        validate_options(config_options, 
+          [:consumer_key, :consumer_secret, :access_token, :access_token_secret])
+        
+        @client = ::Vimeo::Advanced::Video.new(
+          config_options[:consumer_key],
+          config_options[:consumer_secret],
+          token: config_options[:access_token],
+          secret: config_options[:access_token_secret]
+        )
+      end
+
+      # Perform search request to Vimeo with search criteria
+      #
+      # @param [Hash] criteria the criteria used to perform the search
+      # @option criteria [String]  :query          The query text to search for (required)
+      # @option criteria [Integer] :page           The page number
+      # @option criteria [Integer] :per_page       The number of items per page
+      # @option criteria [String]  :sort           The sort filter
+      # @option criteria [String]  :content_filter The content filter of which to apply
+      #                                            this is not supported yet - https://developer.vimeo.com/api/docs/spec
+      #
+      # @example Request
+      #   driver = ActivePublicResources::Drivers::Vimeo.new({ .. config options .. })
+      #   results = driver.perform_request({ query: 'education' })
+      #     
+      # @example Returns
+      #   {
+      #     'items': [
+      #       {
+      #         'kind'          : 'video',
+      #         'id'            : '1',
+      #         'title'         : '',
+      #         'description'   : '',
+      #         'thumbnail_url' : '',
+      #         'url'           : '',
+      #         'duration'      : 150,
+      #         'num_views'     : 13,
+      #         'num_likes'     : 1,
+      #         'num_comments'  : 2,
+      #         'created_date'  : '',
+      #         'username'      : '',
+      #         'embed_html'    : '',
+      #         'width'         : 640,
+      #         'height'        : 360
+      #       },
+      #       ...
+      #     ],
+      #     'meta': {
+      #       'nextCriteria': {
+      #         'query'          : 'education',
+      #         'page'           : 2
+      #         'per_page'       : 25
+      #         'sort'           : 'relevant'
+      #         'content_filter' : 'safe'
+      #       }
+      #     }
+      #   }
+      #
+      # @return [JSON] the normalized response object
+      def perform_request(request_criteria)
+        request_criteria.validate_presence!([:query])
+        raise StandardError.new("driver has not been initialized properly") unless @client
+        
+        results = @client.search(request_criteria.query, {
+          :page           => request_criteria.page || 1,
+          :per_page       => request_criteria.per_page || 25,
+          :full_response  => 1,
+          :sort           => request_criteria.sort || "relevant",
+          :user_id        => nil,
+          :content_filter => request_criteria.content_filter || 'safe'
+        })
+
+        return parse_results(request_criteria, results)
+      end
+
+    private
+
+      def sort(val)
+        case val
+          when APR::RequestCriteria::SORT_RELEVANCE
+            'relevant'
+          when APR::RequestCriteria::SORT_RECENT
+            'newest'
+          when APR::RequestCriteria::SORT_POPULAR
+            'most_played'
+          else
+            'relevant'
+        end
+      end
+
+      def content_filter(val)
+        case val
+          when APR::RequestCriteria::CONTENT_FILTER_NONE
+            'safe'
+          when APR::RequestCriteria::CONTENT_FILTER_STRICT
+            'safe'
+          else
+            'safe'
+        end
+      end
+
+      def parse_results(request_criteria, results)
+        @driver_response = DriverResponse.new(
+          :criteria      => request_criteria,
+          :next_criteria => next_criteria(request_criteria, results),
+          :total_items   => results['videos']['total'].to_i,
+          :items         => results['videos']['video'].map { |data| parse_video(data) }
+        )
+      end
+
+      def next_criteria(request_criteria, results)
+        page     = results['videos']['page'].to_i
+        per_page = results['videos']['perpage'].to_i
+        total    = results['videos']['total'].to_i
+        if ((page * per_page) < total)
+          return RequestCriteria.new({
+            :query    => request_criteria.query,
+            :page     => page + 1,
+            :per_page => per_page
+          })
+        end
+      end
+
+      def parse_video(data)
+        video = ActivePublicResources::ResponseTypes::Video.new
+        video.id            = data['id']
+        video.title         = data['title']
+        video.description   = data['description']
+        video.thumbnail_url = data['thumbnails']['thumbnail'][0]['_content']
+        video.url           = data['urls']['url'][0]['_content']
+        video.duration      = data['duration'].to_i
+        video.num_views     = data['number_of_plays'].to_i
+        video.num_likes     = data['number_of_likes'].to_i
+        video.num_comments  = data['number_of_comments'].to_i
+        video.created_date  = Date.parse(data['upload_date'])
+        video.username      = data['owner']['display_name']
+        video.width         = 640
+        video.height        = 360
+
+        # Return Types
+        video.return_types << APR::ReturnTypes::Url.new(
+          :url   => video.url,
+          :text  => video.title,
+          :title => video.title
+        )
+        video.return_types << APR::ReturnTypes::Iframe.new(
+          :url    => "//player.vimeo.com/video/#{data['id']}",
+          :text   => video.title,
+          :title  => video.title,
+          :width  => 640,
+          :height => 360
+        )
+
+        video
+      end
+
+    end
+  end
+end

data/lib/active_public_resources/drivers/youtube.rb

@@ -0,0 +1,113 @@
+require 'net/https'
+
+module ActivePublicResources
+  module Drivers
+    class Youtube < Driver
+
+      def perform_request(request_criteria)
+        request_criteria.validate_presence!([:query])
+
+        uri = URI('https://gdata.youtube.com/feeds/api/videos')
+        params = {
+          'v'           => 2,
+          'q'           => request_criteria.query,
+          'orderby'     => sort(request_criteria.sort),
+          'alt'         => 'json',
+          'safeSearch'  => content_filter(request_criteria.content_filter),
+          'start-index' => request_criteria.page || 1,
+          'max-results' => request_criteria.per_page || 25
+        }
+
+        uri.query = URI.encode_www_form(params)
+
+        res = Net::HTTP.get_response(uri)
+        results = JSON.parse(res.body)
+        
+        return parse_results(request_criteria, results)
+      end
+
+    private
+
+      def sort(val)
+        case val
+          when APR::RequestCriteria::SORT_RELEVANCE
+            'relevance'
+          when APR::RequestCriteria::SORT_RECENT
+            'relevance'
+          when APR::RequestCriteria::SORT_POPULAR
+            'relevance'
+          else
+            'relevance'
+        end
+      end
+
+      def content_filter(val)
+        case val
+          when APR::RequestCriteria::CONTENT_FILTER_NONE
+            'strict'
+          when APR::RequestCriteria::CONTENT_FILTER_STRICT
+            'strict'
+          else
+            'strict'
+        end
+      end
+
+      def parse_results(request_criteria, results)
+        @driver_response = DriverResponse.new(
+          :criteria      => request_criteria,
+          :next_criteria => next_criteria(request_criteria, results),
+          :total_items   => results['feed']['openSearch$totalResults']['$t'].to_i,
+          :items         => results['feed']['entry'].map { |data| parse_video(data) }
+        )
+      end
+
+      def next_criteria(request_criteria, results)
+        page     = results['feed']['openSearch$startIndex']['$t'].to_i
+        per_page = results['feed']['openSearch$itemsPerPage']['$t'].to_i
+        total    = results['feed']['openSearch$totalResults']['$t'].to_i
+        if ((page * per_page) < total)
+          return RequestCriteria.new({
+            :query    => request_criteria.query,
+            :page     => page + 1,
+            :per_page => per_page
+          })
+        end
+      end
+
+      def parse_video(data)
+        video_id = data['id']['$t'].split(':').last
+        video = APR::ResponseTypes::Video.new
+        video.id            = video_id
+        video.title         = data['title']['$t']
+        video.description   = data['media$group']['media$description']['$t']
+        video.thumbnail_url = data['media$group']['media$thumbnail'][0]['url']
+        video.url           = data['media$group']['media$player']['url']
+        video.duration      = data['media$group']['yt$duration']['seconds'].to_i
+        video.num_views     = data['yt$statistics'] ? data['yt$statistics']['viewCount'].to_i : 0
+        video.num_likes     = data['yt$rating'] ? data['yt$rating']['numLikes'].to_i : 0
+        video.num_comments  = data['gd$comments'] ? data['gd$comments']['gd$feedLink']['countHint'] : 0
+        video.created_date  = Date.parse(data['published']['$t'])
+        video.username      = data['author'][0]['name']['$t']
+        video.width         = 640
+        video.height        = 360
+
+        # Return Types
+        video.return_types << APR::ReturnTypes::Url.new(
+          :url   => video.url,
+          :text  => video.title,
+          :title => video.title
+        )
+        video.return_types << APR::ReturnTypes::Iframe.new(
+          :url    => "//www.youtube.com/embed/#{video_id}?feature=oembed",
+          :text   => video.title,
+          :title  => video.title,
+          :width  => 640,
+          :height => 360
+        )
+
+        video
+      end
+
+    end
+  end
+end

data/lib/active_public_resources/request_criteria.rb

@@ -0,0 +1,51 @@
+module ActivePublicResources
+  class RequestCriteria
+
+    SORTS = [
+      SORT_RELEVANCE = 'relevance',
+      SORT_RECENT    = 'recent',
+      SORT_POPULAR   = 'popular'
+    ]
+
+    CONTENT_FILTERS = [
+      CONTENT_FILTER_NONE   = 'none',
+      CONTENT_FILTER_STRICT = 'strict'
+    ]
+
+    attr_accessor :query, :page, :per_page, :content_filter, :sort, :folder
+
+    def initialize(args={})
+      args.each do |k,v|
+        if k.to_s == 'sort' && !SORTS.include?(v)
+          raise ArgumentError.new("sort is invalid. Must be in [#{SORTS.join(', ')}]")
+        end
+        if k.to_s == 'content_filter' && !CONTENT_FILTERS.include?(v)
+          raise ArgumentError.new("content_filter is invalid. Must be in [#{CONTENT_FILTERS.join(', ')}]")
+        end
+        instance_variable_set("@#{k}", v) unless v.nil?
+      end
+    end
+
+    def sort=(val)
+      unless SORTS.include?(val)
+        raise ArgumentError.new("is invalid. Must be in [#{SORTS.join(', ')}]")
+      end
+      @sort = val
+    end
+
+    def content_filter=(val)
+      unless CONTENT_FILTERS.include?(val)
+        raise ArgumentError.new("is invalid. Must be in [#{CONTENT_FILTERS.join(', ')}]")
+      end
+      @content_filter = val
+    end
+
+    def validate_presence!(attr_names)
+      attr_names.each do |k|
+        if instance_variable_get("@#{k}").blank?
+          raise ArgumentError.new("must include #{attr_names.join(', ')}")
+        end
+      end
+    end
+  end
+end

data/lib/active_public_resources/response_types/exercise.rb

@@ -0,0 +1,11 @@
+module ActivePublicResources
+  module ResponseTypes
+    class Exercise < BaseResponseType
+      attr_accessor :thumbnail_url, :url
+
+      def kind
+        'exercise'
+      end
+    end
+  end
+end