mumuki-laboratory 5.13.0 → 6.0.0

data/app/models/api_client.rb

@@ -1,31 +0,0 @@
-class ApiClient < ApplicationRecord
-
-  belongs_to :user
-  accepts_nested_attributes_for :user
-  validates_presence_of :description
-
-  #TODO add JWT expiration and api client invalidation
-  #TODO rename toke to encoded_token
-  before_create :set_encoded_token!
-
-  def verify!
-    self.class.invalid_token! 'Invalid Api Client' if Mumukit::Auth::Token.decode(token).uid != user.uid
-  end
-
-  def self.verify_token!(token)
-    client = find_by token: token
-    invalid_token! 'No Api Client found for Token' unless client
-    client.verify!
-  end
-
-  private
-
-  def set_encoded_token!
-    self.token = Mumukit::Auth::Token.encode user.uid, {}
-  end
-
-  def self.invalid_token!(message)
-    raise Mumukit::Auth::InvalidTokenError, message
-  end
-
-end

data/app/models/application_record.rb

@@ -1,92 +0,0 @@
-class ApplicationRecord < ActiveRecord::Base
-  self.abstract_class = true
-
-  delegate :whitelist_attributes, to: :class
-
-  def self.defaults(&block)
-    after_initialize :defaults, if: :new_record?
-    define_method :defaults, &block
-  end
-
-  def self.name_model_as(other)
-    define_singleton_method :model_name do
-      other.model_name
-    end
-  end
-
-  def self.all_except(others)
-    if others.present?
-      where.not(id: [others.map(&:id)])
-    else
-      all
-    end
-  end
-
-  def self.serialize_symbolized_hash_array(*keys)
-    keys.each do |field|
-      serialize field
-      define_method(field) { self[field]&.map { |it| it.symbolize_keys } }
-    end
-  end
-
-  def save(*)
-    super
-  rescue => e
-    self.errors.add :base, e.message
-    self
-  end
-
-  def save_and_notify_changes!
-    if changed?
-      save_and_notify!
-    else
-      save!
-    end
-  end
-
-  def save_and_notify!
-    save!
-    notify!
-    self
-  end
-
-  def update_and_notify!(data)
-    update! data
-    notify!
-    self
-  end
-
-  def self.aggregate_of(association)
-    class_eval do
-      define_method(:rebuild!) do |children|
-        transaction do
-          self.send(association).all_except(children).delete_all
-          self.update! association => children
-          children.each &:save!
-        end
-        reload
-      end
-    end
-  end
-
-  def self.numbered(*associations)
-    class_eval do
-      associations.each do |it|
-        define_method("#{it}=") do |e|
-          e.merge_numbers!
-          super(e)
-        end
-      end
-    end
-  end
-
-  def self.update_or_create!(attributes)
-    obj = first || new
-    obj.update!(attributes)
-    obj
-  end
-
-  def self.whitelist_attributes(a_hash, options={})
-    a_hash.slice(*attribute_names).except(*options[:except])
-  end
-end

data/app/models/assignment.rb

@@ -1,204 +0,0 @@
-class Assignment < ApplicationRecord
-  include Contextualization
-  include WithMessages
-
-  markdown_on :extra_preview
-
-  belongs_to :exercise
-  has_one :guide, through: :exercise
-  has_many :messages, -> { where.not(submission_id: nil).order(date: :desc) }, foreign_key: :submission_id, primary_key: :submission_id, dependent: :delete_all
-
-  belongs_to :submitter, class_name: 'User'
-
-  validates_presence_of :exercise, :submitter
-
-  delegate :language, :name, :navigable_parent,
-           :limited?, :input_kids?, :choice?, to: :exercise
-
-  alias_attribute :status, :submission_status
-  alias_attribute :attempts_count, :attemps_count
-
-  scope :by_exercise_ids, -> (exercise_ids) {
-    where(exercise_id: exercise_ids) if exercise_ids
-  }
-
-  scope :by_usernames, -> (usernames) {
-    joins(:submitter).where('users.name' => usernames) if usernames
-  }
-
-  defaults do
-    self.query_results = []
-    self.expectation_results = []
-  end
-
-  def evaluate_manually!(teacher_evaluation)
-    update! status: teacher_evaluation[:status], manual_evaluation_comment: teacher_evaluation[:manual_evaluation]
-  end
-
-  def persist_submission!(submission)
-    transaction do
-      messages.destroy_all if submission_id.present?
-      update! submission_id: submission.id
-      update_submissions_count!
-      update_last_submission!
-    end
-  end
-
-  def extension
-    exercise.language.extension
-  end
-
-  def notify!
-    Mumukit::Nuntius.notify! 'submissions', as_platform_json unless Organization.current.silent?
-  end
-
-  def notify_to_accessible_organizations!
-    submitter.accessible_organizations.each do |organization|
-      organization.switch!
-      notify!
-    end
-  end
-
-  def self.evaluate_manually!(teacher_evaluation)
-    Assignment.find_by(submission_id: teacher_evaluation[:submission_id])&.evaluate_manually! teacher_evaluation
-  end
-
-  def content=(content)
-    if content.present?
-      self.solution = exercise.single_choice? ? exercise.choices.index(content) : content
-    end
-  end
-
-  def test
-    exercise.test && language.interpolate_references_for(self, exercise.test)
-  end
-
-  def extra
-    exercise.extra && language.interpolate_references_for(self, exercise.extra)
-  end
-
-  def extra_preview
-    Mumukit::ContentType::Markdown.highlighted_code(language.name, extra)
-  end
-
-  def run_update!
-    running!
-    begin
-      update! yield
-    rescue => e
-      errored! e.message
-      raise e
-    end
-  end
-
-  def passed!
-    update! submission_status: :passed
-  end
-
-  def running!
-    update! submission_status: :running,
-            result: nil,
-            test_results: nil,
-            expectation_results: [],
-            manual_evaluation_comment: nil
-  end
-
-  def errored!(message)
-    update! result: message, submission_status: :errored
-  end
-
-  %w(query try).each do |key|
-    name = "run_#{key}!"
-    define_method(name) { |params| exercise.send name, params.merge(extra: extra) }
-  end
-
-  def run_tests!(params)
-    exercise.run_tests! params.merge(extra: extra, test: test)
-  end
-
-  def as_platform_json
-    as_json(except: [:exercise_id, :submission_id, :id, :submitter_id, :solution, :created_at, :updated_at, :submission_status],
-              include: {
-                guide: {
-                  only: [:slug, :name],
-                  include: {
-                    lesson: {only: [:number]},
-                    language: {only: [:name]}},
-                },
-                exercise: {only: [:name, :number]},
-                submitter: {only: [:email, :image_url, :social_id, :uid], methods: [:name]}}).
-      deep_merge(
-        'organization' => Organization.current.name,
-        'sid' => submission_id,
-        'created_at' => updated_at,
-        'content' => solution,
-        'status' => submission_status,
-        'exercise' => {
-          'eid' => exercise.bibliotheca_id
-        },
-        'guide' => {'parent' => {
-          'type' => navigable_parent.class.to_s,
-          'name' => navigable_parent.name,
-          'position' => navigable_parent.try(:number),
-          'chapter' => guide.chapter.as_json(only: [:id], methods: [:name])
-        }})
-  end
-
-  def tips
-    @tips ||= exercise.assist_with(self)
-  end
-
-  def increment_attempts!
-    self.attempts_count += 1 if should_retry?
-  end
-
-  def attempts_left
-    navigable_parent.attempts_left_for(self)
-  end
-
-  # Tells wether the submitter of this
-  # assignment can keep on sending submissions
-  # which is true for non limited or for assignments
-  # that have not reached their submissions limit
-  def attempts_left?
-    !limited? || attempts_left > 0
-  end
-
-  def current_content
-    solution || default_content
-  end
-
-  def current_content_at(index)
-    exercise.sibling_at(index).assignment_for(submitter).current_content
-  end
-
-  def default_content
-    @default_content ||= language.interpolate_references_for(self, exercise.default_content)
-  end
-
-  def files
-    language
-      .directives_sections
-      .split_sections(current_content)
-      .map { |name, content| Mumuki::Laboratory::File.new name, content }
-  end
-
-  private
-
-  def update_submissions_count!
-    self.class.connection.execute(
-      "update public.exercises
-         set submissions_count = submissions_count + 1
-        where id = #{exercise.id}")
-    self.class.connection.execute(
-      "update public.assignments
-         set submissions_count = submissions_count + 1
-        where id = #{id}")
-    exercise.reload
-  end
-
-  def update_last_submission!
-    submitter.update!(last_submission_date: DateTime.now, last_exercise: exercise)
-  end
-
-end

data/app/models/book.rb

@@ -1,47 +0,0 @@
-class Book < Content
-  numbered :chapters
-  aggregate_of :chapters
-
-  has_many :chapters, -> { order(number: :asc) }, dependent: :delete_all
-  has_many :complements, dependent: :delete_all
-
-  has_many :exercises, through: :chapters
-  has_many :discussions, through: :exercises
-
-  delegate :first_lesson, to: :first_chapter
-
-  def to_s
-    slug
-  end
-
-  def first_chapter
-    chapters.first
-  end
-
-  def next_lesson_for(user)
-    user.try(:last_lesson)|| first_lesson
-  end
-
-  def import_from_json!(json)
-    self.assign_attributes json.except('chapters', 'complements', 'id', 'description', 'teacher_info')
-    self.description = json['description'].squeeze(' ')
-
-    rebuild! json['chapters'].map { |it| Topic.find_by!(slug: it).as_chapter_of(self) }
-    rebuild_complements!  (json['complements']||[]).map { |it| Guide.find_by(slug: it)&.as_complement_of(self) }.compact
-
-    Organization.all.each { |org| org.reindex_usages! }
-  end
-
-  def rebuild_complements!(complements) #FIXME use rebuild
-    transaction do
-      self.complements.all_except(complements).delete_all
-      self.update! :complements => complements
-      complements.each &:save!
-    end
-    reload
-  end
-
-  def index_usage!(organization)
-    [chapters, complements].flatten.each { |item| item.index_usage! organization }
-  end
-end

data/app/models/chapter.rb

@@ -1,29 +0,0 @@
-class Chapter < ApplicationRecord
-  include WithStats
-  include WithNumber
-
-  include FriendlyName
-
-  include TopicContainer
-
-  belongs_to :book, optional: true
-  belongs_to :topic
-
-  has_many :exercises, through: :topic
-
-  include SiblingsNavigation
-  include TerminalNavigation
-
-  def used_in?(organization)
-    organization.book == self.book
-  end
-
-  def pending_siblings_for(user)
-    book.pending_chapters(user)
-  end
-
-  def index_usage!(organization = Organization.current)
-    organization.index_usage_of! topic, self
-    lessons.each { |lesson| lesson.index_usage! organization }
-  end
-end

data/app/models/complement.rb

@@ -1,15 +0,0 @@
-class Complement < ApplicationRecord
-  include GuideContainer
-  include FriendlyName
-
-  validates_presence_of :book
-
-  belongs_to :guide
-  belongs_to :book
-
-  include TerminalNavigation
-
-  def used_in?(organization)
-    organization.book == book
-  end
-end

data/app/models/concerns/assistable.rb

@@ -1,17 +0,0 @@
-module Assistable
-  extend ActiveSupport::Concern
-
-  included do
-    serialize :assistance_rules, Array
-  end
-
-  def assistant
-    Mumukit::Assistant.parse(assistance_rules)
-  end
-
-  def assist_with(assignment)
-    # not strictly necessary, but avoid going through
-    # all the assistence process when there are no rules
-    assistance_rules.blank? ? [] : assistant.assist_with(assignment)
-  end
-end

data/app/models/concerns/contextualization.rb

@@ -1,82 +0,0 @@
-module Contextualization
-  extend ActiveSupport::Concern
-
-  class_methods do
-
-    private
-
-    def submission_mapping
-      class_attrs = Submission.mapping_attributes.map { |it| submission_fields_overrides[it] || it }
-      class_attrs.zip Submission.mapping_attributes
-    end
-
-    def submission_fields_overrides
-      { status: :submission_status }
-    end
-  end
-
-  included do
-    serialize :submission_status, Mumuki::Laboratory::Status::Submission
-    validates_presence_of :submission_status
-
-    serialize_symbolized_hash_array :expectation_results, :test_results, :query_results
-
-    composed_of :submission, mapping: submission_mapping, constructor: :from_attributes
-
-    delegate :visible_success_output?, to: :exercise
-    delegate :output_content_type, to: :language
-    delegate :should_retry?, :to_submission_status, *Mumuki::Laboratory::Status::Submission.test_selectors, to: :submission_status
-    delegate :inspection_keywords, to: :exercise
-  end
-
-  def queries_with_results
-    queries.zip(query_results).map do |query, result|
-      {query: query, status: result&.dig(:status).defaulting(:pending), result: result&.dig(:result)}
-    end
-  end
-
-  def single_visual_result?
-    test_results.size == 1 && test_results.first[:title].blank? && visible_success_output?
-  end
-
-  def single_visual_result_html
-    output_content_type.to_html test_results.first[:result]
-  end
-
-  def results_visible?
-    (visible_success_output? || !passed?) && !exercise.choices? && !manual_evaluation_pending?
-  end
-
-  def result_preview
-    result.truncate(100) unless passed?
-  end
-
-  def result_html
-    output_content_type.to_html(result)
-  end
-
-  def feedback_html
-    output_content_type.to_html(feedback)
-  end
-
-  def failed_expectation_results
-    (expectation_results || []).select { |it| it[:result].failed? }
-  end
-
-  def expectation_results_visible?
-    failed_expectation_results.present?
-  end
-
-  def visible_expectation_results
-    exercise.input_kids? ? failed_expectation_results.first(1) : failed_expectation_results
-  end
-
-  def humanized_expectation_results
-    visible_expectation_results.map do |it|
-      {
-        result: it[:result],
-        explanation: Mumukit::Inspection::Expectation.parse(it).translate(inspection_keywords)
-      }
-    end
-  end
-end