lcms-engine 0.1.0

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module Search
+      class ElasticSearchDocument
+        # return the corresponding repository
+        def self.repository
+          @repository ||= Lcms::Engine::Search::Repository.new
+        end
+
+        def repository
+          self.class.repository
+        end
+
+        def index!
+          repository.save self
+        end
+
+        def delete!
+          repository.delete self
+        end
+
+        # Default search
+        #
+        # term: [String || Nil]
+        #   - [Nil]    : return a match_all query
+        #   - [String] : perform a `fts_query` on the repository
+        #
+        # options: [Hash]
+        #   - per_page : number os results per page
+        #   - page     : results page number
+        #   - <filter> : any doc specific filters, e.g: 'grade', 'subject', etc
+        #
+        def self.search(term, options = {})
+          return [] unless repository.index_exists?
+
+          query = if term.present?
+                    repository.fts_query(term, options)
+                  else
+                    repository.all_query(options)
+                  end
+          repository.search query
+        end
+
+        # this is necessary for the ActiveModel::ArraySerializer#as_json method to work
+        # (used on the Pagination#serialize_with_pagination)
+        # NOTE: https://github.com/rails-api/active_model_serializers/issues/891
+        def read_attribute_for_serialization(key)
+          if key.try(:to_sym) == :id
+            attributes.fetch(key) { id }
+          else
+            attributes[key]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require 'elasticsearch/persistence'
+
+module Lcms
+  module Engine
+    module Search
+      def self.ngrams_multi_field
+        {
+          type: 'string', fields: {
+            full: { type: 'string', analyzer: 'full_str' },
+            partial: { type: 'string', analyzer: 'partial_str' },
+            key: { type: 'string', index: 'not_analyzed' }
+          }
+        }
+      end
+
+      def self.index_settings
+        {
+          analysis: {
+            filter: {
+              str_ngrams: { type: 'nGram', min_gram: 3, max_gram: 10 },
+              stop_en: { type: 'stop', stopwords: '_english_' }
+            },
+            analyzer: {
+              keyword_str: {
+                filter: ['lowercase'],
+                type: 'custom',
+                tokenizer: 'keyword'
+              },
+              full_str: {
+                filter: %w(standard lowercase stop_en asciifolding),
+                type: 'custom',
+                tokenizer: 'standard'
+              },
+              partial_str: {
+                filter: %w(standard lowercase stop_en asciifolding str_ngrams),
+                type: 'custom',
+                tokenizer: 'standard'
+              }
+            }
+          }
+        }
+      end
+
+      class Repository
+        include Elasticsearch::Persistence::Repository
+        include Elasticsearch::Persistence::Repository::DSL
+
+        client Elasticsearch::Client.new(host: ENV['ELASTICSEARCH_ADDRESS'])
+
+        index_name :"unbounded_documents_#{Rails.env}"
+
+        document_type :document
+
+        klass Lcms::Engine::Search::Document
+
+        settings index: Lcms::Engine::Search.index_settings do
+          mappings dynamic: 'false' do
+            indexes :breadcrumbs, type: 'string', index: 'not_analyzed'
+            indexes :description, **Lcms::Engine::Search.ngrams_multi_field
+            indexes :doc_type, type: 'string', index: 'not_analyzed' #  module | unit | lesson | video | etc
+            indexes :document_metadata, type: 'string'
+            indexes :grade, type: 'string', index: 'not_analyzed'
+            indexes :model_id, type: 'string', index: 'not_analyzed'
+            indexes :model_type, type: 'string', index: 'not_analyzed' # ActiveRecord model => resource only for now
+            indexes :position, type: 'string', index: 'not_analyzed'
+            indexes :subject, type: 'string', index: 'not_analyzed'
+            indexes :tag_authors, type: 'string'
+            indexes :tag_keywords, type: 'string'
+            indexes :tag_standards, type: 'string', analyzer: 'keyword_str'
+            indexes :tag_texts, **Lcms::Engine::Search.ngrams_multi_field
+            indexes :teaser, **Lcms::Engine::Search.ngrams_multi_field
+            indexes :title, **Lcms::Engine::Search.ngrams_multi_field
+          end
+        end
+
+        SYNONYMS = {
+          'text sets' => 'text set',
+          'expert pack' => 'expert packs'
+        }.freeze
+
+        def all_query(options)
+          limit = options.fetch(:per_page, 20)
+          page = options.fetch(:page, 1)
+
+          query = {
+            query: {
+              bool: {
+                must: { match_all: {} },
+                filter: []
+              }
+            },
+            sort: [
+              { subject: 'asc' },
+              { position: 'asc' },
+              { 'title.key' => 'asc' }
+            ],
+            size: limit,
+            from: (page - 1) * limit
+          }
+
+          apply_filters(query, options)
+        end
+
+        def fts_query(term, options)
+          return term if term.respond_to?(:to_hash)
+
+          limit = options.fetch(:per_page, 20)
+          page = options.fetch(:page, 1)
+          term = replace_synonyms term.downcase
+
+          query = {
+            min_score: 6,
+            query: {
+              bool: {
+                should: [
+                  { match: { 'title.full' => { query: term, boost: 3, type: 'phrase' } } },
+                  { match: { 'title.partial' => { query: term, boost: 0.5 } } },
+
+                  { match: { 'teaser.full' => { query: term, boost: 4, type: 'phrase' } } },
+
+                  { match: { document_metadata: { query: term, boost: 1 } } }
+                ],
+                filter: []
+              }
+            },
+            size: limit,
+            from: (page - 1) * limit
+          }
+
+          apply_filters(query, options)
+        end
+
+        def standards_query(term, options)
+          return term if term.respond_to?(:to_hash)
+
+          limit = options.fetch(:per_page, 20)
+          page = options.fetch(:page, 1)
+
+          query = {
+            query: {
+              bool: {
+                filter: [],
+                should: [
+                  { term: { tag_standards: term } },
+                  { match_phrase_prefix: { tag_standards: { query: term } } }
+                ],
+                minimum_should_match: 1
+              }
+            },
+            size: limit,
+            from: (page - 1) * limit
+          }
+
+          apply_filters query, options
+        end
+
+        def tags_query(term, tags, options)
+          return term if term.respond_to?(:to_hash)
+
+          limit = options.fetch(:per_page, 20)
+          page = options.fetch(:page, 1)
+
+          query = {
+            query: {
+              bool: {
+                filter: [],
+                should: tags.map { |t| { match: { t => term } } }.concat(
+                  [
+                    { match_phrase: { title: term } },
+                    { match_phrase: { teaser: term } }
+                  ]
+                ),
+                minimum_should_match: 1
+              }
+            },
+            size: limit,
+            from: (page - 1) * limit
+          }
+
+          apply_filters query, options
+        end
+
+        def accepted_filters
+          %i(model_type subject grade doc_type)
+        end
+
+        def apply_filters(query, options)
+          accepted_filters.each do |filter|
+            next unless options[filter]
+
+            filter_term = if options[filter].is_a? Array
+                            { terms: { filter => options[filter] } }
+                          else
+                            { match: { filter => { query: options[filter] } } }
+                          end
+            query[:query][:bool][:filter] << filter_term
+          end
+          query
+        end
+
+        def empty_response
+          Elasticsearch::Persistence::Repository::Response::Results.new(
+            self,
+            hits: { total: 0, max_score: nil, hits: [] }
+          )
+        end
+
+        def multisearch(queries)
+          body = queries.map { |query| { search: query } }
+          client.msearch(index: index, type: type, body: body)['responses'].map do |r|
+            Elasticsearch::Persistence::Repository::Response::Results.new(self, r)
+          end
+        end
+
+        def replace_synonyms(term)
+          SYNONYMS[term] || term
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class Settings < ActiveRecord::Base
+      class << self
+        def [](key)
+          settings.data[key.to_s]
+        end
+
+        def []=(key, value)
+          settings.update data: settings.data.merge(key.to_s => value)
+        end
+
+        private
+
+        def settings
+          last || create!(data: { editing_enabled: true })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class SocialThumbnail < ActiveRecord::Base
+      MEDIAS = %w(all facebook pinterest twitter).freeze
+
+      mount_uploader :image, SocialThumbnailUploader
+
+      belongs_to :target, polymorphic: true
+
+      validates :target, :media, presence: true
+      validates :media, inclusion: { in: MEDIAS }
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class StaffMember < ActiveRecord::Base
+      validates :first_name, :last_name, presence: true
+      validates :bio, length: { maximum: 4096 }
+      enum staff_type: { staff: 1, board: 2 }
+
+      scope :order_by_name, -> { order(:last_name) }
+      scope :order_by_name_with_precedence, -> { order(:order, :last_name) }
+
+      def name
+        "#{first_name} #{last_name}"
+      end
+
+      # mount_uploader :image_file, StaffImageUploader
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class Standard < ActiveRecord::Base
+      # NOTE: #954 - to be removed?
+      ALT_NAME_REGEX = {
+        'ela' => /^[[:alpha:]]+\.(k|pk|\d+)\.\d+(\.[[:alnum:]]+)?$/,
+        'math' => /^(k|pk|\d+)\.[[:alpha:]]+(\.[[:alpha:]]+)?\.\d+(\.[[:alpha:]]+)?$/
+      }.freeze
+
+      DOMAINS_GRADES = {
+        'K_8' => ['k'].concat((1..8).to_a.map(&:to_s)),
+        '9_12' => (9..12).to_a.map(&:to_s)
+      }.freeze
+
+      DOMAINS = {
+        'K_8' => {
+          'CC' => 'Counting & Cardinality',
+          'OA' => 'Operations & Algebraic Thinking',
+          'NBT' => 'Number & Operations in Base Ten',
+          'MD' => 'Measurement & Data',
+          'G' => 'Geometry',
+          'NF' => 'Number & Operations—Fractions',
+          'RP' => 'Ratios & Proportional Relationships',
+          'NS' => 'The Number System',
+          'EE' => 'Expressions & Equations',
+          'SP' => 'Statistics & Probability',
+          'F' => 'Functions'
+        },
+        '9_12' => {
+          'RN' => 'The Real Number System',
+          'Q' => 'Quantities*',
+          'CN' => 'The Complex Number System',
+          'VM' => 'Vector & Matrix Quantities',
+          'SSE' => 'Seeing Structure in Expressions',
+          'APR' => 'Arithmetic with Polynomials & Rational Expressions',
+          'CED' => 'Creating Equations*',
+          'REI' => 'Reasoning with Equations & Inequalities',
+          'IF' => 'Interpreting Functions',
+          'BF' => 'Building Functions',
+          'LE' => 'Linear, Quadratic, & Exponential Models*',
+          'TF' => 'Trigonometric Functions',
+          'CO' => 'Congruence',
+          'SRT' => 'Similarity, Right Triangles, & Trigonometry',
+          'C' => 'Circles',
+          'GPE' => 'Expressing Geometric Properties with Equations',
+          'GMD' => 'Geometric Measurement & Dimension',
+          'MG' => 'Modeling with Geometry',
+          'ID' => 'Interpreting Categorical & Quantitative Data',
+          'IC' => 'Making Inferences & Justifying Conclusions',
+          'CP' => 'Conditional Probability & the Rules of Probability',
+          'MD' => 'Using Probability to Make Decisions'
+        }
+      }.freeze
+
+      STRANDS = {
+        'L' => 'Language',
+        'RF' => 'Reading: Foundational Skills',
+        'RI' => 'Reading: Informational Text',
+        'RL' => 'Reading: Literature',
+        'SL' => 'Speaking & Listening',
+        'W' => 'Writing'
+      }.freeze
+
+      validates :name, presence: true
+
+      has_many :resource_standards, dependent: :destroy
+      has_many :resources, through: :resource_standards
+
+      # NOTE: #954 - to be removed
+      scope :by_grade, ->(grade) { by_grades [grade] }
+      # NOTE: #954 - to be removed
+      scope :by_grades, lambda { |grades|
+        joins(resource_standards: { resource: [:grades] })
+          .where('grades.id' => grades.map(&:id))
+      }
+
+      # NOTE: #954 - to be removed
+      scope :ela, -> { where(subject: 'ela') }
+      scope :math, -> { where(subject: 'math') }
+
+      # NOTE: #954 - to be removed?
+      def self.search_by_name(name)
+        where('name ILIKE :q OR alt_names::text ILIKE :q', q: "%#{name}%").order(:id)
+      end
+
+      # NOTE: #954 - to be removed?
+      def self.filter_ccss_standards(name, subject)
+        name&.match?(ALT_NAME_REGEX[subject]) ? name.upcase : nil
+      end
+
+      # NOTE: #954 - to be removed?
+      def short_name
+        alt_names.map { |n| self.class.filter_ccss_standards(n, subject) }.compact.try(:first) || name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class StandardLink < ActiveRecord::Base
+      belongs_to :standard_begin, class_name: 'Standard', foreign_key: 'standard_begin_id'
+      belongs_to :standard_end, class_name: 'Standard', foreign_key: 'standard_end_id'
+    end
+  end
+end