mumuki-laboratory 5.13.0 → 6.0.0

data/app/models/event.rb

@@ -1,2 +0,0 @@
-module Event
-end

data/app/models/exam.rb

@@ -1,147 +0,0 @@
-class Exam < ApplicationRecord
-  include GuideContainer
-  include FriendlyName
-
-  validates_presence_of :start_time, :end_time
-
-  belongs_to :guide
-  belongs_to :organization
-
-  has_many :authorizations, class_name: 'ExamAuthorization', dependent: :delete_all
-  has_many :users, through: :authorizations
-
-  after_destroy { |record| Usage.destroy_usages_for record }
-
-  include TerminalNavigation
-
-  def used_in?(organization)
-    organization == self.organization
-  end
-
-  def enabled?
-    enabled_range.cover? DateTime.now
-  end
-
-  def enabled_range
-    start_time..end_time
-  end
-
-  def enabled_for?(user)
-    enabled_range_for(user).cover? DateTime.now
-  end
-
-  def in_progress_for?(user)
-    accessible_for?(user) && started?(user)
-  end
-
-  def validate_accessible_for!(user)
-    if user.present?
-      raise Mumuki::Laboratory::ForbiddenError unless authorized?(user)
-      raise Mumuki::Laboratory::GoneError unless enabled_for?(user)
-    else
-      raise Mumuki::Laboratory::UnauthorizedError
-    end
-  end
-
-  def accessible_for?(user)
-    authorized?(user) && enabled_for?(user)
-  end
-
-  def timed?
-    duration.present?
-  end
-
-  def authorize!(user)
-    users << user unless authorized?(user)
-  end
-
-  def authorized?(user)
-    users.include? user
-  end
-
-  def enabled_range_for(user)
-    start_time..real_end_time(user)
-  end
-
-  def authorization_for(user)
-    authorizations.find_by(user_id: user.id)
-  end
-
-  def authorizations_for(users)
-    authorizations.where(user_id: users.map(&:id))
-  end
-
-  def start!(user)
-    authorization_for(user).start! unless user.teacher_here?
-  end
-
-  def started?(user)
-    authorization_for(user).try(:started?)
-  end
-
-  def real_end_time(user)
-    if duration.present? && started?(user)
-      [started_at(user) + duration.minutes, end_time].min
-    else
-      end_time
-    end
-  end
-
-  def started_at(user)
-    authorization_for(user).started_at
-  end
-
-  def process_users(users)
-    users.map { |user| authorize! user }
-    clean_authorizations users
-  end
-
-  def clean_authorizations(users)
-    authorizations.all_except(authorizations_for(users)).destroy_all
-  end
-
-  def self.import_from_json!(json)
-    exam_data = json.with_indifferent_access
-    organization = Organization.find_by!(name: exam_data[:organization])
-    organization.switch!
-    adapt_json_values exam_data
-    remove_previous_version exam_data[:eid], exam_data[:guide_id]
-    exam = where(classroom_id: exam_data[:eid]).update_or_create!(whitelist_attributes(exam_data))
-    exam.process_users exam_data[:users]
-    exam.index_usage! organization
-    exam
-  end
-
-  def self.adapt_json_values(exam)
-    exam[:guide_id] = Guide.find_by(slug: exam[:slug]).id
-    exam[:organization_id] = Organization.current.id
-    exam[:users] = exam[:uids].map { |uid| User.find_by(uid: uid) }.compact
-    [:start_time, :end_time].each { |param| exam[param] = exam[param].to_time }
-  end
-
-  def self.remove_previous_version(eid, guide_id)
-    Rails.logger.info "Looking for"
-    where("guide_id=? and organization_id=? and classroom_id!=?", guide_id, Organization.current.id, eid).tap do |exams|
-      Rails.logger.info "Deleting exams with ORG_ID:#{Organization.current.id} - GUIDE_ID:#{guide_id} - CLASSROOM_ID:#{eid}"
-      exams.destroy_all
-    end
-  end
-
-  def attempts_left_for(assignment)
-    max_attempts_for(assignment.exercise) - (assignment.attempts_count || 0)
-  end
-
-  def limited_for?(exercise)
-    max_attempts_for(exercise).present?
-  end
-
-  def resettable?
-    false
-  end
-
-  private
-
-  def max_attempts_for(exercise)
-    exercise.choice? ? max_choice_submissions : max_problem_submissions
-  end
-end

data/app/models/exam_authorization.rb

@@ -1,10 +0,0 @@
-class ExamAuthorization < ApplicationRecord
-
-  belongs_to :user
-  belongs_to :exam
-
-  def start!
-    update!(started: true, started_at: Time.now) unless started?
-  end
-
-end

data/app/models/exercise.rb

@@ -1,190 +0,0 @@
-class Exercise < ApplicationRecord
-  include WithDescription
-  include WithLocale
-  include WithNumber,
-          WithAssignments,
-          FriendlyName,
-          WithLanguage,
-          Assistable,
-          WithRandomizations,
-          WithDiscussions
-
-  include Submittable,
-          Questionable
-
-  include SiblingsNavigation,
-          ParentNavigation
-
-  belongs_to :guide
-  defaults { self.submissions_count = 0 }
-
-  validates_presence_of :submissions_count,
-                        :guide
-
-  randomize :description, :hint, :extra, :test, :default_content
-  delegate :timed?, to: :navigable_parent
-
-  def console?
-    queriable?
-  end
-
-  def used_in?(organization=Organization.current)
-    guide.usage_in_organization(organization).present?
-  end
-
-  def pending_siblings_for(user)
-    guide.pending_exercises(user)
-  end
-
-  def structural_parent
-    guide
-  end
-
-  def guide_done_for?(user)
-    guide.done_for?(user)
-  end
-
-  def previous
-    sibling_at number.pred
-  end
-
-  def sibling_at(index)
-    index = number + index unless index.positive?
-    guide.exercises.find_by(number: index)
-  end
-
-  def search_tags
-    [language&.name, *tag_list].compact
-  end
-
-  def slug
-    "#{guide.slug}/#{bibliotheca_id}"
-  end
-
-  def slug_parts
-    guide.slug_parts.merge(bibliotheca_id: bibliotheca_id)
-  end
-
-  def friendly
-    defaulting_name { "#{navigable_parent.friendly} - #{name}" }
-  end
-
-  def submission_for(user)
-    assignment_for(user).submission
-  end
-
-  def new_solution
-    Solution.new(content: default_content)
-  end
-
-  def import_from_json!(number, json)
-    self.language = Language.for_name(json['language']) || guide.language
-    self.locale = guide.locale
-
-    reset!
-
-    attrs = whitelist_attributes(json, except: %w(type id))
-    attrs['choices'] = json['choices']&.map { |choice| choice['value'] } || []
-    attrs['bibliotheca_id'] = json['id']
-    attrs['number'] = number
-    attrs = attrs.except('expectations') if json['type'] != 'problem' || json['new_expectations']
-
-    assign_attributes(attrs)
-    save!
-  end
-
-  def reset!
-    self.name = nil
-    self.description = nil
-    self.corollary = nil
-    self.hint = nil
-    self.extra = nil
-    self.tag_list = []
-  end
-
-  def ensure_type!(type)
-    if self.type != type
-      reclassify! type
-    else
-      self
-    end
-  end
-
-  def reclassify!(type)
-    update!(type: Exercise.class_for(type).name)
-    Exercise.find(id)
-  end
-
-  def messages_path_for(user)
-    "api/guides/#{guide.slug}/#{bibliotheca_id}/student/#{URI.escape user.uid}/messages?language=#{language}"
-  end
-
-  def messages_url_for(user)
-    Mumukit::Platform.classroom_api.organic_url_for(Organization.current, messages_path_for(user))
-  end
-
-  def description_context
-    Mumukit::ContentType::Markdown.to_html splitted_description.first
-  end
-
-  def splitted_description
-    description.split('> ')
-  end
-
-  def description_task
-    Mumukit::ContentType::Markdown.to_html splitted_description.drop(1).join("\n")
-  end
-
-  def custom?
-    false
-  end
-
-  def inspection_keywords
-    {}
-  end
-
-  def default_content
-    self[:default_content] || ''
-  end
-
-  # Submits the user solution
-  # only if the corresponding assignment has attemps left
-  def try_submit_solution!(user, solution={})
-    assignment = assignment_for(user)
-    if assignment.attempts_left?
-      submit_solution!(user, solution)
-    else
-      assignment
-    end
-  end
-
-  def limited?
-    navigable_parent.limited_for?(self)
-  end
-
-  private
-
-  def evaluation_class
-    if manual_evaluation?
-      manual_evaluation_class
-    else
-      automated_evaluation_class
-    end
-  end
-
-  def manual_evaluation_class
-    Mumuki::Laboratory::Evaluation::Manual
-  end
-
-  def automated_evaluation_class
-    Mumuki::Laboratory::Evaluation::Automated
-  end
-
-  def self.class_for(type)
-    type.camelcase.constantize
-  end
-
-  def self.default_layout
-    layouts.keys[0]
-  end
-end

data/app/models/exercise/challenge.rb

@@ -1,25 +0,0 @@
-class Challenge < Exercise
-  include WithLayout
-
-  markdown_on :hint
-
-  def reset!
-    super
-    self.layout = self.class.default_layout
-  end
-
-  def extra(*)
-    [guide.extra, super]
-      .compact
-      .join("\n")
-      .strip
-      .ensure_newline
-  end
-
-  private
-
-  def defaults
-    super
-    self.layout = self.class.default_layout
-  end
-end

data/app/models/exercise/interactive.rb

@@ -1,41 +0,0 @@
-class Interactive < Challenge
-  include Triable
-
-  markdown_on :corollary
-  validate :ensure_triable_language
-  validate :ensure_stateful_console
-
-  serialize :goal
-  name_model_as Exercise
-
-  def console?
-    true
-  end
-
-  def stateful_console?
-    true
-  end
-
-  def queriable?
-    false
-  end
-
-  def hidden?
-    false
-  end
-
-  def upload?
-    false
-  end
-
-  private
-
-  def ensure_triable_language
-    errors.add(:base, :language_not_triable) unless language.triable?
-  end
-
-  def ensure_stateful_console
-    errors.add(:base, :console_not_stateful) unless language.stateful_console?
-  end
-
-end

data/app/models/exercise/playground.rb

@@ -1,23 +0,0 @@
-class Playground < QueriableChallenge
-  validate :ensure_queriable_language
-
-  name_model_as Exercise
-
-  def setup_query_assignment!(assignment)
-    assignment.running!
-  end
-
-  def save_query_results!(assignment)
-    unless assignment.passed?
-      assignment.passed!
-      assignment.notify!
-    end
-  end
-
-  private
-
-  def ensure_queriable_language
-    errors.add(:base, :language_not_queriable) unless queriable?
-  end
-
-end