mumuki-laboratory 7.3.1 → 7.5.1

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-a059418e5fd8/app/models/lesson.rb

@@ -0,0 +1,24 @@
+class Lesson < ApplicationRecord
+  include WithNumber
+  include FriendlyName
+
+  include ParentNavigation, SiblingsNavigation
+
+  include GuideContainer
+
+  belongs_to :topic
+
+  alias_method :chapter, :navigable_parent
+
+  def used_in?(organization)
+    guide.usage_in_organization(organization) == self
+  end
+
+  def structural_parent
+    topic
+  end
+
+  def pending_siblings_for(user)
+    topic.pending_lessons(user)
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-a059418e5fd8/app/models/message.rb

@@ -0,0 +1,68 @@
+class Message < ApplicationRecord
+
+  belongs_to :discussion, optional: true
+  belongs_to :assignment, foreign_key: :submission_id, primary_key: :submission_id, optional: true
+  has_one :exercise, through: :assignment
+
+  validates_presence_of :content, :sender
+  validates_presence_of :submission_id, :unless => :discussion_id?
+  markdown_on :content
+
+  def notify!
+    Mumukit::Nuntius.notify! 'student-messages', to_resource_h unless Organization.silenced?
+  end
+
+  def from_initiator?
+    sender_user == discussion&.initiator
+  end
+
+  def from_user?(user)
+    sender_user == user
+  end
+
+  def sender_user
+    User.find_by(uid: sender)
+  end
+
+  def authorized?(user)
+    from_user?(user) || user&.moderator_here?
+  end
+
+  def authorize!(user)
+    raise Mumukit::Auth::UnauthorizedAccessError unless authorized?(user)
+  end
+
+  def to_resource_h
+    as_json(except: [:id, :type, :discussion_id, :approved],
+            include: {exercise: {only: [:bibliotheca_id]}})
+      .merge(organization: Organization.current.name)
+  end
+
+  def read!
+    update! read: true
+  end
+
+  def toggle_approved!
+    toggle! :approved
+  end
+
+  def self.parse_json(json)
+    message = json.delete 'message'
+    json
+      .except('uid', 'exercise_id')
+      .merge(message)
+  end
+
+  def self.read_all!
+    update_all read: true
+  end
+
+  def self.import_from_resource_h!(json)
+    message_data = parse_json json
+    Organization.find_by!(name: message_data.delete('organization')).switch!
+
+    if message_data['submission_id'].present?
+      Assignment.find_by(submission_id: message_data.delete('submission_id'))&.receive_answer! message_data
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-a059418e5fd8/app/models/organization.rb

@@ -0,0 +1,167 @@
+class Organization < ApplicationRecord
+  include Mumuki::Domain::Syncable
+  include Mumuki::Domain::Helpers::Organization
+
+  include Mumukit::Login::OrganizationHelpers
+
+  serialize :profile, Mumuki::Domain::Organization::Profile
+  serialize :settings, Mumuki::Domain::Organization::Settings
+  serialize :theme, Mumuki::Domain::Organization::Theme
+
+  markdown_on :description
+
+  validate :ensure_consistent_public_login
+
+  belongs_to :book
+  has_many :usages
+
+  validates_presence_of :contact_email, :locale
+  validates :name, uniqueness: true,
+                   presence: true,
+                   format: { with: Mumukit::Platform::Organization.anchored_valid_name_regex }
+  validates :locale, inclusion: { in: Mumukit::Platform::Locale.supported }
+
+  after_create :reindex_usages!
+  after_update :reindex_usages!, if: lambda { |user| user.saved_change_to_book_id? }
+
+  has_many :guides, through: 'usages', source: 'item', source_type: 'Guide'
+  has_many :exercises, through: :guides
+  has_many :assignments, through: :exercises
+  has_many :exams
+  has_many :courses
+
+  resource_fields :name, :book, :profile, :settings, :theme
+
+  defaults do
+    self.class.base.try do |base|
+      self.theme         = base.theme    if theme.empty?
+      self.settings      = base.settings if settings.empty?
+      self.contact_email ||= base.contact_email
+      self.book          ||= base.book
+      self.locale        ||= base.locale
+    end
+  end
+
+  def in_path?(item)
+    usages.exists?(item: item) || usages.exists?(parent_item: item)
+  end
+
+  def notify_recent_assignments!(date)
+    notify_assignments! assignments.where('assignments.updated_at > ?', date)
+  end
+
+  def notify_assignments_by!(submitter)
+    notify_assignments! assignments.where(submitter_id: submitter.id)
+  end
+
+  def silent?
+    test?
+  end
+
+  def reindex_usages!
+    transaction do
+      drop_usage_indices!
+      book.index_usage! self
+      exams.each { |exam| exam.index_usage! self }
+    end
+    reload
+  end
+
+  def drop_usage_indices!
+    usages.destroy_all
+  end
+
+  def index_usage_of!(item, parent)
+    Usage.create! organization: self, item: item, parent_item: parent
+  end
+
+  def accessible_exams_for(user)
+    exams.select { |exam| exam.accessible_for?(user) }
+  end
+
+  def has_login_method?(login_method)
+    self.login_methods.include? login_method.to_s
+  end
+
+  def explain_error(code, advice)
+    errors_explanations.try { |it| it[code.to_s] } || I18n.t(advice)
+  end
+
+  def self.accessible_as(user, role)
+    all.select { |it| it.public? || user.has_permission?(role, it.slug) }
+  end
+
+  def title_suffix
+    central? ? '' : " - #{book.name}"
+  end
+
+  def site_name
+    central? ? 'mumuki' : name
+  end
+
+  # Tells if the given user can
+  # ask for help in this organization
+  #
+  # Warning: this method does not strictly check user's permission
+  def ask_for_help_enabled?(user = nil)
+    report_issue_enabled? || community_link.present? || can_create_discussions?(user)
+  end
+
+  # Tells if the given user can
+  # create discussion in this organization
+  #
+  # This is true only when this organization has a forum and the user
+  # has the discusser pseudo-permission
+  def can_create_discussions?(user = nil)
+    forum_enabled? && (!user || user.discusser_of?(self))
+  end
+
+  def import_from_resource_h!(resource_h)
+    attrs = self.class.slice_resource_h resource_h
+    attrs[:book] = Book.locate! attrs[:book]
+    update! attrs
+  end
+
+  def to_resource_h
+    super.merge(book: book.slug)
+  end
+
+  private
+
+  def ensure_consistent_public_login
+    errors.add(:base, :consistent_public_login) if settings.customized_login_methods? && public?
+  end
+
+  def notify_assignments!(assignments)
+    assignments.each { |assignment| assignment.notify! }
+  end
+
+  class << self
+    def central
+      find_by name: 'central'
+    end
+
+    def base
+      find_by name: 'base'
+    end
+
+    def silenced?
+      !Mumukit::Platform::Organization.current? || current.silent?
+    end
+
+    def sync_key_id_field
+      :name
+    end
+
+    # Answers organizations that have the given item
+    # in their paths.
+    #
+    # Warning: unlike `in_path?`, this method does only work with
+    # content - child - items instead of both kind of items - content and content containers.
+    #
+    # See `Organization#in_path?`
+    def in_path(content)
+      joins(:usages).where('usages.item': content).distinct
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-a059418e5fd8/app/models/progress.rb

@@ -0,0 +1,15 @@
+class Progress < ApplicationRecord
+  self.abstract_class = true
+
+  before_save :parent, unless: :parent_id?
+  belongs_to :parent, class_name: 'Indicator', optional: true
+
+  def parent
+    assign_attributes(parent: parent_content&.progress_for(user, organization)) unless super
+    super
+  end
+
+  def dirty_parent_by_submission!
+    parent&.dirty_by_submission!
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-a059418e5fd8/app/models/stats.rb

@@ -0,0 +1,24 @@
+class Stats
+  include ActiveModel::Model
+
+  attr_accessor :passed, :passed_with_warnings, :failed, :pending, :skipped
+
+  def submitted
+    passed + passed_with_warnings + failed
+  end
+
+  def done?
+    failed + pending == 0
+  end
+
+  def started?
+    submitted > 0
+  end
+
+  def self.from_statuses(statuses)
+    Stats.new(statuses.inject({passed: 0, passed_with_warnings: 0, failed: 0, pending: 0, skipped: 0}) do |accum, status|
+      accum[status.group.to_sym] += 1
+      accum
+    end)
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-a059418e5fd8/app/models/subscription.rb

@@ -0,0 +1,12 @@
+class Subscription < ApplicationRecord
+  belongs_to :user
+  belongs_to :discussion
+
+  def unread!
+    update! read: false
+  end
+
+  def read!
+    update! read: true
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-a059418e5fd8/app/models/topic.rb

@@ -0,0 +1,63 @@
+class Topic < Content
+  numbered :lessons
+  aggregate_of :lessons
+
+  has_many :lessons, -> { order(number: :asc) }, dependent: :delete_all
+
+  has_many :guides, -> { order('lessons.number') }, through: :lessons
+  has_many :exercises, -> { order('exercises.number') }, through: :guides
+
+  markdown_on :appendix
+
+  alias_method :structural_children, :lessons
+
+  def first_lesson
+    lessons.first
+  end
+
+  def import_from_resource_h!(resource_h)
+    dirty_progress_if_structural_children_changed! do
+      self.assign_attributes resource_h.except(:lessons, :description)
+      self.description = resource_h[:description].squeeze(' ')
+      rebuild_lessons! resource_h[:lessons].to_a.map { |it| lesson_for(it) }
+    end
+  end
+
+  def to_expanded_resource_h
+    super.merge(appendix: appendix, lessons: lessons.map(&:slug))
+  end
+
+  def as_chapter_of(book)
+    book.chapters.find_by(topic_id: id) || Chapter.new(topic: self, book: book)
+  end
+
+  def reindex_usages!
+    Chapter.where(topic: self).map(&:book).each(&:reindex_usages!)
+  end
+
+  ## Forking
+
+  def fork_children_into!(dup, organization, syncer)
+    dup.lessons = lessons.map { |lesson| lesson.guide.fork_to!(organization, syncer, quiet: true).as_lesson_of(dup) }
+  end
+
+  def pending_lessons(user)
+    guides.
+      joins('left join public.exercises exercises
+                on exercises.guide_id = guides.id').
+      joins("left join public.assignments assignments
+                on assignments.exercise_id = exercises.id
+                and assignments.submitter_id = #{user.id}
+                and assignments.submission_status = #{Mumuki::Domain::Status::Submission::Passed.to_i}").
+      where('assignments.id is null').
+      group('public.guides.id', 'lessons.number').map(&:lesson)
+  end
+
+  private
+
+  def lesson_for(slug)
+    Guide.find_by!(slug: slug).as_lesson_of(self)
+  rescue ActiveRecord::RecordNotFound
+    raise "Guide for slug #{slug} could not be found"
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-a059418e5fd8/app/models/upvote.rb

@@ -0,0 +1,4 @@
+class Upvote < ApplicationRecord
+  belongs_to :user
+  belongs_to :discussion, counter_cache: true
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-a059418e5fd8/app/models/usage.rb

@@ -0,0 +1,33 @@
+class Usage < ApplicationRecord
+  belongs_to :organization
+
+  belongs_to :item, polymorphic: true
+  belongs_to :parent_item, polymorphic: true
+
+  scope :in_organization, ->(organization = Organization.current) { where(organization_id: organization.id) }
+
+  before_save :set_slug
+  before_destroy :destroy_children_usages!
+
+  def self.destroy_all_where(query)
+    where(query).destroy_all
+  end
+
+  def self.destroy_usages_for(record)
+    destroy_all_where(parent_item: record)
+  end
+
+  def destroy_children_usages!
+    item.structural_children.each { |child| Usage.destroy_all_where(parent_item: child, organization: organization) }
+  end
+
+  def index_children!(children)
+    children.each { |it| it.index_usage! organization }
+  end
+
+  private
+
+  def set_slug
+    self.slug = item.slug
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-a059418e5fd8/app/models/user.rb

@@ -0,0 +1,192 @@
+class User < ApplicationRecord
+  include Mumuki::Domain::Syncable
+  include WithProfile,
+          WithUserNavigation,
+          WithReminders,
+          WithDiscussionCreation,
+          Disabling,
+          Mumuki::Domain::Helpers::User
+
+  serialize :permissions, Mumukit::Auth::Permissions
+
+  has_many :assignments, foreign_key: :submitter_id
+
+  has_many :messages, -> { order(created_at: :desc) }, through: :assignments
+
+  has_many :submitted_exercises, through: :assignments, class_name: 'Exercise', source: :exercise
+
+  has_many :solved_exercises,
+           -> { where('assignments.submission_status' => Mumuki::Domain::Status::Submission::Passed.to_i) },
+           through: :assignments,
+           class_name: 'Exercise',
+           source: :exercise
+
+  belongs_to :last_exercise, class_name: 'Exercise', optional: true
+  belongs_to :last_organization, class_name: 'Organization', optional: true
+
+  has_one :last_guide, through: :last_exercise, source: :guide
+
+  has_many :exam_authorizations
+
+  has_many :exams, through: :exam_authorizations
+
+  after_initialize :init
+
+  enum gender: %i(female male other unspecified)
+
+  belongs_to :avatar, optional: true
+
+  before_validation :set_uid!
+  validates :uid, presence: true
+
+  resource_fields :uid, :social_id, :email, :permissions, :verified_first_name, :verified_last_name, *profile_fields
+
+  def last_lesson
+    last_guide.try(:lesson)
+  end
+
+  def submissions_count
+    assignments.pluck(:submissions_count).sum
+  end
+
+  def passed_submissions_count
+    passed_assignments.count
+  end
+
+  def submitted_exercises_count
+    submitted_exercises.count
+  end
+
+  def solved_exercises_count
+    solved_exercises.count
+  end
+
+  def passed_assignments
+    assignments.where(status: Mumuki::Domain::Status::Submission::Passed.to_i)
+  end
+
+  def unread_messages
+    messages.where read: false
+  end
+
+  def visit!(organization)
+    update!(last_organization: organization) if organization != last_organization
+  end
+
+  def to_s
+    "#{id}:#{name}:#{uid}"
+  end
+
+  def never_submitted?
+    last_submission_date.nil?
+  end
+
+  def clear_progress!
+    transaction do
+      update! last_submission_date: nil, last_exercise: nil
+      assignments.destroy_all
+    end
+  end
+
+  def accept_invitation!(invitation)
+    make_student_of! invitation.course_slug
+  end
+
+  def transfer_progress_to!(another)
+    transaction do
+      assignments.update_all(submitter_id: another.id)
+      if another.never_submitted? || last_submission_date.try { |it| it > another.last_submission_date }
+        another.update! last_submission_date: last_submission_date,
+                        last_exercise: last_exercise,
+                        last_organization: last_organization
+      end
+    end
+    reload
+  end
+
+  def import_from_resource_h!(json)
+    update! self.class.slice_resource_h json
+  end
+
+  def to_resource_h
+    super.merge(image_url: profile_picture)
+  end
+
+  def verify_name!
+    self.verified_first_name ||= first_name
+    self.verified_last_name ||= last_name
+    save!
+  end
+
+  def unsubscribe_from_reminders!
+    update! accepts_reminders: false
+  end
+
+
+  def attach!(role, course)
+    add_permission! role, course.slug
+    save_and_notify!
+  end
+
+  def detach!(role, course)
+    remove_permission! role, course.slug
+    save_and_notify!
+  end
+
+  def interpolations
+    {
+      'user_email' => email,
+      'user_first_name' => first_name,
+      'user_last_name' => last_name
+    }
+  end
+
+  def currently_in_exam?
+    exams.any? { |e| e.in_progress_for? self }
+  end
+
+  def profile_picture
+    avatar&.image_url || image_url
+  end
+
+  def bury!
+    # TODO change avatar
+    update! self.class.buried_profile.merge(accepts_reminders: false, gender: nil, birthdate: nil)
+  end
+
+  private
+
+  def set_uid!
+    self.uid ||= email
+  end
+
+  def init
+    # Temporarily keep using image_url until avatars are created
+    # self.avatar = Avatar.sample unless profile_picture.present?
+
+    self.image_url ||= "user_shape.png"
+  end
+
+  def self.sync_key_id_field
+    :uid
+  end
+
+  def self.unsubscription_verifier
+    Rails.application.message_verifier(:unsubscribe)
+  end
+
+  def self.create_if_necessary(user)
+    user[:uid] ||= user[:email]
+    where(uid: user[:uid]).first_or_create(user)
+  end
+
+  # Call this method once as part of application initialization
+  # in order to enable user profile override as part of disabling process
+  def self.configure_buried_profile!(profile)
+    @buried_profile = profile
+  end
+
+  def self.buried_profile
+    (@buried_profile || {}).slice(:first_name, :last_name, :email)
+  end
+end