mumuki-laboratory 7.9.2 → 7.10.0

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-7082a83493eb/app/models/concerns/with_usages.rb

@@ -1,42 +0,0 @@
-module WithUsages
-  extend ActiveSupport::Concern
-
-  included do
-    has_many :usages, as: :item
-    before_destroy :ensure_unused!
-    organic_on :usages
-  end
-
-  def usage_in_organization(organization = Organization.current)
-    usages_in_organization(organization).first.try(:parent_item)
-  end
-
-  def usage_in_organization_of_type(type, organization = Organization.current)
-    item = usage_in_organization(organization)
-    item.is_a?(type) ? item : nil
-  end
-
-  class_methods do
-    def aggregate_of(association)
-      super
-
-      revamp "rebuild_#{association}!" do |_, this, children, hyper|
-        old_children = this.send association
-        added_children = children - old_children
-        hyper.(children)
-        this.usages.each { |it| it.index_children!(added_children) }
-
-        this
-      end
-    end
-  end
-
-  private
-
-  def ensure_unused!
-    if usages.present?
-      errors.add :base, :in_use, organization: usages.first.organization.name
-      throw :abort
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-7082a83493eb/app/models/concerns/with_user_navigation.rb

@@ -1,9 +0,0 @@
-module WithUserNavigation
-  def navigable_name
-    name
-  end
-
-  def navigation_end?
-    true
-  end
-end

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

@@ -1,35 +0,0 @@
-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-7082a83493eb/app/models/course.rb

@@ -1,62 +0,0 @@
-class Course < ApplicationRecord
-  include Mumuki::Domain::Syncable
-  include Mumuki::Domain::Helpers::Course
-  include Mumuki::Domain::Area
-
-  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).first
-  end
-
-  def import_from_resource_h!(resource_h)
-    update! self.class.slice_resource_h(resource_h)
-  end
-
-  def slug=(slug)
-    s = slug.to_mumukit_slug
-    self[:slug] = slug.to_s
-    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)
-    invitations.create expiration_date: expiration_date, course: self
-    current_invitation
-  end
-
-  def self.sync_key_id_field
-    :slug
-  end
-
-  def to_organization
-    organization
-  end
-
-  def to_s
-    slug.to_s
-  end
-
-  def self.allowed_for(user, organization = Organization.current)
-    where(organization: organization).select { |course| user.teacher_of? course.slug }
-  end
-end

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

@@ -1,176 +0,0 @@
-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 :last_moderator_access_by, class_name: 'User', optional: true
-  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}) }
-  scope :order_by_responses_count, -> (direction) { reorder(validated_messages_count: direction, messages_count: opposite(direction)) }
-  scope :by_requires_moderator_response, -> (boolean) { where(requires_moderator_response: boolean.to_boolean) }
-
-  after_create :subscribe_initiator!
-
-  markdown_on :description
-
-  sortable :responses_count, :upvotes_count, :created_at, default: :created_at_desc
-  filterable :status, :language, :requires_moderator_response
-  pageable
-
-  delegate :language, to: :item
-  delegate :to_discussion_status, to: :status
-
-  MODERATOR_REVIEW_AVERAGE_TIME = 10.minutes
-
-  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 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
-    initiator.name
-  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 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 has_validated_responses?
-    validated_messages_count > 0
-  end
-
-  def subscribe_initiator!
-    initiator.subscribe_to! self
-  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 update_counters!
-    messages_query = messages_by_updated_at
-    validated_messages = messages_query.select &:validated?
-    has_moderator_response = messages_query.find { |it| it.validated? || it.question? }&.validated?
-    update! messages_count: messages_query.count,
-            validated_messages_count: validated_messages.count,
-            requires_moderator_response: !has_moderator_response
-  end
-
-  def update_last_moderator_access!(user)
-    if user&.moderator_here? && !last_moderator_access_visible_for?(user)
-      update! last_moderator_access_at: Time.now,
-              last_moderator_access_by: user
-    end
-  end
-
-  def being_accessed_by_moderator?
-    last_moderator_access_at.present? && last_moderator_access_at > Time.now - MODERATOR_REVIEW_AVERAGE_TIME
-  end
-
-  def last_moderator_access_visible_for?(user)
-    show_last_moderator_access_for?(user) && being_accessed_by_moderator?
-  end
-
-  def show_last_moderator_access_for?(user)
-    user&.moderator_here? && last_moderator_access_by != user
-  end
-
-  def self.debatable_for(klazz, params)
-    debatable_id = params[:"#{klazz.underscore}_id"]
-    klazz.constantize.find(debatable_id)
-  end
-
-  private
-
-  def messages_by_updated_at(direction = :desc)
-    messages.reorder(updated_at: direction)
-  end
-end

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

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

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

@@ -1,207 +0,0 @@
-class Exam < ApplicationRecord
-
-  include GuideContainer
-  include FriendlyName
-  include TerminalNavigation
-
-  belongs_to :organization
-  belongs_to :course, optional: true
-
-  has_many :authorizations, class_name: 'ExamAuthorization', dependent: :destroy
-  has_many :users, through: :authorizations
-
-  enum passing_criterion_type: [:none, :percentage, :passed_exercises], _prefix: :passing_criterion
-
-  validates_presence_of :start_time, :end_time
-  validates_numericality_of :max_problem_submissions, :max_choice_submissions, greater_than_or_equal_to: 1, allow_nil: true
-
-  before_save :set_default_criterion_type!
-  before_save :ensure_valid_passing_criterion!
-
-  before_create :set_classroom_id!
-
-  after_destroy { |record| Usage.destroy_usages_for record }
-  after_create :reindex_usages!
-
-  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 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
-
-  def set_classroom_id!
-    self.classroom_id ||= SecureRandom.hex(8)
-  end
-
-  def passing_criterion
-    @passing_criterion ||= Exam::PassingCriterion.parse(passing_criterion_type, passing_criterion_value)
-  end
-
-  def ensure_valid_passing_criterion!
-    passing_criterion.ensure_valid!
-  end
-
-  def set_default_criterion_type!
-    self.passing_criterion_type ||= :none
-  end
-
-  def self.import_from_resource_h!(json)
-    exam_data = json.with_indifferent_access
-    Organization.locate!(exam_data[:organization].to_s).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[:course_id] = Course.locate!(exam[:course].to_s).id
-    exam[:users] = User.where(uid: exam[:uids])
-    exam[:start_time] = exam[:start_time].to_time
-    exam[:end_time] = exam[:end_time].to_time
-    exam[:classroom_id] = exam[:eid] if exam[:eid].present?
-    exam[:passing_criterion_type] = exam.dig(:passing_criterion, :type)
-    exam[:passing_criterion_value] = exam.dig(:passing_criterion, :value)
-  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
-
-  private
-
-  def max_attempts_for(exercise)
-    exercise.choice? ? max_choice_submissions : max_problem_submissions
-  end
-
-end