now can round trip queries from a case to a book and back again by pr…

…eserving all query attributes on query_doc_pairs

app/controllers/api/v1/books/populate_controller.rb

@@ -27,8 +27,14 @@ def update
             query_doc_pair.position = pair[:position]
             query_doc_pair.document_fields = pair[:document_fields].to_json
 
+            query = @case.queries.find_by(query_text: query_doc_pair.query_text)
+
+            query_doc_pair.information_need = query.information_need
+            query_doc_pair.notes = query.notes
+            query_doc_pair.options = query.options
+
             if pair[:rating]
-              rating = @case.queries.find_by(query_text: query_doc_pair.query_text).ratings.find_by(doc_id: query_doc_pair.doc_id)
+              rating = query.ratings.find_by(doc_id: query_doc_pair.doc_id)
 
               # we are smart and just look up the correct user id from rating.user_id via the database, no API data needed.
               judgement = query_doc_pair.judgements.find_or_create_by user_id: rating.user_id

app/models/book.rb

@@ -30,6 +30,9 @@ class Book < ApplicationRecord
                           join_table: 'teams_books'
   # rubocop:enable Rails/HasAndBelongsToMany
 
+  belongs_to :owner,
+             class_name: 'User', optional: true
+
   belongs_to :selection_strategy
   belongs_to :scorer
   has_many :query_doc_pairs, dependent: :destroy, autosave: true

app/models/query_doc_pair.rb

@@ -4,14 +4,17 @@
 #
 # Table name: query_doc_pairs
 #
-#  id              :bigint           not null, primary key
-#  document_fields :text(65535)
-#  position        :integer
-#  query_text      :string(500)
-#  created_at      :datetime         not null
-#  updated_at      :datetime         not null
-#  book_id         :bigint           not null
-#  doc_id          :string(500)
+#  id               :bigint           not null, primary key
+#  document_fields  :text(65535)
+#  information_need :string(255)
+#  notes            :text(65535)
+#  options          :text(65535)
+#  position         :integer
+#  query_text       :string(500)
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#  book_id          :bigint           not null
+#  doc_id           :string(500)
 #
 # Indexes
 #
@@ -30,4 +33,6 @@ class QueryDocPair < ApplicationRecord
   validates :position, numericality: { only_integer: true }, allow_nil: true
 
   scope :has_judgements, -> { joins(:judgements) }
+
+  serialize :options, coder: JSON
 end

app/services/ratings_manager.rb

@@ -22,7 +22,7 @@ def sync_ratings_for_query_doc_pair query_doc_pair
   end
 
   def sync_ratings_for_case kase
-    @book.rated_query_doc_pairs.each do |query_doc_pair|
+    @book.query_doc_pairs.each do |query_doc_pair|
       sync_judgements_to_ratings kase, query_doc_pair
     end
   end
@@ -33,12 +33,24 @@ def sync_ratings_for_case kase
   # rubocop:disable Metrics/CyclomaticComplexity
   def sync_judgements_to_ratings kase, query_doc_pair
     query = Query.find_or_initialize_by(case: kase, query_text: query_doc_pair.query_text)
+
     return if query.new_record? && !options[:create_missing_queries]
 
+    if query.new_record?
+      query.information_need = query_doc_pair.information_need
+      query.notes = query_doc_pair.notes
+      query.options = query_doc_pair.options
+
+      @queries_created += 1
+    end
+
+    query.save
+
     count_of_judgements = query_doc_pair.judgements.rateable.size
-    summed_rating = query_doc_pair.judgements.rateable.sum(&:rating)
+
     # only calculate this if we have valid judgements.  If everything is unrateable, then don't proceed.
     if count_of_judgements.positive?
+      summed_rating = query_doc_pair.judgements.rateable.sum(&:rating)
 
       rating = Rating.find_or_initialize_by(query: query, doc_id: query_doc_pair.doc_id)
       rating.user = query_doc_pair.judgements.last.user if rating.user.nil?
@@ -49,11 +61,10 @@ def sync_judgements_to_ratings kase, query_doc_pair
                         (summed_rating / count_of_judgements).round
                       end
 
-      @queries_created += 1 if query.new_record?
       @ratings_created += 1 if rating.new_record?
 
       rating.save
-      query.save
+
     end
   end
   # rubocop:enable Metrics/AbcSize

db/migrate/20231222115905_add_all_query_attributes_to_query_docs.rb

@@ -0,0 +1,15 @@
+class AddAllQueryAttributesToQueryDocs < ActiveRecord::Migration[7.1]
+  # As we do more automatic syncing of books and cases it becomes more
+  # apparent that having "query" and "ratings" as seperate tables for supporting Cases,
+  # while having "query_doc_pair" and "judgements" for supporting Books is
+  # maybe not the right way.   
+  # 
+  # Here we are adding some columns to "query_doc_pair" that exist on "query"
+  # so that when we have a Case, and we populate the Book, and then
+  # create a NEW Case, we have these fields from the original Case.
+  def change
+    add_column :query_doc_pairs, :information_need, :string
+    add_column :query_doc_pairs, :notes, :text
+    add_column :query_doc_pairs, :options, :text
+  end
+end

test/fixtures/books.yml

@@ -31,7 +31,12 @@ book_of_comedy_films:
   selection_strategy: :single_rater
   name: TMDB Greatest Comedies
 
-james_bond_movies:   # this has some query doc pairs and ratings.
+james_bond_movies:
   scorer: :quepid_default_scorer
   selection_strategy: :multiple_raters
   name: James Bond Movies
+
+empty_book:
+  scorer: :quepid_default_scorer
+  selection_strategy: :single_rater
+  name: Empty Book

test/fixtures/queries.yml

@@ -90,9 +90,16 @@ query_for_best_bond_ever:
   query_text:   Best Bond Ever
   information_need: I am looking for Sean Connery as the actor, as he was the best!
   arranged_at:  3
+  options:      '{"special_boost": 3.2}'
 
 query_for_best_bond_ever2:
   case:         :random_case_1
   query_text:   Best Bond Ever
   information_need: I am looking for Sean Connery as the actor, as he was the best!
   arranged_at:  1
+
+query_for_case_with_book:
+  case:         :case_with_book
+  query_text:   star wars
+  information_need: I am looking for the movies, with them in order of release, except for the newest should be at the top
+  arranged_at:  1

test/fixtures/query_doc_pairs.yml

@@ -2,14 +2,17 @@
 #
 # Table name: query_doc_pairs
 #
-#  id              :bigint           not null, primary key
-#  document_fields :text(65535)
-#  position        :integer
-#  query_text      :string(500)
-#  created_at      :datetime         not null
-#  updated_at      :datetime         not null
-#  book_id         :bigint           not null
-#  doc_id          :string(500)
+#  id               :bigint           not null, primary key
+#  document_fields  :text(65535)
+#  information_need :string(255)
+#  notes            :text(65535)
+#  options          :text(65535)
+#  position         :integer
+#  query_text       :string(500)
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#  book_id          :bigint           not null
+#  doc_id           :string(500)
 #
 # Indexes
 #

test/fixtures/teams.yml

@@ -31,7 +31,7 @@ shared:
   scorers:  shared_scorer, shared_scorer1, shared_scorer2
   cases:    shared_with_team
   search_endpoints: one, for_shared_team_case
-  books:    james_bond_movies, book_of_star_wars_judgements
+  books:    james_bond_movies, book_of_star_wars_judgements, empty_book
 
 case_finder_owned_team:
   name:     An team owned by the Case Finder User

test/integration/api/case_to_book_to_case_flow_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class CaseToBookToCaseFlowTest < ActionDispatch::IntegrationTest
+  include ActionMailer::TestHelper
+
+  let(:kase) { cases(:random_case) }
+  let(:book) { books(:empty_book) }
+  let(:team) { teams(:shared) }
+  let(:user) { users(:doug) }
+
+  test 'Create a book from a case, and then create a new case from that book' do
+    post users_login_url params: { user: { email: user.email, password: 'password' }, format: :json }
+
+    kase.owner = user
+    kase.save!
+
+    book.owner = user
+    book.save!
+
+    # populate the book
+    data = {
+      book_id:         book.id,
+      case_id:         kase.id,
+      query_doc_pairs: [
+        {
+          query_text:      'Best Bond Ever',
+          doc_id:          'https://www.themoviedb.org/movie/708-the-living-daylights',
+          position:        0,
+          document_fields: {
+            title: 'The Living Daylights',
+            year:  '1987',
+          },
+        }
+      ],
+    }
+
+    put api_book_populate_url book, params: data
+
+    assert_response :no_content
+
+    response.parsed_body
+
+    # the new Case that we will populate from a book...
+    new_case = Case.create(case_name: 'test case', owner: user)
+
+    put api_book_case_refresh_url book, new_case, params: { create_missing_queries: true }
+
+    response.parsed_body
+
+    new_case.reload
+    assert_not_empty new_case.queries
+
+    old_query = kase.queries.find_by(query_text: 'Best Bond Ever')
+    new_query = new_case.queries.find_by(query_text: 'Best Bond Ever')
+
+    assert_not_equal old_query.arranged_next, new_query.arranged_next
+
+    assert_equal old_query.information_need, new_query.information_need
+    assert_equal old_query.notes, new_query.notes
+    assert_equal old_query.options, new_query.options
+  end
+end

test/models/book_test.rb

@@ -29,12 +29,15 @@ class BookTest < ActiveSupport::TestCase
     let(:user)                  { users(:random) }
     let(:team)                  { teams(:shared) }
     let(:book1)                 { books(:james_bond_movies) }
-    let(:book2)                 { books(:book_of_star_wars_judgements) }
+    let(:book2)                 { books(:empty_book) }
 
-    it 'returns books by alphabetical name of book for a team' do
-      assert_equal book1, team.books.first
-      assert_equal book2, team.books.second
-    end
+    # not sure this is actually important?  Why would we care at this level?
+    # it 'returns books by alphabetical name of book for a team' do
+    #  puts team.books.first.name
+    #  puts team.books.second.name
+    #  assert_equal book2, team.books.first
+    #  assert_equal book1, team.books.second
+    # end
   end
 
   describe 'sampling random query doc pairs' do

test/models/query_doc_pair_test.rb

@@ -4,14 +4,17 @@
 #
 # Table name: query_doc_pairs
 #
-#  id              :bigint           not null, primary key
-#  document_fields :text(65535)
-#  position        :integer
-#  query_text      :string(500)
-#  created_at      :datetime         not null
-#  updated_at      :datetime         not null
-#  book_id         :bigint           not null
-#  doc_id          :string(500)
+#  id               :bigint           not null, primary key
+#  document_fields  :text(65535)
+#  information_need :string(255)
+#  notes            :text(65535)
+#  options          :text(65535)
+#  position         :integer
+#  query_text       :string(500)
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#  book_id          :bigint           not null
+#  doc_id           :string(500)
 #
 # Indexes
 #

test/services/ratings_importer_test.rb

@@ -122,15 +122,15 @@ class RatingsImporterTest < ActiveSupport::TestCase
   test 'handles when a doc id does not exist in our index, it is still inserted' do
     ratings = [
       { query_text: 'Swedish Food',   doc_id: ' 720784-021190', rating: nil },
-      { query_text: 'Swedish Food',   doc_id: 'NON_EXISTANT_DOC_ID', rating: '6' }
+      { query_text: 'Swedish Food',   doc_id: 'NON_EXISTANT_DOC_IDzzz', rating: '6' }
     ]
 
     ratings_importer = RatingsImporter.new owned_case, ratings, options
     ratings_importer.import
     rating = Rating.find_by(doc_id: '720784-021190')
     assert_nil(rating)
 
-    rating = Rating.find_by(doc_id: 'NON_EXISTANT_DOC_ID')
+    rating = Rating.find_by(doc_id: 'NON_EXISTANT_DOC_IDzzz')
     assert_not_nil(rating)
     assert_equal 'Swedish Food', rating.query.query_text
   end