mumuki-laboratory 7.4.0 → 7.5.2

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-ad16a5930cec/app/models/content.rb

@@ -0,0 +1,35 @@
+class Content < ApplicationRecord
+  self.abstract_class = true
+
+  include Mumuki::Domain::Syncable
+  include WithDescription
+  include WithLocale
+  include WithSlug
+  include WithUsages
+  include WithName
+  include WithProgress
+
+  def to_resource_h(*args)
+    to_expanded_resource_h(*args).compact
+  end
+
+  def to_expanded_resource_h(*)
+    as_json(only: [:name, :slug, :description, :locale]).symbolize_keys
+  end
+
+  def fork_to!(organization, syncer, quiet: false)
+    rebased_dup(organization).tap do |dup|
+      self.class.find_by(slug: dup.slug).try { |it| return it } if quiet
+
+      dup.validate!
+      fork_children_into! dup, organization, syncer
+      dup.save validate: false
+
+      syncer.export! dup
+    end
+  end
+
+  def public?
+    !private?
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-ad16a5930cec/app/models/course.rb

@@ -0,0 +1,51 @@
+class Course < ApplicationRecord
+  include Mumuki::Domain::Syncable
+  include Mumuki::Domain::Helpers::Course
+
+  validates_presence_of :slug, :shifts, :code, :days, :period, :description, :organization_id
+  validates_uniqueness_of :slug
+  belongs_to :organization
+
+  has_many :invitations
+
+  alias_attribute :name, :code
+
+  resource_fields :slug, :shifts, :code, :days, :period, :description
+
+  def current_invitation
+    invitations.where('expiration_date > ?', Time.now).take
+  end
+
+  def import_from_resource_h!(resource_h)
+    update! self.class.slice_resource_h(resource_h)
+  end
+
+  def slug=(slug)
+    s = Mumukit::Auth::Slug.parse(slug)
+
+    self[:slug] = slug
+    self[:code] = s.course
+    self[:organization_id] = Organization.locate!(s.organization).id
+  end
+
+  def invite!(expiration_date)
+    if closed?
+      generate_invitation! expiration_date
+    else
+      current_invitation
+    end
+  end
+
+  def closed?
+    current_invitation.blank? || current_invitation.expired?
+  end
+
+  def generate_invitation!(expiration_date)
+    invitation = invitations.build expiration_date: expiration_date, course: self
+    invitation.save_and_notify!
+  end
+
+  def self.sync_key_id_field
+    :slug
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-ad16a5930cec/app/models/discussion.rb

@@ -0,0 +1,138 @@
+class Discussion < ApplicationRecord
+  include WithDiscussionStatus, WithScopedQueries, Contextualization
+
+  belongs_to :item, polymorphic: true
+  has_many :messages, -> { order(:created_at) }, dependent: :destroy
+  belongs_to :initiator, class_name: 'User'
+  belongs_to :exercise, foreign_type: :exercise, foreign_key: 'item_id'
+  belongs_to :organization
+  has_many :subscriptions
+  has_many :upvotes
+
+  scope :by_language, -> (language) { includes(:exercise).joins(exercise: :language).where(languages: {name: language}) }
+
+  before_save :capitalize_title
+  validates_presence_of :title
+
+  markdown_on :description
+
+  sortable :created_at, :upvotes_count, default: :created_at_desc
+  filterable :status, :language
+  pageable
+
+  delegate :language, to: :item
+  delegate :to_discussion_status, to: :status
+
+  scope :for_user, -> (user) do
+    if user.try(:moderator_here?)
+      all
+    else
+      where.not(status: :closed).where.not(status: :pending_review).or(where(initiator: user))
+    end
+  end
+
+  def try_solve!
+    if opened?
+      update! status: reachable_statuses_for(initiator).first
+    end
+  end
+
+  def capitalize_title
+    title.capitalize!
+  end
+
+  def used_in?(organization)
+    organization == self.organization
+  end
+
+  def commentable_by?(user)
+    user&.moderator_here? || (opened? && user.present?)
+  end
+
+  def subscribable?
+    opened? || solved?
+  end
+
+  def has_submission?
+    submission.solution.present?
+  end
+
+  def read_by?(user)
+    subscription_for(user).read
+  end
+
+  def last_message_date
+    messages.last&.created_at || created_at
+  end
+
+  def friendly
+    title
+  end
+
+  def subscription_for(user)
+    subscriptions.find_by(user: user)
+  end
+
+  def upvote_for(user)
+    upvotes.find_by(user: user)
+  end
+
+  def unread_subscriptions(user)
+    subscriptions.where.not(user: user).map(&:unread!)
+  end
+
+  def submit_message!(message, user)
+    message.merge!(sender: user.uid)
+    messages.create(message)
+    user.subscribe_to! self
+    unread_subscriptions(user)
+  end
+
+  def authorized?(user)
+    initiator?(user) || user.try(:moderator_here?)
+  end
+
+  def initiator?(user)
+    user.try(:uid) == initiator.uid
+  end
+
+  def reachable_statuses_for(user)
+    return [] unless authorized?(user)
+    status.reachable_statuses_for(user, self)
+  end
+
+  def reachable_status_for?(user, status)
+    reachable_statuses_for(user).include? status
+  end
+
+  def allowed_statuses_for(user)
+    status.allowed_statuses_for(user, self)
+  end
+
+  def update_status!(status, user)
+    update!(status: status) if reachable_status_for?(user, status)
+  end
+
+  def has_messages?
+    messages.exists? || description.present?
+  end
+
+  def responses_count
+    messages.where.not(sender: initiator.uid).count
+  end
+
+  def has_responses?
+    responses_count > 0
+  end
+
+  def extra_preview_html
+    # FIXME this is buggy, because the extra
+    # may have changed since the submission of this discussion
+    exercise.assignment_for(initiator).extra_preview_html
+  end
+
+  def self.debatable_for(klazz, params)
+    debatable_id = params[:"#{klazz.underscore}_id"]
+    klazz.constantize.find(debatable_id)
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-ad16a5930cec/app/models/event.rb

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

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-ad16a5930cec/app/models/exam.rb

@@ -0,0 +1,177 @@
+class Exam < ApplicationRecord
+  include GuideContainer
+  include FriendlyName
+
+  validates_presence_of :start_time, :end_time
+
+  belongs_to :organization
+
+  has_many :authorizations, class_name: 'ExamAuthorization', dependent: :destroy
+  has_many :users, through: :authorizations
+
+  after_destroy { |record| Usage.destroy_usages_for record }
+  after_create :reindex_usages!
+
+  include TerminalNavigation
+
+  def used_in?(organization)
+    organization == self.organization
+  end
+
+  def enabled?
+    enabled_range.cover? DateTime.current
+  end
+
+  def enabled_range
+    start_time..end_time
+  end
+
+  def enabled_for?(user)
+    enabled_range_for(user).cover? DateTime.current
+  end
+
+  def in_progress_for?(user)
+    accessible_for?(user) && started?(user)
+  end
+
+  def validate_accessible_for!(user)
+    if user.present?
+      raise Mumuki::Domain::ForbiddenError unless authorized?(user)
+      raise Mumuki::Domain::GoneError unless enabled_for?(user)
+    else
+      raise Mumuki::Domain::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)
+    return if user.teacher_here?
+
+    authorization = authorization_for(user)
+    raise Mumuki::Domain::ForbiddenError unless authorization
+    authorization.start!
+  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 authorize_users!(users)
+    users.each { |user| authorize! user }
+  end
+
+  def unauthorize_users!(users)
+    authorizations_for(users).destroy_all
+  end
+
+  def process_users(users)
+    authorize_users!(users)
+    clean_authorizations users
+  end
+
+  def clean_authorizations(authorized_users)
+    unauthorize_users!(users.all_except(authorized_users))
+  end
+
+  def reindex_usages!
+    index_usage! organization
+  end
+
+  def self.import_from_resource_h!(json)
+    exam_data = json.with_indifferent_access
+    organization = Organization.locate! 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
+  end
+
+  def self.upsert_students!(json)
+    data = json.with_indifferent_access
+    exam = find_by(classroom_id: data[:eid])
+
+    added_users = User.where(uid: data[:added])
+    deleted_users = User.where(uid: data[:deleted])
+
+    exam.authorize_users! added_users
+    exam.unauthorize_users! deleted_users
+  end
+
+  def self.adapt_json_values(exam)
+    exam[:guide_id] = Guide.locate!(exam[:slug]).id
+    exam[:organization_id] = Organization.current.id
+    exam[:users] = User.where(uid: exam[:uids])
+    [: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 results_hidden_for?(exercise)
+    exercise.choice? && results_hidden_for_choices?
+  end
+
+  def resettable?
+    false
+  end
+
+  private
+
+  def max_attempts_for(exercise)
+    exercise.choice? ? max_choice_submissions : max_problem_submissions
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-ad16a5930cec/app/models/exam_authorization.rb

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

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-ad16a5930cec/app/models/exercise.rb

@@ -0,0 +1,255 @@
+class Exercise < ApplicationRecord
+  RANDOMIZED_FIELDS = [:default_content, :description, :extra, :hint, :test]
+  BASIC_RESOURCE_FIELDS = %i(
+    name layout editor corollary teacher_info manual_evaluation locale
+    choices assistance_rules randomizations tag_list extra_visible goal
+    free_form_editor_source initial_state final_state)
+
+  include WithDescription
+  include WithLocale
+  include WithNumber,
+          WithName,
+          WithAssignments,
+          FriendlyName,
+          WithLanguage,
+          Assistable,
+          WithRandomizations,
+          WithDiscussions
+
+  include Submittable,
+          Questionable
+
+  include SiblingsNavigation,
+          ParentNavigation
+
+  belongs_to :guide
+
+  markdown_on :teacher_info
+
+  defaults { self.submissions_count = 0 }
+
+  alias_method :progress_for, :assignment_for
+
+  serialize :choices, Array
+  serialize :settings, Hash
+
+  validates_presence_of :submissions_count,
+                        :guide, :bibliotheca_id
+
+  randomize(*RANDOMIZED_FIELDS)
+  delegate :timed?, to: :navigable_parent
+
+  def console?
+    queriable?
+  end
+
+  def used_in?(organization=Organization.current)
+    guide.usage_in_organization(organization).present?
+  end
+
+  def structural_parent
+    guide
+  end
+
+  def guide_done_for?(user)
+    guide.done_for?(user)
+  end
+
+  def choice?
+    false
+  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 transparent_id
+    "#{guide.transparent_id}/#{bibliotheca_id}"
+  end
+
+  def transparent_params
+    guide.transparent_params.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
+    Mumuki::Domain::Submission::Solution.new(content: default_content)
+  end
+
+  def import_from_resource_h!(number, resource_h)
+    self.language = Language.for_name(resource_h.dig(:language, :name)) || guide.language
+    self.locale = guide.locale
+
+    reset!
+
+    attrs = whitelist_attributes(resource_h, except: [:type, :id])
+    attrs[:choices] = resource_h[:choices].to_a
+    attrs[:bibliotheca_id] = resource_h[:id]
+    attrs[:number] = number
+    attrs[:manual_evaluation] ||= false
+    attrs = attrs.except(:expectations, :custom_expectations) if type != 'Problem'
+
+    assign_attributes(attrs)
+    save!
+  end
+
+  def choice_values
+    choices.map { |it| it.indifferent_get(:value) }
+  end
+
+  def choice_index_for(value)
+    choice_values.index(value)
+  end
+
+  def to_resource_h(*args)
+    to_expanded_resource_h(*args).compact
+  end
+
+  # Keep this list up to date with
+  # Mumuki::Domain::Store::Github::ExerciseSchema
+  def to_expanded_resource_h(options={})
+    language_resource_h = language.to_embedded_resource_h if language != guide.language
+    as_json(only: BASIC_RESOURCE_FIELDS)
+      .merge(id: bibliotheca_id, language: language_resource_h, type: type.underscore)
+      .merge(expectations: self[:expectations])
+      .merge(custom_expectations: self[:custom_expectations])
+      .merge(settings: self[:settings])
+      .merge(RANDOMIZED_FIELDS.map { |it| [it, self[it]] }.to_h)
+      .symbolize_keys
+      .tap { |it| it.markdownified!(:hint, :corollary, :description, :teacher_info) if options[:markdownified] }
+  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: type)
+    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
+    splitted_description.first.markdownified
+  end
+
+  def splitted_description
+    description.split('> ')
+  end
+
+  def description_task
+    splitted_description.drop(1).join("\n").markdownified
+  end
+
+  def custom?
+    false
+  end
+
+  def inspection_keywords
+    {}
+  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
+
+  # An exercise with hidden results cannot be limited
+  # as those exercises can be submitted as many times as the
+  # student wants because no result output is given
+  def limited?
+    !results_hidden? && navigable_parent.limited_for?(self)
+  end
+
+  def results_hidden?
+    navigable_parent&.results_hidden_for?(self)
+  end
+
+  def files_for(current_content)
+    language
+      .directives_sections
+      .split_sections(current_content)
+      .map { |name, content| Mumuki::Domain::File.new name, content }
+  end
+
+  def self.find_transparently!(params)
+    Guide.find_transparently!(params).locate_exercise! params[:bibliotheca_id]
+  end
+
+  def self.locate!(slug_and_bibliotheca_id)
+    slug, bibliotheca_id = slug_and_bibliotheca_id
+    Guide.locate!(slug).locate_exercise! bibliotheca_id
+  end
+
+  def settings
+    guide.settings.deep_merge super
+  end
+
+  def pending_siblings_for(user)
+    guide.pending_exercises(user)
+  end
+
+  private
+
+  def evaluation_class
+    if manual_evaluation?
+      manual_evaluation_class
+    else
+      automated_evaluation_class
+    end
+  end
+
+  def manual_evaluation_class
+    Mumuki::Domain::Evaluation::Manual
+  end
+
+  def automated_evaluation_class
+    Mumuki::Domain::Evaluation::Automated
+  end
+
+  def self.default_layout
+    layouts.keys[0]
+  end
+end