lcms-engine 0.1.0

data/app/helpers/lcms/engine/application_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'webpacker/helper'
+
+module Lcms
+  module Engine
+    module ApplicationHelper
+      include ViewHelper
+      include ::Webpacker::Helper
+
+      def current_webpacker_instance
+        Lcms::Engine.webpacker
+      end
+    end
+  end
+end

data/app/helpers/lcms/engine/documents_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module DocumentsHelper
+      def toc_time(time)
+        time.zero? ? raw('—') : "#{time} mins"
+      end
+    end
+  end
+end

data/app/helpers/lcms/engine/download_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module DownloadHelper
+      def file_icon(type)
+        %w(excel doc pdf powerpoint zip).include?(type) ? type : 'unknown'
+      end
+    end
+  end
+end

data/app/helpers/lcms/engine/media_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module MediaHelper
+      def embed_media(resource)
+        if resource.video?
+          embed_video(resource.embed_video_url)
+        elsif resource.podcast?
+          embed_podcast = resource.embed_podcast
+          embed_podcast.try(:html_safe) || resource.url
+        end
+      end
+
+      def embed_video(embed_url)
+        content_tag(:iframe, nil, src: embed_url, allowfullscreen: true, frameborder: 0)
+      end
+    end
+  end
+end

data/app/helpers/lcms/engine/pages_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module PagesHelper
+      def standardsinstitutes_link
+        @standardsinstitutes_link ||= link_to(
+          t('ui.learn_more'),
+          'http://www.standardsinstitutes.org/',
+          class: 'o-btn o-btn--register o-btn--xs-full u-margin-bottom--zero', target: '_blank'
+        )
+      end
+    end
+  end
+end

data/app/helpers/lcms/engine/resource_helper.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module ResourceHelper
+      include Lcms::Engine::Engine.routes.url_helpers
+
+      def show_resource_path(resource)
+        if resource.slug.present?
+          show_with_slug_path(resource.slug)
+        else
+          resource_path(resource)
+        end
+      end
+
+      def type_name(resource)
+        resource.curriculum_type&.capitalize
+      end
+
+      def back_to_resource_path(resource)
+        slug = resource.lesson? && resource.parent ?  resource.parent.slug : resource.slug
+        CGI.unescape(explore_curriculum_index_path(p: slug, e: 1))
+      end
+
+      def copyrights_text(object)
+        cc_descriptions = []
+        object.copyrights.each do |copyright|
+          cc_descriptions << copyright.value.strip if copyright.value.present?
+        end
+        object.copyrights.pluck(:disclaimer).uniq.each do |disclaimer|
+          cc_descriptions << disclaimer.strip if disclaimer.present?
+        end
+        cc_descriptions.join(' ')
+      end
+
+      def download_per_category_limit
+        ResourceDownload::DOWNLOAD_PER_CATEGORY_LIMIT
+      end
+
+      def download_heap_data(download, opts = {})
+        {
+          category: download.download_category&.title,
+          url: download.download.filename.url
+        }.merge(opts).to_json
+      end
+
+      def resource_breadcrumbs_with_links(resource)
+        return GenericPresenter.new(resource).generic_title if resource.generic?
+
+        breadcrumbs = Breadcrumbs.new(resource)
+        pieces = breadcrumbs.full_title.split(' / ')
+        short_pieces = breadcrumbs.short_title.split(' / ')
+
+        [].tap do |result|
+          pieces.each_with_index do |piece, idx|
+            result << piece && next if idx.zero?
+
+            slug = Slug.build_from(pieces[0..idx])
+
+            link = link_to show_with_slug_path(slug) do
+              show = content_tag(:span, piece, class: 'show-for-ipad')
+              short_piece = idx == pieces.size - 1 ? piece : short_pieces[idx]
+              hide = content_tag(:span, short_piece, class: 'hide-for-ipad')
+              "#{show} #{hide}".html_safe
+            end
+
+            result << link
+          end
+        end.join(' / ').html_safe
+      end
+
+      def prerequisites_standards(resource)
+        ids = StandardLink
+                .where(standard_end_id: resource.standards.pluck(:id))
+                .where.not(link_type: 'c')
+                .pluck(:standard_begin_id)
+        Standard
+          .where(id: ids).pluck(:alt_names).flatten.uniq
+          .map { |n| Standard.filter_ccss_standards(n, resource.subject) }.compact.sort
+      end
+
+      def bundle_heap_data(resource, bundle, cat, content_type)
+        {
+          resource_id: resource.id,
+          resource_title: resource.title,
+          url: bundle.file&.url.presence || bundle.url,
+          category: cat,
+          type: content_type
+        }.to_json
+      end
+    end
+  end
+end

data/app/helpers/lcms/engine/tags_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module TagsHelper
+      TAG_GROUPS = {
+        ccss_standards: 'CCSS Standard',
+        ccss_domain: 'CCSS Domain',
+        ccss_cluster: 'CCSS Cluster',
+        texts: 'Texts',
+        authors: 'Authors'
+      }.freeze
+
+      def render_tag_clouds(resource)
+        named_tags = resource.filtered_named_tags
+        render partial: 'lcms/engine/resources/tags',
+               locals: { tag_clouds: tag_clouds(named_tags), color_code: color_code(resource) }
+      end
+
+      def tag_clouds(named_tags)
+        named_tags[:ell_appropriate] = named_tags[:ell_appropriate] ? 'ELL Appropriate' : nil
+        named_tags.transform_values { |v| Array.wrap(v).flatten.compact.uniq.sort }
+      end
+
+      def each_tags_cloud!(tag_clouds)
+        tags = tag_clouds.keep_if { |k, v| TAG_GROUPS.key?(k) && v.present? }
+        tags.each { |k, v| yield(v, TAG_GROUPS[k]) }
+        yield([], nil) if tags.empty?
+      end
+    end
+  end
+end

data/app/helpers/lcms/engine/view_helper.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module ViewHelper # rubocop:disable Metrics/ModuleLength
+      ENABLE_BASE64_CACHING = ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(
+        ENV.fetch('ENABLE_BASE64_CACHING', true)
+      )
+
+      def add_class_for_path(link_path, klass, klass_prefix = nil)
+        [
+          klass_prefix,
+          current_page?(link_path) ? klass : nil
+        ].compact.join(' ')
+      end
+
+      def add_class_for_action(controller_name, action_name, klass, klass_prefix = nil)
+        if controller.controller_name == controller_name.to_s && controller.action_name == action_name.to_s
+          sufix = klass
+        end
+        "#{klass_prefix} #{sufix}"
+      end
+
+      def nav_link(link_text, link_path, attrs = {}, link_attrs = {})
+        cls = add_class_for_path(link_path, 'active', attrs[:class])
+        content_tag(:li, attrs.merge(class: cls)) { link_to link_text, link_path, link_attrs }
+      end
+
+      def flash_to_hash
+        result = { message: nil, message_type: 'alert', status: false }
+        flash.to_hash.slice('notice', 'alert').each do |name, message|
+          result = { message: result[:message].present? ? "#{result.message}\n#{message}" : message,
+                     message_type: name, status: true }
+        end
+        result
+      end
+
+      def header_mod
+        controller.controller_name
+      end
+
+      def page_title
+        page_content_for :page_title
+      end
+
+      def page_description
+        page_content_for :description
+      end
+
+      def page_og_image
+        if content_for?(:og_image)
+          page_og_image = content_for(:og_image)
+        else
+          controller = controller_path.tr('/', '.')
+          page_og_image = t("#{controller}.#{action_name}.og_image", default: t('default_og_image'))
+        end
+        page_og_image
+      end
+
+      # Render meta tag
+      def redirect_meta_tag
+        content_for(:redirect_meta_tag) if content_for?(:redirect_meta_tag)
+      end
+
+      # Use in views as redirection directive
+      def redirect_via_meta_tag(to_url:, delay: 5)
+        content_for(:redirect_meta_tag) do
+          content_tag(:meta, nil, { content: "#{delay};url=#{to_url}", 'http-equiv' => 'refresh' }, true)
+        end
+      end
+
+      def set_page_title(title) # rubocop:disable Naming/AccessorMethodName
+        content_for :page_title do
+          title
+        end
+      end
+
+      def set_page_description(dsc) # rubocop:disable Naming/AccessorMethodName
+        content_for :description do
+          dsc
+        end
+      end
+
+      def set_canonical_url(value) # rubocop:disable Naming/AccessorMethodName
+        content_for(:canonical_url, value)
+      end
+
+      def base64_encoded_asset(path)
+        AssetHelper.base64_encoded path, cache: ENABLE_BASE64_CACHING
+      end
+
+      def inlined_asset(path)
+        AssetHelper.inlined path
+      end
+
+      def strip_tags_and_squish(str)
+        return unless str.respond_to? :squish
+
+        strip_tags(str).squish
+      end
+
+      def generic_page?
+        controller.controller_name == 'resources' && controller.action_name == 'generic'
+      end
+
+      def set_social_media_sharing(target) # rubocop:disable Naming/AccessorMethodName
+        @social_media_presenter = SocialMediaPresenter.new(target: target, view: self)
+      end
+
+      def social_media
+        @social_media_presenter || SocialMediaPresenter.new(target: nil, view: self)
+      end
+
+      def color_code(model, base: false)
+        subject_color_code = model.try(:subject) || 'default'
+        grade_avg = base ? 'base' : model.grades.average
+        "#{subject_color_code}-#{grade_avg}"
+      end
+
+      def selected_id?(id)
+        selected_ids = params[:selected_ids]
+        return unless selected_ids.present?
+
+        case selected_ids
+        when Array then
+          selected_ids.include?(id.to_s)
+        else
+          selected_ids.split(',').include?(id.to_s)
+        end
+      end
+
+      def lcms_engine_url_helpers
+        @lcms_engine_url_helpers ||= Lcms::Engine::Engine.routes.url_helpers
+      end
+
+      private
+
+      def page_content_for(type)
+        if content_for?(type)
+          content = content_for(type)
+        else
+          controller = controller_path.tr('/', '.')
+          type = type.to_s.gsub(/^page_/, '')
+          content = t("#{controller}.#{action_name}.page_#{type}", default: t("default_#{type}"))
+        end
+        strip_tags_and_squish(content)
+      end
+    end
+  end
+end

data/app/interactors/lcms/engine/base_interactor.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    # Base interactor to be used on the controllers
+    # Usage:
+    #
+    #   class MyController
+    #     def my_action
+    #       interactor = MyInteractor.call(self)
+    #       if interactor.success?
+    #           # do something
+    #       else
+    #           # use interactor.error
+    #       end
+    class BaseInteractor
+      def self.call(context)
+        interactor = new(context)
+        interactor.run
+        interactor
+      end
+
+      attr_reader :error
+
+      def initialize(context)
+        @context = context
+      end
+
+      def success?
+        @error.nil?
+      end
+
+      def run
+        raise NotImplementedError
+      end
+
+      protected
+
+      attr_reader :context
+
+      def fail!(error)
+        @error = error
+      end
+
+      def params
+        context.params
+      end
+    end
+  end
+end

data/app/interactors/lcms/engine/enhance_instruction_interactor.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    class EnhanceInstructionInteractor < BaseInteractor
+      TAB_INDEX = %i(instructions videos generic).freeze
+
+      attr_reader :props
+
+      def run
+        @props = pagination.serialize(data, serializer)
+        @props.merge!(filterbar.props)
+        @props.merge!(tab: active_tab)
+      end
+
+      private
+
+      def filterbar
+        @filterbar ||= Filterbar.new(params)
+      end
+
+      def pagination
+        @pagination ||= Pagination.new(params)
+      end
+
+      def active_tab
+        @active_tab ||= (params[:tab] || 0).to_i
+      end
+
+      def tab(name)
+        TAB_INDEX.index(name)
+      end
+
+      def data
+        case active_tab
+        when tab(:videos) then resources(:media)
+        else resources(:generic_resources)
+        end
+      end
+
+      def serializer
+        ResourceInstructionSerializer
+      end
+
+      def resources(type)
+        scope = Resource
+                  .send(type)
+                  .where_subject(filterbar.subjects)
+                  .where_grade(filterbar.grades)
+
+        scope = if type == :media
+                  scope.order(created_at: :desc)
+                else
+                  scope.ordered
+                end
+
+        scope.paginate(pagination.params(strict: true))
+      end
+    end
+  end
+end