Optimized the way we fetch involved people. Added scope to prefetch t…

…hem.

app/controllers/admin_controller.rb

@@ -285,6 +285,7 @@ def translated_from_multiple_languages
 
   def incongruous_copyright
     @incong = Manifestation.joins(expression: :work)
+                           .with_involved_authorities
                            .select('expressions.id as expression_id, expressions.intellectual_property')
                            .select('manifestations.title, manifestations.id as id')
                            .select(Arel.sql("#{HAS_NON_PUBLIC_DOMAIN_AUTHORITY} as has_non_pd_authority"))

app/models/expression.rb

@@ -23,11 +23,11 @@ class Expression < ApplicationRecord
   validates :intellectual_property, presence: true
 
   def editors
-    return realizers.includes(:person).where(role: Realizer.roles[:editor]).map{|x| x.person}
+    realizers.to_a.select(&:editor?).map(&:person)
   end
 
   def translators
-    return realizers.includes(:person).where(role: Realizer.roles[:translator]).map {|x| x.person}
+    realizers.to_a.select(&:translator?).map(&:person)
   end
 
   def self.cached_translations_count

app/models/manifestation.rb

@@ -33,6 +33,7 @@ class Manifestation < ApplicationRecord
   scope :translations, -> { joins(:expression).includes(:expression).where(expressions: {translation: true})}
   scope :genre, -> (genre) { joins(expression: :work).where(works: {genre: genre})}
   scope :tagged_with, ->(tag_id) {joins(:taggings).where(taggings: {tag_id: tag_id, status: Tagging.statuses[:approved]}).distinct}
+  scope :with_involved_authorities, -> { preload(expression: { realizers: :person, work: { creations: :person } }) }
 
   SHORT_LENGTH = 1500 # kind of arbitrary...
   LONG_LENGTH = 15000 # kind of arbitrary...

app/models/work.rb

@@ -18,11 +18,11 @@ class Work < ApplicationRecord
   # has_and_belongs_to_many :people # superseded by creations and persons above
 
   def authors
-    return creations.author.includes(:person).map(&:person)
+    return creations.to_a.select(&:author?).map(&:person)
   end
 
   def illustrators
-    return creations.illustrator.includes(:person).map(&:person)
+    return creations.to_a.select(&:illustrator?).map(&:person)
   end
 
   def first_author