mumuki-laboratory 7.9.2 → 7.10.0

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

@@ -1,92 +0,0 @@
-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?
-
-  after_save :update_counters_cache!
-  after_destroy :update_counters_cache!
-
-  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_moderator?
-    sender_user.moderator_here?
-  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, :not_actually_a_question],
-            include: {exercise: {only: [:bibliotheca_id]}})
-        .merge(organization: Organization.current.name)
-  end
-
-  def read!
-    update! read: true
-  end
-
-  def toggle_approved!
-    toggle! :approved
-  end
-
-  def toggle_not_actually_a_question!
-    toggle! :not_actually_a_question
-  end
-
-  def validated?
-    approved? || from_moderator?
-  end
-
-  def update_counters_cache!
-    discussion&.update_counters!
-  end
-
-  def question?
-    from_initiator? && !not_actually_a_question?
-  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.6.0/bundler/gems/mumuki-domain-7082a83493eb/app/models/organization.rb

@@ -1,181 +0,0 @@
-class Organization < ApplicationRecord
-  include Mumuki::Domain::Syncable
-  include Mumuki::Domain::Helpers::Organization
-  include Mumuki::Domain::Area
-
-  include Mumukit::Login::OrganizationHelpers
-
-  include WithTargetAudience
-
-  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
-  validate :ensure_valid_activity_range
-
-  belongs_to :book
-  has_many :usages
-
-  validates_presence_of :contact_email, :locale
-  validates_presence_of :welcome_email_template, if: :greet_new_users?
-  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)
-    report_issue_enabled? || community_link.present? || user.can_discuss_in?(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
-
-  def to_organization
-    self
-  end
-
-  def enable_progressive_display!(lookahead: 1)
-    update! progressive_display_lookahead: lookahead
-  end
-
-  def display_name
-    name.gsub(/\W/, ' ').titleize
-  end
-
-  private
-
-  def ensure_consistent_public_login
-    errors.add(:base, :consistent_public_login) if settings.customized_login_methods? && public?
-  end
-
-  def ensure_valid_activity_range
-    if in_preparation_until.present? && disabled_from.present?
-      errors.add(:base, :invalid_activity_range) if in_preparation_until.to_datetime >= disabled_from.to_datetime
-    end
-  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.6.0/bundler/gems/mumuki-domain-7082a83493eb/app/models/progress.rb

@@ -1,15 +0,0 @@
-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.6.0/bundler/gems/mumuki-domain-7082a83493eb/app/models/stats.rb

@@ -1,24 +0,0 @@
-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.6.0/bundler/gems/mumuki-domain-7082a83493eb/app/models/subscription.rb

@@ -1,12 +0,0 @@
-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.6.0/bundler/gems/mumuki-domain-7082a83493eb/app/models/topic.rb

@@ -1,63 +0,0 @@
-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.6.0/bundler/gems/mumuki-domain-7082a83493eb/app/models/upvote.rb

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

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

@@ -1,33 +0,0 @@
-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.6.0/bundler/gems/mumuki-domain-7082a83493eb/app/models/user.rb

@@ -1,300 +0,0 @@
-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
-
-  enum gender: %i(female male other unspecified)
-  belongs_to :avatar, optional: true
-
-  before_validation :set_uid!
-  validates :uid, presence: true
-
-  after_save :welcome_to_new_organizations!, if: :gained_access_to_new_orga?
-  after_initialize :init
-  PLACEHOLDER_IMAGE_URL = 'user_shape.png'.freeze
-
-  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 custom_profile_picture
-    avatar&.image_url || image_url
-  end
-
-  def profile_picture
-    custom_profile_picture || placeholder_image_url
-  end
-
-  def bury!
-    # TODO change avatar
-    update! self.class.buried_profile.merge(accepts_reminders: false, gender: nil, birthdate: nil)
-  end
-
-  # Takes a didactic - ordered - sequence of content containers
-  # and returns those that have been completed
-  def completed_containers(sequence, organization)
-    sequence.take_while { |it| it.content.completed_for?(self, organization) }
-  end
-
-  # Like `completed_containers`, returns a slice of the completed containers
-  # in the sequence, but adding a configurable number of trailing, non-completed contaienrs
-  def completed_containers_with_lookahead(sequence, organization, lookahead: 1)
-    raise 'invalid lookahead' if lookahead < 1
-
-    count = completed_containers(sequence, organization).size
-    sequence[0..count + lookahead - 1]
-  end
-
-  # Tells if the given user can discuss in an organization
-  #
-  # This is true only when this organization has the forum enabled and the user
-  # has the discusser pseudo-permission and the discusser is trusted
-  def can_discuss_in?(organization)
-    organization.forum_enabled? && discusser_of?(organization) && trusted_as_discusser_in?(organization)
-  end
-
-  def trusted_as_discusser_in?(organization)
-    trusted_for_forum? || !organization.forum_only_for_trusted?
-  end
-
-  def can_discuss_here?
-    can_discuss_in? Organization.current
-  end
-
-  def can_access_teacher_info_in?(organization)
-    teacher_of?(organization) || organization.teacher_training?
-  end
-
-  def name_initials
-    name.split.map(&:first).map(&:capitalize).join(' ')
-  end
-
-  def progress_at(content, organization)
-    Indicator.find_or_initialize_by(user: self, organization: organization, content: content)
-  end
-
-  def build_assignment(exercise, organization)
-    assignments.build(exercise: exercise, organization: organization)
-  end
-
-  def pending_siblings_at(content)
-    content.pending_siblings_for(self)
-  end
-
-  def next_exercise_at(guide)
-    guide.pending_exercises(self).order('public.exercises.number asc').first
-  end
-
-  def run_submission!(submission, assignment, evaluation)
-    submission.run! assignment, evaluation
-  end
-
-  def incognito?
-    false
-  end
-
-  def current_audience
-    current_organic_context&.target_audience
-  end
-
-  def placeholder_image_url
-    PLACEHOLDER_IMAGE_URL
-  end
-
-  def age
-    if birthdate.present?
-      @age ||= Time.now.round_years_since(birthdate.to_time)
-    end
-  end
-
-  private
-
-  def welcome_to_new_organizations!
-    new_accessible_organizations.each do |organization|
-      UserMailer.welcome_email(self, organization).deliver_now rescue nil if organization.greet_new_users?
-    end
-  end
-
-  def gained_access_to_new_orga?
-    new_accessible_organizations.present?
-  end
-
-  def new_accessible_organizations
-    return [] unless saved_change_to_permissions?
-
-    old, new = saved_change_to_permissions
-    new_organizations = (new.any_granted_organizations - old.any_granted_organizations).to_a
-    Organization.where(name: new_organizations)
-  end
-
-  def set_uid!
-    self.uid ||= email
-  end
-
-  def init
-    if custom_profile_picture.blank?
-      self.avatar = Avatar.sample_for(self)
-      save if persisted?
-    end
-  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
-
-  def current_organic_context
-    if Organization.current?
-      Organization.current
-    else
-      main_organization
-    end
-  end
-end