mumuki-domain 6.0.0

data/app/models/concerns/with_scoped_queries/page.rb

@@ -0,0 +1,10 @@
+module WithScopedQueries::Page
+  def self.query_by(params, current_scope, _)
+    page_param = params[:page] || 1
+    current_scope.page(page_param)
+  end
+
+  def self.add_queriable_attributes_to(klass, _)
+    klass.queriable_attributes.merge!(page: :page)
+  end
+end

data/app/models/concerns/with_scoped_queries/sort.rb

@@ -0,0 +1,47 @@
+module WithScopedQueries::Sort
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :sorting_fields, :default_sorting_field, instance_writer: false
+  end
+
+  def self.query_by(params, scope, klass)
+    sort_param = params[:sort] || klass.default_sorting_field.to_s
+    normalized_params = normalize_params(sort_param)
+    if sort_param.present? && klass.sorting_params_allowed?(*normalized_params)
+      sort_method_for(klass, scope, *normalized_params)
+    else
+      scope
+    end
+  end
+
+  def self.normalize_params(param)
+    param&.split(/_(?!.*_)/)
+  end
+
+  def self.add_queriable_attributes_to(klass, attributes)
+    klass.default_sorting_field = attributes.extract_options![:default]
+    klass.sorting_fields = attributes
+    klass.queriable_attributes.merge!(sort: :sort)
+  end
+
+  def self.sort_method_for(klass, scope, field, direction)
+    if klass.column_names.include? field
+      scope.public_send(:reorder, "#{klass.table_name}.#{field} #{direction}")
+    else
+      scope.public_send("order_by_#{field}", direction)
+    end
+  end
+
+  class_methods do
+    def sorting_filters
+      sorting_fields.product([:asc, :desc]).map do |it|
+        "#{it.first}_#{it.second}"
+      end
+    end
+
+    def sorting_params_allowed?(sort_param, direction_param=nil)
+      sorting_fields.include?(sort_param.to_sym) && [:asc, :desc].include?(direction_param&.to_sym)
+    end
+  end
+end

data/app/models/concerns/with_scoped_queries.rb

@@ -0,0 +1,47 @@
+module WithScopedQueries
+  extend ActiveSupport::Concern
+
+  SCOPING_METHODS = [Filter, Sort, Page]
+
+  included do
+    class_attribute :queriable_attributes, instance_writer: false
+    self.queriable_attributes = {}
+
+    SCOPING_METHODS.each do |mod|
+      define_singleton_method "#{mod.name.demodulize.underscore}able" do |*attributes|
+        include mod
+        mod.add_queriable_attributes_to(self, attributes)
+      end
+    end
+  end
+
+  class_methods do
+    def query_methods
+      queriable_attributes.keys
+    end
+
+    def scoped_query_module(method)
+      "WithScopedQueries::#{method.to_s.camelcase}".constantize
+    end
+
+    def permitted_query_params
+      queriable_attributes.values.flatten
+    end
+
+    def actual_params(params, excluded_param)
+      params.reject { |it| it == excluded_param.to_s }
+    end
+
+    def scoped_query_by(params, excluded_param=nil)
+      query_methods.inject(all) do |scope, method|
+        valid_params = valid_params_for(method, params, excluded_param)
+        scoped_query_module(method).query_by valid_params, scope, self
+      end
+    end
+
+    def valid_params_for(method, params, excluded_param)
+      actual_params = actual_params(params, excluded_param)
+      actual_params.permit queriable_attributes[method]
+    end
+  end
+end

data/app/models/concerns/with_slug.rb

@@ -0,0 +1,52 @@
+#TODO may use mumukit slug
+module WithSlug
+  extend ActiveSupport::Concern
+
+  included do
+    validates_presence_of :slug
+    validates_uniqueness_of :slug
+  end
+
+  def slug_parts
+    org, repo = slug.split('/')
+    {organization: org, repository: repo}
+  end
+
+  ## Resource Protocol
+
+  def sync_key
+    Mumukit::Sync.key self.class.name.underscore.to_sym, slug
+  end
+
+  ## Copy and Rebase
+
+  def rebase!(organization)
+    self.slug = self.slug.to_mumukit_slug.rebase(organization).to_s
+  end
+
+  def rebased_dup(organization)
+    dup.tap { |it| it.rebase! organization }
+  end
+
+  ## Filtering
+
+  module ClassMethods
+
+    def allowed(permissions)
+      all.select { |it| permissions&.writer?(it.slug) }
+    end
+
+    def visible(permissions)
+      # FIXME no truly generic
+      all.select { |it| !it.private? || permissions&.writer?(it.slug) }
+    end
+
+    def by_slug_parts!(args)
+      find_by!(slug: "#{args[:organization]}/#{args[:repository]}")
+    end
+
+    def locate_resource(key)
+      find_or_initialize_by(slug: key)
+    end
+  end
+end

data/app/models/concerns/with_usages.rb

@@ -0,0 +1,16 @@
+module WithUsages
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :usages, as: :item
+  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
+end

data/app/models/concerns/with_user_navigation.rb

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

data/app/models/content.rb

@@ -0,0 +1,15 @@
+class Content < ApplicationRecord
+  self.abstract_class = true
+
+  include WithDescription
+  include WithLocale
+  include WithSlug
+  include WithUsages
+  include WithName
+
+  def to_resource_h
+    as_json(only: [:name, :slug, :description, :locale]).symbolize_keys
+  end
+
+end
+

data/app/models/course.rb

@@ -0,0 +1,20 @@
+class Course < ApplicationRecord
+  include Mumukit::Platform::Course::Helpers
+
+  validates_presence_of :slug, :shifts, :code, :days, :period, :description, :organization_id
+  validates_uniqueness_of :slug
+  belongs_to :organization
+
+  def self.import_from_resource_h!(resource_h)
+    json = Mumukit::Platform::Course::Helpers.slice_platform_json resource_h
+    where(slug: json[:slug]).update_or_create!(json)
+  end
+
+  def slug=(slug)
+    s = Mumukit::Auth::Slug.parse(slug)
+
+    self[:slug] = slug
+    self[:code] = s.course
+    self[:organization_id] = Organization.find_by!(name: s.organization).id
+  end
+end

data/app/models/discussion.rb

@@ -0,0 +1,136 @@
+class Discussion < ApplicationRecord
+  include WithDiscussionStatus, ParentNavigation, WithScopedQueries, Contextualization
+
+  belongs_to :item, polymorphic: true
+  has_many :messages, -> { order(:created_at) }, dependent: :delete_all
+  belongs_to :initiator, class_name: 'User'
+  belongs_to :exercise, foreign_type: :exercise, foreign_key: 'item_id'
+  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?)
+      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)
+    item.used_in?(organization)
+  end
+
+  def commentable_by?(user)
+    user&.moderator? || (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)
+    unread_subscriptions(user)
+  end
+
+  def authorized?(user)
+    initiator?(user) || user.try(:moderator?)
+  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/app/models/event.rb

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

data/app/models/exam.rb

@@ -0,0 +1,147 @@
+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::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)
+    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_resource_h!(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