Merge pull request #65 from Dantemss/created_before

Added published_before to the exercise search API

Author: Dantemss

app/controllers/api/v1/exercises_controller.rb

@@ -45,6 +45,8 @@ class ExercisesController < OpenStax::Api::V1::ApiController
       * `number` &ndash; Matches the exercise number exactly.
       * `version` &ndash; Matches the exercise version exactly.
       * `id` &ndash; Matches the exercise ID exactly.
+      * `published_before` &ndash; Matches exercises published before the given date.
+                                   Enclose date in quotes to avoid parsing errors.
 
       You can also add search terms without prefixes, separated by spaces.
       These terms will be searched for in all of the prefix categories.
@@ -56,7 +58,7 @@ class ExercisesController < OpenStax::Api::V1::ApiController
 
       `content:DTFT` &ndash; returns exercises containing the DTFT word.
 
-      `number:1 version:2` &ndash; returns e1v2.
+      `number:1 version:2` &ndash; returns exercise 1@2.
     EOS
     param :order_by, String, desc: <<-EOS
       A string that indicates how to sort the results of the query. The string

app/models/publication.rb

@@ -25,6 +25,8 @@ class Publication < ActiveRecord::Base
 
   default_scope { order{[number.asc, version.desc]} }
 
+  scope :published, -> { where{published_at != nil} }
+
   def uid
     "#{number}@#{version}"
   end

app/routines/search_exercises.rb

@@ -10,28 +10,31 @@ class SearchExercises
     'number' => Publication.arel_table[:number],
     'version' => Publication.arel_table[:version],
     'title' => :title,
-    'created_at' => :created_at
+    'created_at' => :created_at,
+    'updated_at' => :updated_at,
+    'published_at' => Publication.arel_table[:published_at]
   }
 
   protected
 
   def exec(params = {}, options = {})
     params[:ob] ||= [{number: :asc}, {version: :desc}]
+    relation = Exercise.visible_for(options[:user])
 
-    # By default, only return the latest exercises.
+    # By default, only return the latest exercises visible to the user.
     # If either versions or uids are specified, this "latest" condition is disabled.
-    latest_only = true
-    run(:search, relation: Exercise.visible_for(options[:user]).preloaded,
+    latest_scope = relation
+
+    run(:search, relation: relation.preloaded,
                  sortable_fields: SORTABLE_FIELDS,
                  params: params) do |with|
       with.default_keyword :content
 
       with.keyword :id, :uid do |ids|
-        latest_only = false
-
         ids.each do |id|
           sanitized_ids = to_string_array(id).collect{|id| id.split('@')}
           next @items = @items.none if sanitized_ids.empty?
+
           sanitized_numbers = sanitized_ids.collect{|sid| sid.first}.compact
           sanitized_versions = sanitized_ids.collect{|sid| sid.second}.compact
           if sanitized_numbers.empty?
@@ -42,31 +45,38 @@ def exec(params = {}, options = {})
             @items = @items.where(publication: {number: sanitized_numbers,
                                                 version: sanitized_versions})
           end
+
+          # Since we are returning specific uids, disable "latest"
+          latest_scope = nil
         end
       end
 
       with.keyword :number do |numbers|
         numbers.each do |number|
           sanitized_numbers = to_string_array(numbers)
           next @items = @items.none if sanitized_numbers.empty?
+
           @items = @items.where(publication: {number: sanitized_versions})
         end
       end
 
       with.keyword :version do |versions|
-        latest_only = false
-
         versions.each do |version|
           sanitized_versions = to_string_array(version)
           next @items = @items.none if sanitized_versions.empty?
+
           @items = @items.where(publication: {version: sanitized_versions})
+
+          # Since we are returning specific versions, disable "latest"
+          latest_scope = nil
         end
       end
 
       with.keyword :tag do |tags|
         tags.each do |tag|
           sanitized_tags = to_string_array(tag).collect{|t| t.downcase}
           next @items = @items.none if sanitized_tags.empty?
+
           @items = @items.joins(:tags)
                          .where(tags: {name: sanitized_tags})
         end
@@ -77,6 +87,7 @@ def exec(params = {}, options = {})
           sanitized_titles = to_string_array(title, append_wildcard: true,
                                                     prepend_wildcard: true)
           next @items = @items.none if sanitized_titles.empty?
+
           @items = @items.where{title.like_any sanitized_titles}
         end
       end
@@ -86,6 +97,7 @@ def exec(params = {}, options = {})
           sanitized_contents = to_string_array(content, append_wildcard: true,
                                                         prepend_wildcard: true)
           next @items = @items.none if sanitized_contents.empty?
+
           @items = @items.joins{[questions.outer.stems.outer, questions.outer.answers.outer]}
                          .where{
                            (title.like_any sanitized_contents) |\
@@ -102,6 +114,7 @@ def exec(params = {}, options = {})
           sanitized_solutions = to_string_array(solution, append_wildcard: true,
                                                           prepend_wildcard: true)
           next @items = @items.none if sanitized_solutions.empty?
+
           @items = @items.joins(:solutions)
                          .where{(solutions.summary.like_any sanitized_solutions) |\
                                 (solutions.details.like_any sanitized_solutions)}
@@ -112,6 +125,7 @@ def exec(params = {}, options = {})
         names.each do |name|
           sn = to_string_array(name, append_wildcard: true)
           next @items = @items.none if sn.empty?
+
           @items = @items.joins(publication: {authors: {user: :account}})
                          .where{
                            (publication.authors.user.account.username.like_any sn) |\
@@ -126,6 +140,7 @@ def exec(params = {}, options = {})
         names.each do |name|
           sn = to_string_array(name, append_wildcard: true)
           next @items = @items.none if sn.empty?
+
           @items = @items.joins(publication: {copyright_holders: {user: :account}})
                          .where{
                            (publication.copyright_holders.user.account.username.like_any sn) |\
@@ -140,6 +155,7 @@ def exec(params = {}, options = {})
         names.each do |name|
           sn = to_string_array(name, append_wildcard: true)
           next @items = @items.none if sn.empty?
+
           @items = @items.joins(publication: {editors: {user: :account}})
                          .where{
                            (publication.editors.user.account.username.like_any sn) |\
@@ -154,6 +170,7 @@ def exec(params = {}, options = {})
         names.each do |name|
           sn = to_string_array(name, append_wildcard: true)
           next @items = @items.none if sn.empty?
+
           @items = @items.joins{publication.outer.authors.outer.user.outer.account.outer}
                          .joins{publication.outer.copyright_holders.outer.user.outer.account.outer}
                          .joins{publication.outer.editors.outer.user.outer.account.outer}
@@ -173,10 +190,24 @@ def exec(params = {}, options = {})
                          }
         end
       end
+
+      with.keyword :published_before do |published_befores|
+        min_published_before = published_befores.flatten.collect do |str|
+          DateTime.parse(str) rescue nil
+        end.compact.min
+        next @items = @items.none if min_published_before.nil?
+
+        @items = @items.where{publication.published_at < min_published_before}
+
+        # Latest now refers to results that happened before min_published_before
+        latest_scope = latest_scope.where{publication.published_at < min_published_before} \
+          unless latest_scope.nil?
+      end
     end
 
-    return unless latest_only
-    outputs[:items] = outputs[:items].latest
+    return if latest_scope.nil?
+
+    outputs[:items] = outputs[:items].latest(latest_scope)
     outputs[:total_count] = outputs[:items].limit(nil).offset(nil).reorder(nil).count
   end
 end

lib/publishable.rb

@@ -44,18 +44,19 @@ def publishable(options = {})
             }
 
             # http://stackoverflow.com/a/7745635
-            scope :latest, -> {
-              class_name = name
-
+            scope :latest, ->(publishable_scope = nil,
+                              publication_scope = Publication.unscoped.published) {
               joins(:publication).joins{
-                Publication.unscoped
-                  .as(:same_number)
-                  .on{ (same_number.publishable_type == my{class_name}) & \
-                       (same_number.number == ~publication.number) & \
-                       (same_number.version > ~publication.version) & \
-                       (same_number.published_at != nil) }
-                  .outer
-              }.where{same_number.id == nil}
+                pub_rel = publication_scope.where(publishable_type: my{name})
+                pub_rel = pub_rel.where(
+                  publishable_id: publishable_scope.limit(nil).reorder(nil).pluck(:id)
+                ) unless publishable_scope.nil?
+
+                pub_rel.as(:newer_publication)
+                       .on{ (newer_publication.number == ~publication.number) & \
+                            (newer_publication.version > ~publication.version) }
+                       .outer
+              }.where{newer_publication.id == nil}
             }
 
             after_initialize :build_publication, unless: [:persisted?, :publication]

spec/routines/search_exercises_spec.rb

@@ -142,6 +142,51 @@
       expect(outputs.total_count).to eq 1
       expect(outputs.items).to eq [new_exercise_2]
     end
+
+    it 'changes the definition of "latest" if published_before is specified' do
+      new_exercise = Exercise.new
+      Api::V1::ExerciseRepresenter.new(new_exercise).from_json({
+        tags: ['tag2', 'tag3'],
+        title: "Lorem ipsum",
+        stimulus: "Dolor",
+        questions: [{
+          stimulus: "Sit amet",
+          stem_html: "Consectetur adipiscing elit",
+          answers: [{
+            content_html: "Sed do eiusmod tempor"
+          }]
+        }]
+      }.to_json)
+      new_exercise.publication.number = @exercise_1.publication.number
+      new_exercise.publication.version = @exercise_1.publication.version + 1
+      new_exercise.save!
+
+      result = SearchExercises.call(q: 'tag:tAg1')
+      expect(result.errors).to be_empty
+
+      outputs = result.outputs
+      expect(outputs.total_count).to eq 1
+      expect(outputs.items).to eq [@exercise_1]
+
+      new_exercise.publication.publish
+      new_exercise.publication.save!
+
+      result = SearchExercises.call(q: 'tag:tAg1')
+      expect(result.errors).to be_empty
+
+      outputs = result.outputs
+      expect(outputs.total_count).to eq 0
+      expect(outputs.items).to eq []
+
+      result = SearchExercises.call(
+        q: "tag:tAg1 published_before:\"#{new_exercise.published_at.as_json}\""
+      )
+      expect(result.errors).to be_empty
+
+      outputs = result.outputs
+      expect(outputs.total_count).to eq 1
+      expect(outputs.items).to eq [@exercise_1]
+    end
   end
 
   context "multiple matches" do