lcms-engine 0.1.0

data/app/controllers/lcms/engine/admin/curriculums_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module Admin
+      class CurriculumsController < AdminController
+        def edit
+          @curriculum = CurriculumPresenter.new
+        end
+
+        def update
+          @form = CurriculumForm.new(params[:curriculum])
+          if @form.save
+            redirect_to admin_path, notice: t('.success')
+          else
+            @curriculum = CurriculumPresenter.new
+            render :edit, alert: t('.error')
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/lcms/engine/admin/documents_controller.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'lt/lcms/lesson/downloader/gdoc'
+
+module Lcms
+  module Engine
+    module Admin
+      class DocumentsController < AdminController
+        include Lcms::Engine::GoogleCredentials
+        include Reimportable
+
+        before_action :find_selected, only: %i(destroy_selected reimport_selected)
+
+        def index
+          @query = OpenStruct.new(params[:query])
+          @documents = DocTemplate.config['queries']['document'].constantize.call(@query, page: params[:page])
+          render_customized_view
+        end
+
+        def create
+          if gdoc_files.size > 1
+            bulk_import gdoc_files
+            return render :import
+          end
+
+          @document = reimport_lesson
+          if @document.save
+            redirect_to AdminController.document_path(@document.document),
+                        notice: t('.success', name: @document.document.name)
+          else
+            render :new, alert: t('.error')
+          end
+        end
+
+        def destroy
+          @document = Document.find(params[:id])
+          @document.destroy
+          redirect_to admin_documents_path(query: params[:query]), notice: t('.success')
+        end
+
+        def destroy_selected
+          count = @documents.destroy_all.count
+          redirect_to admin_documents_path(query: params[:query]), notice: t('.success', count: count)
+        end
+
+        def import_status
+          data = import_status_for DocumentGenerator.document_parse_job
+          render json: data, status: :ok
+        end
+
+        def new
+          @document = DocumentForm.new
+        end
+
+        def reimport_selected
+          bulk_import @documents
+          render :import
+        end
+
+        private
+
+        def bulk_import(docs)
+          reimport_materials = params[:with_materials].to_i.nonzero?
+          jobs = docs.each_with_object({}) do |doc, jobs_|
+            job_id = DocumentGenerator.document_parse_job
+                       .perform_later(doc, reimport_materials: reimport_materials).job_id
+            link = doc.is_a?(Document) ? doc.file_url : doc
+            jobs_[job_id] = { link: link, status: 'waiting' }
+          end
+          @props = { jobs: jobs, type: :documents, links: view_links }
+        end
+
+        def find_selected
+          return head(:bad_request) unless params[:selected_ids].present?
+
+          ids = params[:selected_ids].split(',')
+          @documents = Document.where(id: ids)
+        end
+
+        def gdoc_files
+          @gdoc_files ||= begin
+            link = form_params[:link]
+            if link.match?(%r{/drive/(.*/)?folders/})
+              folder_id = ::Lt::Google::Api::Drive.folder_id_for(link)
+              ::Lt::Google::Api::Drive.new(google_credentials)
+                .list_file_ids_in(folder_id)
+                .map { |id| Lt::Lcms::Lesson::Downloader::Gdoc.gdoc_file_url(id) }
+            else
+              [link]
+            end
+          end
+        end
+
+        def form_params
+          @form_params ||=
+            begin
+              data = params.require(:document_form).permit(:link, :link_fs, :reimport, :with_materials)
+              data.delete(:with_materials) if data[:with_materials].to_i.zero?
+              data
+            end
+        end
+
+        def reimport_lesson
+          reimport_lesson_materials if form_params[:with_materials].present?
+
+          DocumentForm.new form_params.except(:with_materials)
+        end
+
+        def reimport_lesson_materials
+          file_id = ::Lt::Lcms::Lesson::Downloader::Base.file_id_for form_params['link']
+          doc = Document.actives.find_by(file_id: file_id)
+          return unless doc
+
+          doc.materials.each do |material|
+            MaterialForm.new({ link: material.file_url, source_type: material.source_type }, google_credentials).save
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/lcms/engine/admin/google_oauth2_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module Admin
+      class GoogleOauth2Controller < AdminController
+        skip_before_action :authenticate_admin!
+
+        def callback
+          redirect_to Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request)
+        end
+      end
+    end
+  end
+end

data/app/controllers/lcms/engine/admin/materials_controller.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module Admin
+      class MaterialsController < AdminController
+        include Lcms::Engine::GoogleCredentials
+        include Reimportable
+
+        before_action :find_selected, only: %i(destroy_selected reimport_selected)
+
+        def index
+          @query = OpenStruct.new params[:query]
+          @materials = DocTemplate.config['queries']['material'].constantize.call(@query, page: params[:page])
+          render_customized_view
+        end
+
+        def create
+          return bulk_import(gdoc_files) && render(:import) if gdoc_files.size > 1
+
+          @material_form = DocumentGenerator.material_form.new(form_params)
+          if @material_form.save
+            material = @material_form.material
+            redirect_to AdminController.material_path(material.id), notice: t('.success', name: material.name)
+          else
+            render :new
+          end
+        end
+
+        def destroy
+          material = Material.find(params[:id])
+          material.destroy
+          redirect_to admin_materials_path(query: params[:query]), notice: t('.success')
+        end
+
+        def destroy_selected
+          count = @materials.destroy_all.count
+          redirect_to admin_materials_path(query: params[:query]), notice: t('.success', count: count)
+        end
+
+        def import_status
+          data = import_status_for DocumentGenerator.material_parse_job
+          render json: data, status: :ok
+        end
+
+        def new
+          @material_form = MaterialForm.new(source_type: params[:source_type].presence || 'gdoc')
+        end
+
+        def reimport_selected
+          bulk_import @materials.map(&:file_url)
+          render :import
+        end
+
+        private
+
+        def bulk_import(files)
+          jobs = {}
+          files.each do |url|
+            job_id = DocumentGenerator.material_parse_job.perform_later(url).job_id
+            jobs[job_id] = { link: url, status: 'waiting' }
+          end
+          @props = { jobs: jobs, type: :materials, links: view_links }
+        end
+
+        def find_selected
+          return head(:bad_request) unless params[:selected_ids].present?
+
+          ids = params[:selected_ids].split(',')
+          @materials = Material.where(id: ids)
+        end
+
+        def form_params
+          params.require(:material_form).permit(:link, :source_type)
+        end
+
+        def gdoc_files
+          @gdoc_files ||= begin
+            link = form_params[:link]
+            return [link] unless link =~ %r{/drive/(.*/)?folders/}
+
+            folder_id = ::Lt::Google::Api::Drive.folder_id_for(link)
+            if form_params[:source_type] == 'pdf'
+              mime_type = Lt::Lcms::Lesson::Downloader::PDF::MIME_TYPE
+              ::Lt::Google::Api::Drive.new(google_credentials)
+                .list_file_ids_in(folder_id, mime_type: mime_type)
+                .map { |id| Lt::Lcms::Lesson::Downloader::PDF.gdoc_file_url(id) }
+            else
+              ::Lt::Google::Api::Drive.new(google_credentials)
+                .list_file_ids_in(folder_id)
+                .map { |id| Lt::Lcms::Lesson::Downloader::Gdoc.gdoc_file_url(id) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/lcms/engine/admin/pages_controller.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module Admin
+      class PagesController < AdminController
+        before_action :find_resource, except: %i(index new create)
+
+        def index
+          @pages = Page.order(id: :desc)
+        end
+
+        def new
+          @page = Page.new
+        end
+
+        def create
+          @page = Page.new(page_params)
+
+          if @page.save
+            redirect_to page_url(@page), notice: t('.success')
+          else
+            render :new
+          end
+        end
+
+        def edit; end
+
+        def update
+          if @page.update_attributes(page_params)
+            redirect_to page_url(@page), notice: t('.success')
+          else
+            render :edit
+          end
+        end
+
+        def destroy
+          @page.destroy
+          redirect_to :admin_pages, notice: t('.success')
+        end
+
+        private
+
+        def find_resource
+          @page = Page.find(params[:id])
+        end
+
+        def page_params
+          params.require(:page).permit(:body, :title, :slug)
+        end
+      end
+    end
+  end
+end

data/app/controllers/lcms/engine/admin/resource_bulk_edits_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module Admin
+      class ResourceBulkEditsController < AdminController
+        before_action :load_resources
+
+        def new
+          if @resources.any?
+            @resource = BulkEditResourcesService.new(@resources).init_sample
+          else
+            redirect_to :admin_resources, alert: t('.no_resources')
+          end
+        end
+
+        def create
+          BulkEditResourcesService.new(@resources, resource_params).edit!
+          resources_count_msg = t(:resources_count, count: @resources.count)
+          notice = t('.success', count: @resources.count, resources_count: resources_count_msg)
+          redirect_to :admin_resources, notice: notice
+        end
+
+        private
+
+        def load_resources
+          @resources = Resource.where(id: params[:ids]).includes(:standards)
+        end
+
+        def resource_params
+          params.require(:resource)
+            .permit(standard_ids: [],
+                    grades: [],
+                    resource_type_list: [],
+                    tag_list: [])
+        end
+      end
+    end
+  end
+end

data/app/controllers/lcms/engine/admin/resource_picker_controller.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module Admin
+      class ResourcePickerController < AdminController
+        def index
+          @resources = Resource.where(nil)
+
+          @resources = @resources.where_subject(index_params[:subject]) if index_params[:subject].present?
+          @resources = @resources.where(curriculum_type: index_params[:type]) if index_params[:type].present?
+          @resources = @resources.where_grade(grade_name) if index_params[:grade].present?
+          @resources = @resources.where('title ilike ?', "%#{params[:q]}%") if index_params[:q].present?
+
+          @resources = @resources.paginate(pagination.params(strict: true)).order('resources.title asc')
+
+          respond_to do |format|
+            format.json { render json: pagination.serialize(@resources, ResourcePickerSerializer) }
+          end
+        end
+
+        private
+
+        def index_params
+          @index_params ||= begin
+            default_params = { type: nil, subject: nil, grade: nil, q: nil }
+            expected_params = params.slice(:type, :subject, :grade, :q).symbolize_keys
+            index_p = default_params.merge(expected_params)
+
+            grade_ok = index_p[:grade].blank? || Filterbar::GRADES.include?(index_p[:grade])
+            type_ok = index_p[:type].blank? || Resource.hierarchy.include?(index_p[:type].to_sym)
+            subject_ok = index_p[:subject].blank? || Resource::SUBJECTS.include?(index_p[:subject])
+
+            raise StandardError unless grade_ok && type_ok && subject_ok
+
+            index_p
+          end
+        end
+
+        def pagination
+          @pagination ||= Pagination.new(params)
+        end
+
+        def grade_name
+          if index_params[:grade].casecmp('K').zero?
+            'kindergarten'
+          elsif index_params[:grade].casecmp('PK').zero?
+            'prekindergarten'
+          elsif !index_params[:grade].start_with?('grade')
+            "grade #{index_params[:grade]}"
+          else
+            index_params[:grade]
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/lcms/engine/admin/resources_controller.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Lcms
+  module Engine
+    module Admin
+      class ResourcesController < AdminController
+        CREATE_TAG_KEYS = %i(new_topic_names new_tag_names new_content_source_names
+                             new_standard_names).freeze
+        CREATE_TAG_METHODS = {
+          new_topic_names: 'topic',
+          new_tag_names: 'tag',
+          new_content_source_names: 'content_source'
+        }.freeze
+
+        before_action :find_resource, except: %i(index new create)
+
+        def index
+          @query = Resource.ransack(params[:q].try(:except, :grades))
+          resources = @query.result.includes(:standards)
+          resources = resources.where_grade(grade_params) if grade_params.present?
+          @resources = resources.order(id: :desc).paginate(page: params[:page], per_page: 15)
+        end
+
+        def new
+          @resource = Resource.new
+        end
+
+        def create
+          @resource = Resource.new(resource_params)
+
+          if @resource.save
+            create_tags
+            redirect_to :admin_resources, notice: t('.success', resource_id: @resource.id)
+          else
+            render :new
+          end
+        end
+
+        def edit; end
+
+        def export_to_lti_cc
+          # TODO: Later may need to extend this check to allow unit export as well
+          return redirect_to :back, notice: 'Unsupported resource type' unless @resource.module?
+
+          data = LtiExporter.perform @resource
+          filename = "#{@resource.slug.parameterize}.zip"
+          send_data data, filename: filename, type: 'application/zip', disposition: 'attachment'
+        end
+
+        def bundle
+          return redirect_to :admin_resources, notice: t('.fail') unless can_bundle?(@resource)
+
+          # see settings loaded via `lcms.yml`
+          generator = DocTemplate.config.dig('bundles', @resource.curriculum_type).constantize
+          generator.perform(@resource)
+          redirect_to :admin_resources, notice: t('.success')
+        end
+
+        def update
+          unless Settings[:editing_enabled]
+            return redirect_to(:admin_resources, alert: t('admin.common.editing_disabled'))
+          end
+
+          create_tags
+          Array.wrap(create_params[:new_standard_names]).each do |std_name|
+            std = Standard.create_with(subject: @resource.subject).find_or_create_by!(name: std_name)
+            resource_params[:standard_ids] << std.id
+          end
+
+          if @resource.update_attributes(resource_params)
+            redirect_to :admin_resources, notice: t('.success', resource_id: @resource.id)
+          else
+            render :edit
+          end
+        end
+
+        def destroy
+          @resource.destroy
+          redirect_to :admin_resources, notice: t('.success', resource_id: @resource.id)
+        end
+
+        private
+
+        def can_bundle?(resource)
+          DocTemplate
+            .config['bundles'].keys
+            .detect { |type| resource.send "#{type}?" }
+            .present?
+        end
+        helper_method :can_bundle?
+
+        def find_resource
+          @resource = Resource.includes(resource_downloads: :download).find(params[:id])
+        end
+
+        def grade_params
+          params.fetch(:q, {}).fetch(:grades, []).select(&:present?)
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def form_params
+          @form_params ||=
+            begin
+              download_categories_settings =
+                DownloadCategory.select(:title).map do |category|
+                  { category.title.parameterize => %i(show_long_description show_short_description) }
+                end
+              ps = params.require(:resource).permit(
+                :curriculum_type,
+                :directory,
+                :parent_id,
+                :tree,
+                :description,
+                :hidden,
+                :resource_type,
+                :short_title,
+                :subtitle,
+                :title,
+                :teaser,
+                :url,
+                :time_to_teach,
+                :ell_appropriate,
+                :image_file,
+                :opr_description,
+                additional_resource_ids: [],
+                common_core_standard_ids: [],
+                download_categories_settings: download_categories_settings,
+                resource_downloads_attributes: [
+                  :_destroy,
+                  :description,
+                  :id,
+                  :download_category_id, { download_attributes: %i(description file main filename_cache id title) }
+                ],
+                related_resource_ids: [],
+                standard_ids: [],
+                new_standard_names: [],
+                topic_ids: [],
+                tag_ids: [],
+                content_source_ids: [],
+                reading_assignment_text_ids: [],
+                new_topic_names: [],
+                new_tag_names: [],
+                new_content_source_names: []
+              )
+              if ps[:download_categories_settings].present?
+                ps[:download_categories_settings].transform_values! do |settings|
+                  settings.transform_values! { |x| x == '1' }
+                end
+              end
+              ps[:metadata] = metadata ps.delete(:directory)&.split(',')
+              ps
+            end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def metadata(directory)
+          return {} unless @resource.present?
+
+          @resource.metadata.merge Resource.metadata_from_dir(directory)
+        end
+
+        def resource_params
+          @resource_params ||= form_params.except(*CREATE_TAG_KEYS)
+        end
+
+        def create_params
+          @create_params ||= form_params.slice(*CREATE_TAG_KEYS)
+        end
+
+        def create_tags
+          CREATE_TAG_METHODS.each do |params_key, basename|
+            Array.wrap(create_params[params_key]).each do |name|
+              @resource.send("#{basename}_list").push(name) if name.present?
+            end
+          end
+        end
+      end
+    end
+  end
+end