lcms-engine 0.1.0

data/lib/lti/thin_common_cartridge.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+#
+# Exporter in LTI Thin Common Cartridge format
+#
+module Lti
+  class ThinCommonCartridge
+    attr_reader :links
+
+    def initialize(items)
+      @items = Array.wrap items
+      @xml = File.open(File.expand_path MANIFEST_FILEPATH) { |f| Nokogiri::XML(f) }
+      @link_template = File.open(File.expand_path LTI_LINK_FILEPATH) { |f| Nokogiri::XML(f) }
+      @links = []
+
+      create_nodes
+    end
+
+    def create_nodes
+      # Build hierarchy of objects
+      root_item = xml.at 'organizations/organization/item'
+      items.each { |c| add_item c, root_item }
+    end
+
+    def manifest
+      xml.to_xml
+    end
+
+    private
+
+    LTI_LINK_RESOURCE_TYPE = 'imsbasiclti_xmlv1p0'
+    MANIFEST_FILEPATH = ::Lcms::Engine::Engine.root.join 'lib', 'lti', 'xml', 'imsmanifest.xml'
+    LTI_LINK_FILEPATH = ::Lcms::Engine::Engine.root.join 'lib', 'lti', 'xml', 'lti_link.xml'
+
+    attr_reader :items, :link_template, :xml
+
+    def add_item(item, parent)
+      item[:identifier] = "ub#{SecureRandom.hex(17)}"
+      item[:identifierref] = "#{item[:identifier]}_link"
+
+      params = {
+        identifier: item[:identifier],
+        identifierref: (item[:identifierref] if item[:url].present?)
+      }
+      node = create_node 'item', params
+      node.add_child %(<title>#{item[:title].capitalize}</title>)
+      parent.add_child node
+
+      item[:children].each { |c| add_item c, node }
+
+      add_resource(item) if item[:url].present?
+
+      node
+    end
+
+    def add_resource(item)
+      params = {
+        identifier: item[:identifierref],
+        type: LTI_LINK_RESOURCE_TYPE
+      }
+      node = create_node('resource', params)
+      resources_node.add_child node
+
+      href = "lti_links/#{item[:identifierref]}.xml"
+      create_link item, href
+
+      file_node = create_node 'file', href: href
+      node.add_child file_node
+    end
+
+    def create_link(item, file_href)
+      @link_template.at('//blti:launch_url').content = item[:url]
+      links << {
+        name: file_href,
+        data: @link_template.to_xml
+      }
+    end
+
+    def create_node(name, attrs = {})
+      node = Nokogiri::XML::Node.new name, xml
+      attrs.compact.each { |k, v| node[k.to_s] = v }
+      node
+    end
+
+    def resources_node
+      @resources_node ||=
+        begin
+          if (node = @xml.at 'resources').nil?
+            node = create_node 'resources'
+            xml.root.add_child node
+          end
+          node
+        end
+    end
+  end
+end

data/lib/lti/xml/imsmanifest.xml

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<manifest identifier="ia66e1d914465bb6a21929535b3f2dcc5" xmlns="http://www.imsglobal.org/xsd/imsccv1p1/imscp_v1p1"
+          xmlns:lomimscc="http://ltsc.ieee.org/xsd/imsccv1p1/LOM/manifest"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xsi:schemaLocation="http://www.imsglobal.org/xsd/imsccv1p1/imscp_v1p1 http://www.imsglobal.org/profile/cc/ccv1p1/ccv1p1_imscp_v1p2_v1p0.xsd http://ltsc.ieee.org/xsd/imsccv1p1/LOM/manifest http://www.imsglobal.org/profile/cc/ccv1p1/LOM/ccv1p1_lommanifest_v1p0.xsd">
+  <metadata>
+    <schema>IMS Common Cartridge</schema>
+    <schemaversion>1.1.0</schemaversion>
+    <lomimscc:lom>
+      <lomimscc:general>
+        <lomimscc:title>
+          <lomimscc:string>UnboundEd.org</lomimscc:string>
+        </lomimscc:title>
+      </lomimscc:general>
+      <lomimscc:lifeCycle>
+        <lomimscc:contribute>
+          <lomimscc:date>
+            <lomimscc:dateTime>2017-11-24</lomimscc:dateTime>
+          </lomimscc:date>
+        </lomimscc:contribute>
+      </lomimscc:lifeCycle>
+      <lomimscc:rights>
+        <lomimscc:copyrightAndOtherRestrictions>
+          <lomimscc:value>yes</lomimscc:value>
+        </lomimscc:copyrightAndOtherRestrictions>
+        <lomimscc:description>
+          <lomimscc:string>Private (Copyrighted) - http://en.wikipedia.org/wiki/Copyright</lomimscc:string>
+        </lomimscc:description>
+      </lomimscc:rights>
+    </lomimscc:lom>
+  </metadata>
+  <organizations>
+    <organization identifier="org_1" structure="rooted-hierarchy">
+      <item identifier="LearningModules"/>
+    </organization>
+  </organizations>
+  <resources/>
+</manifest>

data/lib/lti/xml/lti_link.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<cartridge_basiclti_link xmlns="http://www.imsglobal.org/xsd/imslticc_v1p0"
+                         xmlns:blti="http://www.imsglobal.org/xsd/imsbasiclti_v1p0"
+                         xmlns:lticp="http://www.imsglobal.org/xsd/imslticp_v1p0"
+                         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                         xsi:schemaLocation="http://www.imsglobal.org/xsd/imslticc_v1p0 http://www.imsglobal.org/xsd/lti/ltiv1p0/imslticc_v1p0.xsd             http://www.imsglobal.org/xsd/imsbasiclti_v1p0 http://www.imsglobal.org/xsd/lti/ltiv1p0/imsbasiclti_v1p0p1.xsd                           http://www.imsglobal.org/xsd/imslticp_v1p0 http://www.imsglobal.org/xsd/lti/ltiv1p0/imslticp_v1p0.xsd">
+  <blti:title>UnboundEd</blti:title>
+  <blti:description/>
+  <blti:launch_url>To be replaced during generation</blti:launch_url>
+  <blti:icon>Icon here</blti:icon>
+  <blti:vendor>
+    <lticp:code>UB</lticp:code>
+    <lticp:name>UnboundEd</lticp:name>
+  </blti:vendor>
+</cartridge_basiclti_link>

data/lib/resque_job.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ResqueJob
+  def self.included(base) # :nodoc:
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def find(job_id)
+      find_in_queue(job_id) || find_in_working(job_id)
+    end
+
+    def find_in_queue(job_id)
+      Resque.peek(queue_name, 0, 0)
+        .map { |job| job['args'].first }
+        .detect { |job| job['job_id'] == job_id }
+    end
+
+    def find_in_queue_by_payload(job_class, &block)
+      result = Resque.peek(:default, 0, 0)
+                 .select { |j| j['args'].first['job_class'] == job_class.to_s }
+                 .flat_map { |j| j['args'] }
+      return result unless block_given?
+
+      result.detect(&block)
+    end
+
+    def find_in_working(job_id)
+      Resque::Worker.working.map(&:job).detect do |job|
+        if job.is_a?(Hash) && (args = job.dig 'payload', 'args').is_a?(Array)
+          args.detect { |x| x['job_id'] == job_id }
+        end
+      end
+    end
+
+    def find_in_working_by_payload(job_class, &block)
+      result =
+        Resque::Worker.working.map(&:job).flat_map do |job|
+          next unless job.is_a?(Hash) && (args = job.dig 'payload', 'args').is_a?(Array)
+
+          args.select { |x| x['job_class'] == job_class.to_s }
+        end.compact
+      return result unless block_given?
+
+      result.detect(&block)
+    end
+
+    def fetch_result(job_id)
+      res = Resque.redis.multi do
+        key = result_key(job_id)
+        Resque.redis.get key
+        Resque.redis.del key
+      end.first
+      JSON.parse(res) rescue res
+    end
+
+    def result_key(job_id)
+      [Resque.redis.namespace, 'result', name.underscore, job_id].join(':')
+    end
+
+    def status(job_id)
+      if find_in_queue(job_id)
+        :waiting
+      elsif find_in_working(job_id)
+        :running
+      else
+        :done
+      end
+    end
+  end
+
+  def result_key
+    @result_key ||= self.class.result_key(job_id)
+  end
+
+  def store_initial_result(res, options = {})
+    key = self.class.result_key(options[:initial_job_id].presence || job_id)
+    Resque.redis.set(key, res.to_json, ex: 1.hour.to_i)
+  end
+
+  def store_result(res, options = {})
+    key = if (jid = options[:initial_job_id]).blank?
+            result_key
+          else
+            # store result with parent job id to retrieve the result later knowing only parent job id
+            [Resque.redis.namespace, 'result', self.class.name.underscore, jid, job_id].join(':')
+          end
+    Resque.redis.set(key, res.to_json, ex: 1.hour.to_i)
+  end
+end

data/lib/standard_importer.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+#
+# Import standards from db/data/standards_*.csv files
+#
+class StandardImporter
+  # @param [String] subject Should be `math` or `ela`
+  def initialize(subject)
+    @subject = subject.to_s
+    @source_file = "db/data/standards_#{subject}.csv"
+    raise 'Source file not found!' unless File.exist?(@source_file)
+  end
+
+  def run
+    content = File.read source_file
+    ActiveRecord::Base.transaction do
+      CSV.parse(content, headers: true) { |row| import row }
+    end
+  end
+
+  private
+
+  RE_EMPHASIS = /^\(\+\)\s?/
+
+  attr_reader :source_file, :subject
+
+  def find_grade(name)
+    key =
+      if name.casecmp('pk').zero?
+        'prekindergarten'
+      elsif name.casecmp('k').zero?
+        'kindergarten'
+      else
+        "grade #{name}"
+      end
+    # TODO: Add caching here
+    Resource.find_by_directory([subject, key]).grades.model
+  end
+
+  def find_grades(data)
+    grades = []
+
+    from_name, to_name = data.squish.downcase.split('-')
+    grades << find_grade(from_name)
+
+    return grades if to_name.blank?
+
+    from_idx = Grades::GRADES_ABBR.index from_name
+    to_idx = Grades::GRADES_ABBR.index from_name
+
+    Grades::GRADES_ABBR.slice(from_idx..to_idx).each { |name| grades << find_grade(name) }
+
+    grades.compact
+  end
+
+  def import(row)
+    grade_name = row[0].to_s.squish
+    return if grade_name.blank?
+
+    standard = subject == 'ela' ? standard_ela(grade_name, row) : standard_math(grade_name, row)
+    standard.resource_ids = find_grades(row[0]).map(&:id)
+  rescue StandardError => e
+    puts e.message
+    puts row
+  end
+
+  def standard_ela(grade_name, data)
+    strand = data[1].to_s.squish
+    number = data[2].to_s.squish
+    name = [grade_name, strand, number].join('.')
+
+    Standard.create!(
+      description: data[4].split(' ', 2).last.to_s.squish,
+      name: name,
+      strand: strand,
+      synonyms: data[3].to_s.squish
+    )
+  end
+
+  def standard_math(grade_name, data)
+    cluster = data[3].to_s.squish
+    course = data[1].to_s.squish
+
+    description = data[5].to_s.split(' ', 2).last.to_s.squish
+    emphasis = description.scan(RE_EMPHASIS)&.send(:[], 0)
+    description = description.sub(RE_EMPHASIS, '')
+
+    domain = data[2].to_s.squish
+    number = data[4].to_s.squish
+    prefix = grade_name.to_i < 9 ? grade_name : course
+    name = [prefix, domain, cluster, number].compact.join('.')
+
+    Standard.create!(
+      description: description&.squish,
+      emphasis: emphasis&.squish,
+      name: name,
+      course: course,
+      domain: domain,
+      synonyms: data[3].to_s.squish
+    )
+  end
+end

data/lib/tasks/cache.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :cache do
+  desc 'Clears up Rails cache store'
+  task(clear: [:environment]) { Rails.cache.clear }
+
+  desc 'Reset Base64 cached assets'
+  task reset_base64: :environment do
+    redis = Rails.application.config.redis
+    redis.keys("#{AssetHelper::REDIS_PREFIX}*").each { |key| redis.del key }
+  end
+end

data/lib/tasks/cleanup.rake

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'google/apis/drive_v3'
+require 'lt/google/api/auth/cli'
+
+namespace :cleanup do # rubocop:disable Metrics/BlockLength
+  def batch_delete_in(folder)
+    Aws::S3::Resource
+      .new(region: ENV.fetch('AWS_REGION'))
+      .bucket(ENV.fetch('AWS_S3_BUCKET_NAME'))
+      .objects(prefix: folder)
+      .batch_delete!
+  end
+
+  namespace :documents do
+    desc 'cleans up PDF generated for preview'
+    task :pdf, [:s3_folder] => [:environment] do |_task, args|
+      Document.find_each do |document|
+        next if document.links.dig('pdf', 'preview').blank?
+
+        links = document.links
+        links['pdf']&.delete('preview')
+        document.update_columns links: links
+      end
+
+      batch_delete_in args[:s3_folder]
+    end
+  end
+
+  namespace :materials do
+    def reset_links_for(type)
+      Material.find_each do |material|
+        next if material.preview_links.empty?
+
+        links = material.preview_links
+        links.delete(type.to_s)
+        material.update preview_links: links
+      end
+    end
+
+    desc 'cleans up PDF generated for materials preview'
+    task pdf: :environment do
+      reset_links_for :pdf
+
+      batch_delete_in MaterialPreviewGenerator::PDF_S3_FOLDER
+    end
+
+    desc 'cleans up Google documents generated for materials preview'
+    task gdoc: :environment do
+      reset_links_for :gdoc
+
+      folder_id = ENV.fetch('GOOGLE_APPLICATION_PREVIEW_FOLDER_ID')
+
+      service = Google::Apis::DriveV3::DriveService.new
+      service.authorization = ::Lt::Google::Api::Auth::Cli.new.credentials
+      service
+        .list_files(q: "'#{folder_id}' in parents")
+        .files.each { |file| service.delete_file file.id }
+    end
+  end
+end

data/lib/tasks/cloud66.rake

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+namespace :cloud66 do # rubocop:disable Metrics/BlockLength
+  desc 'Post-symlink hook tasks for Cloud66.'
+  task after_symlink: %i(environment db:migrate db:seed)
+
+  namespace :robots do
+    desc 'Add robots.txt to public'
+    task add: :environment do
+      origin = Rails.root.join '.cloud66', 'public', 'staging', 'robots.txt'
+      target = Rails.root.join 'public'
+      FileUtils.cp origin, target
+    end
+
+    desc 'Deletes robots.txt from public'
+    task remove: :environment do
+      path = Rails.root.join 'public', 'robots.txt'
+      FileUtils.rm path
+    end
+  end
+
+  namespace :swap do
+    SWAP_FILE = Rails.root.join 'export-swap.sql'
+
+    desc 'Exports tables to be synced'
+    task export: :environment do
+      cmd = <<-BASH
+        pg_dump -U #{ENV['POSTGRESQL_USERNAME']} #{ENV['POSTGRESQL_DATABASE']} \
+          --no-owner \
+          --table=users \
+          --table=access_codes \
+          --file=#{SWAP_FILE}
+      BASH
+      system cmd
+    end
+
+    desc 'Deletes existing tables and creates new one'
+    task import: :environment do
+      raise 'No data file. Please execute `cloud66:swap:export` prior loading the data.' unless File.exist?(SWAP_FILE)
+
+      cmd = "psql -U #{ENV['POSTGRESQL_USERNAME']} #{ENV['POSTGRESQL_DATABASE']}"
+      # Drops old tables
+      system "#{cmd} -c 'drop table access_codes, users;'"
+      # Create new and load the data
+      system "#{cmd} < #{SWAP_FILE}"
+    end
+  end
+end