mumuki-laboratory 5.5.0 → 5.6.0

data/app/models/concerns/with_discussion_status.rb

@@ -0,0 +1,11 @@
+module WithDiscussionStatus
+  extend ActiveSupport::Concern
+
+  included do
+    serialize :status, Mumuki::Laboratory::Status::Discussion
+    validates_presence_of :status
+    scope :by_status, -> (status) { where(status: status) }
+  end
+
+  delegate :closed?, :opened?, :solved?, :pending_review?, :reachable_statuses, to: :status
+end

data/app/models/concerns/with_discussions.rb

@@ -0,0 +1,23 @@
+module WithDiscussions
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :discussions, as: :item
+  end
+
+  def discuss!(user, discussion)
+    discussion.merge!(initiator_id: user.id)
+    discussion.merge!(submission: submission_for(user)) if submission_for(user).present?
+    created_discussion = discussions.create discussion
+    user.subscribe_to! created_discussion
+    created_discussion
+  end
+
+  def submission_for(_)
+    nil
+  end
+
+  def try_solve_discussions(user)
+    discussions.where(initiator: user).map(&:try_solve!)
+  end
+end

data/app/models/concerns/with_randomizations.rb

@@ -0,0 +1,34 @@
+module WithRandomizations
+  extend ActiveSupport::Concern
+
+  included do
+    serialize :randomizations, Hash
+  end
+
+  def seed
+    @seed || 0
+  end
+
+  def seed_with!(seed)
+    @seed = seed
+  end
+
+  def randomizer
+    @randomizer ||= Mumukit::Randomizer.parse(randomizations)
+  end
+
+  module ClassMethods
+    def randomize(*selectors)
+      selectors.each { |selector| randomize_field selector }
+    end
+
+    private
+
+    def randomize_field(selector)
+      define_method(selector) do |*args|
+        return unless super(*args)
+        randomizer.randomize!(super(*args), seed)
+      end
+    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_scoped_queries/filter.rb

@@ -0,0 +1,15 @@
+module WithScopedQueries::Filter
+  def self.query_by(params, current_scope, _)
+    params.to_h.inject(current_scope) do |scope, (field, value)|
+      if value.present?
+        scope.public_send("by_#{field}", value)
+      else
+        scope
+      end
+    end
+  end
+
+  def self.add_queriable_attributes_to(klass, attributes)
+    klass.queriable_attributes.merge!(filter: attributes)
+  end
+end

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(:order, "#{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/discussion.rb

@@ -0,0 +1,128 @@
+class Discussion < ApplicationRecord
+  include WithDiscussionStatus, ParentNavigation, WithScopedQueries, Contextualization
+
+  belongs_to :item, polymorphic: true
+  has_many :messages
+  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
+
+  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)
+    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?
+  end
+
+  def responses_count
+    messages.where.not(sender: initiator.uid).count
+  end
+
+  def has_responses?
+    responses_count > 0
+  end
+
+  def self.debatable_for(klazz, params)
+    debatable_id = params[:"#{klazz.underscore}_id"]
+    klazz.constantize.find(debatable_id)
+  end
+end

data/app/models/exercise.rb

@@ -6,7 +6,8 @@ class Exercise < ApplicationRecord
           FriendlyName,
           WithLanguage,
           Assistable,
-          WithRandomizations
+          WithRandomizations,
+          WithDiscussions
 
   include Submittable,
           Questionable
@@ -67,6 +68,10 @@ class Exercise < ApplicationRecord
     defaulting_name { "#{navigable_parent.friendly} - #{name}" }
   end
 
+  def submission_for(user)
+    assignment_for(user)&.submission
+  end
+
   def new_solution
     Solution.new(content: default_content)
   end
@@ -133,6 +138,10 @@ class Exercise < ApplicationRecord
     false
   end
 
+  def inspection_keywords
+    {}
+  end
+
   private
 
   def evaluation_class

data/app/models/guide.rb

@@ -37,7 +37,7 @@ class Guide < Content
         joins("left join public.assignments assignments
                 on assignments.exercise_id = exercises.id
                 and assignments.submitter_id = #{user.id}
-                and assignments.status = #{Mumuki::Laboratory::Status::Passed.to_i}").
+                and assignments.submission_status = #{Mumuki::Laboratory::Status::Submission::Passed.to_i}").
         where('assignments.id is null')
   end
 

data/app/models/message.rb

@@ -1,18 +1,39 @@
 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 :submission_id, :content, :sender
-
+  validates_presence_of :content, :sender
+  validates_presence_of :submission_id, :unless => :discussion_id?
   markdown_on :content
 
   def notify!
     Mumukit::Nuntius.notify! 'student-messages', as_platform_json
   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?
+  end
+
+  def authorize!
+    raise Mumukit::Auth::UnauthorizedAccessError unless authorized?(current_user)
+  end
+
   def as_platform_json
-    as_json(except: [:id, :type],
+    as_json(except: [:id, :type, :discussion_id],
             include: {exercise: {only: [:bibliotheca_id]}})
       .merge(organization: Organization.current.name)
   end

data/app/models/organization.rb

@@ -92,6 +92,10 @@ class Organization < ApplicationRecord
     central? ? 'mumuki' : name
   end
 
+  def ask_for_help_enabled?
+    report_issue_enabled? || community_link.present? || forum_enabled?
+  end
+
   private
 
   def ensure_consistent_public_login

data/app/models/submission/confirmation.rb

@@ -4,6 +4,6 @@ class Confirmation < PersistentSubmission
   end
 
   def try_evaluate!(*)
-    {status: Mumuki::Laboratory::Status::Passed, result: ''}
+    {status: Mumuki::Laboratory::Status::Submission::Passed, result: ''}
   end
 end

data/app/models/submission/console_submission.rb

@@ -7,7 +7,7 @@ class ConsoleSubmission < Submission
 
   def format_query_result!(results)
     results[:result] = I18n.t(:try_again) if results[:status] == :aborted
-    results[:status] = results[:status].to_mumuki_status
+    results[:status] = results[:status].to_submission_status
     results
   end
 end

data/app/models/submission/submission.rb

@@ -5,6 +5,19 @@ class Submission
 
   required :try_evaluate!
 
+  ATTRIBUTES = [:solution, :status, :result, :expectation_results, :feedback, :test_results,
+                :submission_id, :queries, :query_results, :manual_evaluation_comment]
+
+  attr_accessor *ATTRIBUTES
+
+  def self.from_attributes(*args)
+    new ATTRIBUTES.zip(args).to_h
+  end
+
+  def self.mapping_attributes
+    ATTRIBUTES
+  end
+
   def run!(assignment, evaluation)
     save_submission! assignment
     results = evaluation.evaluate! assignment, self