lcms-engine 0.1.0

data/app/models/lcms/engine/reading_assignment_author.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class ReadingAssignmentAuthor < ActiveRecord::Base
+      has_many :reading_assignment_texts
+    end
+  end
+end

data/app/models/lcms/engine/reading_assignment_text.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class ReadingAssignmentText < ActiveRecord::Base
+      has_many :resource_reading_assignments
+      has_many :resources, through: :resource_reading_assignments
+
+      belongs_to :reading_assignment_author
+      alias_attribute :author, :reading_assignment_author
+    end
+  end
+end

data/app/models/lcms/engine/resource.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class Resource < ActiveRecord::Base
+      enum resource_type: {
+        resource: 1,
+        podcast: 2,
+        video: 3,
+        quick_reference_guide: 4,
+        text_set: 5,
+        resource_other: 6
+      }
+
+      MEDIA_TYPES = %i(video podcast).map { |t| resource_types[t] }.freeze
+      GENERIC_TYPES = %i(text_set quick_reference_guide resource_other).map { |t| resource_types[t] }.freeze
+
+      SUBJECTS = %w(ela math lead).freeze
+      HIERARCHY = %i(subject grade module unit lesson).freeze
+
+      include Searchable
+      include Navigable
+
+      mount_uploader :image_file, ResourceImageUploader
+
+      acts_as_taggable_on :content_sources, :download_types, :resource_types, :tags, :topics
+      has_closure_tree order: :level_position, dependent: :destroy, numeric_order: true
+
+      belongs_to :parent, class_name: 'Lcms::Engine::Resource', foreign_key: 'parent_id'
+
+      belongs_to :author
+      belongs_to :curriculum
+
+      # Additional resources
+      has_many :resource_additional_resources, dependent: :destroy
+      has_many :additional_resources, through: :resource_additional_resources
+
+      has_many :resource_standards, dependent: :destroy
+      has_many :standards, through: :resource_standards
+
+      # Downloads.
+      has_many :resource_downloads, dependent: :destroy
+      has_many :downloads, through: :resource_downloads
+      accepts_nested_attributes_for :resource_downloads, allow_destroy: true
+
+      # Reading assignments.
+      has_many :resource_reading_assignments, dependent: :destroy
+      alias_attribute :reading_assignments, :resource_reading_assignments
+      has_many :reading_assignment_texts, through: :resource_reading_assignments
+
+      # Related resources.
+      has_many :resource_related_resources, dependent: :destroy
+      has_many :related_resources, through: :resource_related_resources, class_name: 'Resource'
+      has_many :resource_related_resources_as_related,
+               class_name: 'ResourceRelatedResource',
+               foreign_key: 'related_resource_id',
+               dependent: :destroy
+
+      has_many :copyright_attributions, dependent: :destroy
+      has_many :social_thumbnails, as: :target
+      has_many :documents, dependent: :destroy
+
+      has_many :document_bundles, dependent: :destroy
+
+      validates :title, presence: true
+      validates :url, presence: true, url: true, if: %i(video? podcast?)
+
+      scope :where_grade, ->(grades) { where_metadata_in :grade, grades }
+      scope :where_module, ->(modules) { where_metadata_in :module, modules }
+      scope :where_subject, ->(subjects) { where_metadata_in :subject, subjects }
+      scope :media, -> { where(resource_type: MEDIA_TYPES) }
+      scope :generic_resources, -> { where(resource_type: GENERIC_TYPES) }
+      scope :ordered, -> { order(:hierarchical_position, :slug) }
+
+      before_save :update_metadata, :update_slug, :update_position
+
+      after_save :update_descendants_meta, :update_descendants_position,
+                 :update_descendants_tree, :update_descendants_author
+
+      before_destroy :destroy_additional_resources
+
+      class << self
+        # Define dynamic scopes for hierarchy levels.
+        # I,e: `grades`, `units`, etc
+        HIERARCHY.map(&:to_s).each do |level|
+          define_method(:"#{level.pluralize}") { where(curriculum_type: level) }
+        end
+
+        def metadata_from_dir(dir)
+          pairs = hierarchy[0...dir.size].zip(dir)
+          Hash[pairs].compact.stringify_keys
+        end
+
+        def find_by_directory(*dir)
+          dir = dir&.flatten&.select(&:present?)
+          return unless dir.present?
+
+          type = hierarchy[dir.size - 1]
+          meta = metadata_from_dir(dir).to_json
+          where('metadata @> ?', meta).where(curriculum_type: type).first
+        end
+
+        def find_podcast_by_url(url)
+          podcast.where(url: url).first
+        end
+
+        def find_video_by_url(url)
+          video_id = MediaEmbed.video_id(url)
+          video.where("url ~ '#{video_id}(&|$)'").first
+        end
+
+        def hierarchy
+          Lcms::Engine::Resource::HIERARCHY
+        end
+
+        # used for ransack search on the admin
+        def ransackable_scopes(_auth_object = nil)
+          %i(grades)
+        end
+
+        # return resources tree by a curriculum name
+        # if no argument is provided, then it's any curriculum tree.
+        def tree(name = nil)
+          if name.present?
+            joins(:curriculum).where('curriculums.name = ? OR curriculums.slug = ?', name, name)
+          elsif (default = Lcms::Engine::Curriculum.default)
+            where(curriculum_id: default.id)
+          else
+            where(nil)
+          end
+        end
+
+        def where_metadata_in(key, arr)
+          arr = Array.wrap arr
+          clauses = Array.new(arr.count) { "metadata->>'#{key}' = ?" }.join(' OR ')
+          where(clauses, *arr)
+        end
+      end
+
+      # Define predicate methods for subjects.
+      # I,e: #ela?, #math?, ..
+      SUBJECTS.each do |subject_name|
+        define_method(:"#{subject_name}?") { subject == subject_name.to_s }
+      end
+
+      # Define predicate methods for hierarchy levels.
+      # I,e: #subject?, #grade?, #lesson?, ...
+      HIERARCHY.each do |level|
+        define_method(:"#{level}?") { curriculum_type.present? && curriculum_type.casecmp(level.to_s).zero? }
+      end
+
+      def tree?
+        curriculum_id.present?
+      end
+
+      def assessment?
+        metadata['assessment'].present?
+      end
+
+      def media?
+        %w(video podcast).include? resource_type
+      end
+
+      def generic?
+        %w(text_set quick_reference_guide resource_other).include?(resource_type)
+      end
+
+      # `Optional prerequisite` - https://github.com/learningtapestry/unbounded/issues/557
+      def opr?
+        tag_list.include?('opr')
+      end
+
+      def prerequisite?
+        tag_list.include?('prereq')
+      end
+
+      def directory
+        @directory ||= Lcms::Engine::Resource.hierarchy.map do |key|
+          key == :grade ? grades.average(abbr: false) : metadata[key.to_s]
+        end.compact
+      end
+
+      def subject
+        metadata['subject']
+      end
+
+      def grades
+        Grades.new(self)
+      end
+
+      def grades=(gds)
+        metadata.merge! 'grade' => gds
+      end
+
+      def lesson_number
+        @lesson_number ||= short_title.match(/(\d+)/)&.[](1).to_i
+      end
+
+      def related_resources
+        @related_resources ||= resource_related_resources
+                                 .includes(:related_resource)
+                                 .order(:position)
+                                 .map(&:related_resource)
+      end
+
+      def download_categories
+        @download_categories ||=
+          resource_downloads.includes(:download_category).includes(:download)
+            .sort_by { |rd| rd.download_category&.position.to_i }
+            .group_by { |d| d.download_category&.title.to_s }
+            .transform_values { |v| v.sort_by { |d| [d.download.main ? 0 : 1, d.download.title] } }
+      end
+
+      def pdf_downloads?(category = nil)
+        if category.present?
+          resource_downloads.joins(:download)
+            .where(download_category: category)
+            .where(downloads: { content_type: 'application/pdf' })
+            .exists?
+        else
+          downloads.where(content_type: 'application/pdf').exists?
+        end
+      end
+
+      alias do_not_skip_indexing? should_index?
+      def should_index?
+        do_not_skip_indexing? && (tree? || media? || generic?)
+      end
+
+      def named_tags
+        {
+          keywords: (tag_list + topic_list).compact.uniq,
+          resource_type: resource_type,
+          ell_appropriate: ell_appropriate,
+          ccss_standards: tag_standards,
+          ccss_domain: nil, # resource.standards.map { |std| std.domain.try(:name) }.uniq
+          ccss_cluster: nil, #  resource.standards.map { |std| std.cluster.try(:name) }.uniq
+          authors: reading_assignment_texts.map { |t| t.author.try(:name) }.compact.uniq,
+          texts: reading_assignment_texts.map(&:name).uniq
+        }
+      end
+
+      def filtered_named_tags
+        filtered_named_tags = named_tags
+        stds = named_tags[:ccss_standards].map { |n| Standard.filter_ccss_standards(n, subject) }.compact
+        filtered_named_tags.merge(ccss_standards: stds)
+      end
+
+      def tag_standards
+        standards.map(&:alt_names).flatten.uniq
+      end
+
+      def copyrights
+        copyright_attributions
+      end
+
+      def document
+        documents.actives.order(updated_at: :desc).first
+      end
+
+      def document?
+        document.present?
+      end
+
+      def next_hierarchy_level
+        index = Lcms::Engine::Resource.hierarchy.index(curriculum_type.to_sym)
+        Lcms::Engine::Resource.hierarchy[index + 1]
+      end
+
+      def unit_bundles?
+        unit? && document_bundles.any?
+      end
+
+      def add_grade_author(author)
+        grade = grade? ? self : ancestors.detect(&:grade?)
+        raise 'Grade not found for this resource' unless grade
+
+        grade.author_id = author.is_a?(Integer) ? author : author.id
+        grade.save
+      end
+
+      def self_and_ancestors_not_persisted
+        # during create we can't call self_and_ancestors directly on the resource
+        # because this query uses the associations on resources_hierarchies
+        # which are only created after the resource is persisted
+        [self] + parent&.self_and_ancestors.to_a
+      end
+
+      def update_metadata
+        meta = self_and_ancestors_not_persisted
+                 .each_with_object({}) do |r, obj|
+          obj[r.curriculum_type] = r.short_title
+        end.compact
+        metadata.merge! meta if meta.present?
+      end
+
+      def update_position
+        self.hierarchical_position = HierarchicalPosition.new(self).position
+      end
+
+      private
+
+      def destroy_additional_resources
+        ResourceAdditionalResource.where(additional_resource_id: id).destroy_all
+      end
+
+      def update_descendants_author
+        # update only if a grade author has changed
+        return unless grade? && author_id_changed?
+
+        descendants.update_all author_id: author_id
+      end
+
+      def update_descendants_meta
+        # update only if is not a lesson (no descendants) and short_title has changed
+        return unless !lesson? && short_title_changed?
+
+        descendants.each do |r|
+          r.metadata[curriculum_type] = short_title
+          r.save
+        end
+      end
+
+      def update_descendants_position
+        # update only if is not a lesson (no descendants) and level_position has changed
+        return unless !lesson? && level_position_changed?
+
+        descendants.each { |r| r.update_position && r.save }
+      end
+
+      def update_descendants_tree
+        # update only if is not a lesson (no descendants) and `tree` has changed to false
+        return unless !lesson? && curriculum_id_changed? && !tree?
+
+        descendants.each { |r| r.update curriculum_id: nil }
+      end
+
+      def update_slug
+        self.slug = Slug.new(self).value
+      end
+    end
+  end
+end

data/app/models/lcms/engine/resource_additional_resource.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class ResourceAdditionalResource < ActiveRecord::Base
+      belongs_to :resource
+      belongs_to :additional_resource, class_name: 'Resource', foreign_key: 'additional_resource_id'
+    end
+  end
+end

data/app/models/lcms/engine/resource_download.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class ResourceDownload < ActiveRecord::Base
+      DOWNLOAD_PER_CATEGORY_LIMIT = 5
+
+      belongs_to :resource
+      belongs_to :download
+      belongs_to :download_category
+
+      validates :download, presence: true
+
+      accepts_nested_attributes_for :download
+    end
+  end
+end

data/app/models/lcms/engine/resource_reading_assignment.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class ResourceReadingAssignment < ActiveRecord::Base
+      belongs_to :reading_assignment_text
+      belongs_to :resource
+    end
+  end
+end

data/app/models/lcms/engine/resource_related_resource.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class ResourceRelatedResource < ActiveRecord::Base
+      belongs_to :resource
+      belongs_to :related_resource, class_name: 'Resource', foreign_key: 'related_resource_id'
+    end
+  end
+end

data/app/models/lcms/engine/resource_standard.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class ResourceStandard < ActiveRecord::Base
+      belongs_to :resource
+      belongs_to :standard
+    end
+  end
+end

data/app/models/lcms/engine/search/document.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'virtus'
+
+module Lcms
+  module Engine
+    module Search
+      class Document < ElasticSearchDocument
+        include Virtus.model
+
+        METADATA_FIELDS = %w(description teaser title lesson_objective).freeze
+
+        attribute :breadcrumbs, String
+        attribute :description, String
+        attribute :doc_type, String
+        attribute :document_metadata, String
+        attribute :grade, String
+        attribute :id, String
+        attribute :model_id, Integer
+        attribute :model_type, String
+        attribute :permalink, String
+        attribute :position, String
+        attribute :slug, String
+        attribute :subject, String
+        attribute :tag_authors, Array[String]
+        attribute :tag_keywords, Array[String]
+        attribute :tag_standards, Array[String]
+        attribute :tag_texts, Array[String]
+        attribute :teaser, String
+        attribute :title, String
+
+        class << self
+          def build_from(model)
+            if model.is_a?(Lcms::Engine::Resource)
+              new(**attrs_from_resource(model))
+
+            elsif model.is_a?(Lcms::Engine::ExternalPage)
+              new(**attrs_from_page(model))
+
+            else
+              raise "Unsupported Type for Search : #{model.class.name}"
+            end
+          end
+
+          def doc_type(model)
+            model.resource_type == 'resource' ? model.curriculum_type : model.resource_type
+          end
+
+          def document_metadata(model)
+            return unless model.document?
+
+            METADATA_FIELDS.map do |k|
+              value = model.document.metadata[k]
+              Nokogiri::HTML.fragment(value).text.presence
+            end.compact.join(' ')
+          end
+
+          # Position mask:
+          # - Since lessons uses 4 blocks of 2 numbers for (grade, mod, unit, lesson),
+          #   we use 5 blocks to place them after lessons.
+          # - the first position is realted to the resource type (always starting
+          #   with 9 to be placed after the lessons).
+          # - The second most significant is related to the grade
+          # - The last position is the number of different grades covered, i.e:
+          #   a resource with 3 different grades show after one with 2, (more specific
+          #   at the top, more generic at the bottom)
+          def grade_position(model)
+            if model.is_a?(Lcms::Engine::Resource) && model.generic?
+              rtype = model[:resource_type] || 0
+              # for generic resource use the min grade, instead the avg
+              grade_pos = model.grades.list.map { |g| Lcms::Engine::Grades::GRADES.index(g) }.compact.min || 0
+              last_pos = model.grades.list.size
+            else
+              rtype = 0
+              grade_pos = model.grades.average_number
+              last_pos = 0
+            end
+            first_pos = 90 + rtype
+
+            [first_pos, grade_pos, 0, 0, last_pos].map { |n| n.to_s.rjust(2, '0') }.join(' ')
+          end
+
+          def resource_position(model)
+            if model.media? || model.generic?
+              grade_position(model)
+            else
+              model.hierarchical_position
+            end
+          end
+
+          # Overrides ElasticSearchDocument.search to include standards search
+          def search(term, options = {})
+            return repository.empty_response unless repository.index_exists?
+            return repository.search(repository.all_query(options)) unless term.present?
+
+            repository.multisearch(
+              [
+                repository.standards_query(term, options),
+                repository.tags_query(term, [:tag_keywords], options),
+                repository.tags_query(term, %i(tag_authors tag_texts), options),
+                repository.fts_query(term, options)
+              ]
+            ).max_by(&:total)
+          end
+
+          private
+
+          def attrs_from_page(model)
+            {
+              description: model.description,
+              doc_type: 'page',
+              grade: [],
+              id: "page_#{model.slug}",
+              model_type: :page,
+              permalink: model.permalink,
+              slug: model.slug,
+              tag_keywords: model.keywords,
+              teaser: model.teaser,
+              title: model.title
+            }
+          end
+
+          def attrs_from_resource(model)
+            tags = model.named_tags
+
+            {
+              breadcrumbs: Lcms::Engine::Breadcrumbs.new(model).title,
+              description: model.description,
+              doc_type: doc_type(model),
+              document_metadata: document_metadata(model),
+              grade: model.grades.list,
+              id: "resource_#{model.id}",
+              model_id: model.id,
+              model_type: 'resource',
+              position: resource_position(model),
+              slug: model.slug,
+              subject: model.subject,
+              tag_authors: tags[:authors] || [],
+              tag_keywords: tags[:keywords] || [],
+              tag_standards: tags[:ccss_standards] || [],
+              tag_texts: tags[:texts] || [],
+              teaser: model.teaser,
+              title: model.title
+            }
+          end
+        end
+
+        def grades
+          @grades ||= Lcms::Engine::Grades.new(self)
+        end
+      end
+    end
+  end
+end