mumuki-classroom 8.0.0

data/lib/mumuki/classroom/models/concerns/with_submission_process.rb

@@ -0,0 +1,148 @@
+module WithSubmissionProcess
+  def process!(data)
+    json = data.deep_symbolize_keys
+
+    json[:course] = find_submission_course! json
+    json[:student] = find_student_from json
+
+    update_assignment json
+    update_guide_progress json
+    update_student_progress json
+    update_student_last_assignment json
+  end
+
+  def organization(json)
+    json[:organization]
+  end
+
+  def find_submission_course!(json)
+    student = Mumuki::Classroom::Student.last_updated_student_by(organization: organization(json), uid: uid(json))
+    raise ActiveRecord::RecordNotFound, "Mumuki::Classroom::Student not found" unless student
+    student.course
+  end
+
+  def find_student_from(json)
+    Mumuki::Classroom::Student.find_by(organization: organization(json), course: course_slug(json), uid: uid(json)).as_json
+  end
+
+  def update_student_progress(json)
+    Mumuki::Classroom::Student.find_by!(organization: organization(json), course: course_slug(json), uid: uid(json)).update_all_stats
+  end
+
+  def update_student_last_assignment(json)
+    Mumuki::Classroom::Student.find_by!(organization: organization(json), course: course_slug(json), uid: uid(json)).update_last_assignment_for
+  end
+
+  def update_assignment(json)
+    assignment = Mumuki::Classroom::Assignment
+                   .where(assignment_query(json))
+                   .first_or_create!(assignment_without_submission_from(json))
+    assignment.upsert_attributes(assignment_without_submission_from(json))
+    assignment.add_submission! submission_from(json)
+  end
+
+  def assignment_query(json)
+    guide_progress_query(json).merge 'exercise.eid': exercise_from(json)[:eid]
+  end
+
+  def guide_progress_query(json)
+    {'organization': organization(json),
+     'course': course_slug(json),
+     'guide.slug': guide_from(json)[:slug],
+     'student.uid': uid(json)}
+  end
+
+  def update_guide_progress(json)
+    json[:stats] = student_stats_for json
+    Mumuki::Classroom::GuideProgress
+      .where(guide_progress_query(json))
+      .first_or_create!(guide_progress_from json)
+      .upsert_attributes(guide_progress_from json)
+  end
+
+  def student_stats_for(json)
+    Mumuki::Classroom::Assignment.stats_by guide_progress_query(json)
+  end
+
+  def uid(json)
+    json[:submitter][:uid]
+  end
+
+  def course_slug(json)
+    json[:course]
+  end
+
+  def guide_progress_from(json)
+    {guide: guide_from(json),
+     student: student_from(json),
+     stats: stats_from(json),
+     last_assignment: {exercise: exercise_from(json),
+                       submission: submission_from(json)}}
+  end
+
+  def assignment_without_submission_from(json)
+    {guide: guide_from(json),
+     student: student_from(json),
+     exercise: exercise_from(json)}
+  end
+
+  def assignment_from(json)
+    assignment_without_submission_from.merge submission: submission_from(json)
+  end
+
+  def stats_from(json)
+    stats = json[:stats]
+
+    {passed: stats[:passed],
+     failed: stats[:failed],
+     passed_with_warnings: stats[:passed_with_warnings]}.compact
+  end
+
+  def student_from(json)
+    student = json[:student]
+
+    {uid: student[:uid],
+     name: student[:name],
+     email: student[:email],
+     image_url: student[:image_url],
+     social_id: student[:social_id],
+     last_name: student[:last_name],
+     first_name: student[:first_name]}.compact
+  end
+
+  def guide_from(json)
+    guide = json[:guide]
+
+    classroom_guide = {
+      slug: guide[:slug],
+      name: guide[:name],
+      parent: guide[:parent],
+      language: {
+        name: guide[:language][:name],
+        devicon: guide[:language][:devicon]
+      }.compact
+    }
+    classroom_guide.compact
+  end
+
+  def exercise_from(json)
+    exercise = json[:exercise]
+
+    {eid: exercise[:eid],
+     name: exercise[:name],
+     number: exercise[:number]}.compact
+  end
+
+  def submission_from(json)
+    {sid: json[:sid],
+     status: json[:status],
+     result: json[:result],
+     content: json[:content],
+     feedback: json[:feedback],
+     created_at: json[:created_at],
+     test_results: json[:test_results],
+     submissions_count: json[:submissions_count],
+     expectation_results: json[:expectation_results],
+     origin_ip: json[:origin_ip]}.compact
+  end
+end

data/lib/mumuki/classroom/models/document.rb

@@ -0,0 +1,12 @@
+class Mumuki::Classroom::Document
+
+  def self.whitelist_attributes(json)
+    json.with_indifferent_access.except(:created_at, :updated_at, :_id).slice(*attribute_names)
+  end
+
+  def self.inherited(subclass)
+    super
+    subclass.include Mongoid::Document
+    subclass.store_in collection: subclass.name.demodulize.tableize
+  end
+end

data/lib/mumuki/classroom/models/exercise.rb

@@ -0,0 +1,7 @@
+class Mumuki::Classroom::Exercise < Mumuki::Classroom::Document
+
+  field :eid, type: Integer
+  field :number, type: Integer
+  field :name, type: String
+
+end

data/lib/mumuki/classroom/models/failed_submission.rb

@@ -0,0 +1,16 @@
+class Mumuki::Classroom::FailedSubmission < Mumuki::Classroom::Document
+
+  extend WithFailedSubmissionReprocess
+
+  include Mongoid::Attributes::Dynamic
+
+  field :created_at, type: Time
+
+  create_index 'organization': 1, 'submitter.uid': 1
+  create_index({'guide.slug': 1, 'exercise.eid': 1}, {name: 'ExBibIdIndex'})
+
+  scope :for, -> (organization) { where 'organization': organization }
+  scope :find_by_uid, -> (uid) { where 'submitter.uid': uid }
+
+
+end

data/lib/mumuki/classroom/models/follower.rb

@@ -0,0 +1,19 @@
+class Mumuki::Classroom::Follower < Mumuki::Classroom::Document
+  include Mongoid::Timestamps
+
+  field :uids, type: Array
+  field :email, type: String
+  field :course, type: String
+  field :organization, type: String
+
+  create_index({organization: 1, course: 1, email: 1}, {unique: true})
+
+  def add!(uid)
+    self.add_to_set uids: uid
+  end
+
+  def remove!(uid)
+    self.pull uids: uid
+  end
+
+end

data/lib/mumuki/classroom/models/guide_progress.rb

@@ -0,0 +1,57 @@
+class Mumuki::Classroom::GuideProgress < Mumuki::Classroom::Document
+  include Mongoid::Timestamps
+
+  demodulized_model_name
+
+  field :organization, type: String
+  field :course, type: Mumukit::Auth::Slug
+  field :stats, type: Hash
+  field :guide, type: Hash
+
+  embeds_one :student, class_name: 'Mumuki::Classroom::Student'
+  embeds_one :last_assignment
+
+  create_index({'organization': 1, 'course': 1, 'student.uid': 1})
+  create_index({'organization': 1, 'course': 1, 'guide.slug': 1, 'student.uid': 1})
+  create_index({'guide.slug': 1, 'last_assignment.exercise.eid': 1}, {name: 'ExBibIdIndex'})
+  create_index({'student.first_name': 'text', 'student.last_name': 'text', 'student.email': 'text'})
+
+  def slug
+    guide[:slug]
+  end
+
+  class << self
+    def detach_all_by!(query)
+      where(query).set(detached: true)
+    end
+
+    def attach_all_by!(query)
+      where(query).unset(:detached)
+    end
+
+    def destroy_all_by!(query)
+      where(query).destroy
+    end
+
+    def transfer_all_by!(query, new_organization, new_course)
+      where(query).set(organization: new_organization, course: new_course)
+    end
+
+    def last_assignment_by(query)
+      where(query).order_by('last_assignment.submission.created_at': :desc).first.try do |it|
+        Mumuki::Classroom::LastAssignment.new(guide: it.guide,
+                                              exercise: it.last_assignment.exercise,
+                                              submission: {
+                                                sid: it.last_assignment.submission.sid,
+                                                status: it.last_assignment.submission.status,
+                                                created_at: it.last_assignment.submission.created_at,
+                                              })
+      end
+    end
+
+    def uid_field
+      'student.uid'.to_sym
+    end
+  end
+
+end

data/lib/mumuki/classroom/models/last_assignment.rb

@@ -0,0 +1,7 @@
+class Mumuki::Classroom::LastAssignment < Mumuki::Classroom::Document
+
+  field :guide, type: Hash
+  embeds_one :exercise
+  embeds_one :submission, class_name: 'Mumuki::Classroom::Submission'
+
+end

data/lib/mumuki/classroom/models/message.rb

@@ -0,0 +1,32 @@
+class Mumuki::Classroom::Message < Mumuki::Classroom::Document
+  include Mongoid::Timestamps
+
+  field :sender, type: String
+  field :email, type: String
+  field :content, type: String
+  field :type, type: String
+  field :date, type: String
+
+  embedded_in :submission, class_name: 'Mumuki::Classroom::Submission'
+
+  def content
+    Mumukit::ContentType::Markdown.to_html(self[:content])
+  end
+
+  def sent_by?(user)
+    sender == user.uid
+  end
+
+  def with_full_messages(user)
+    self.tap do |message|
+      message[:is_me] = message.sent_by? user
+    end
+  end
+
+  def self.import_from_json!(json)
+    assignment = Mumuki::Classroom::Assignment.find_by!(organization: json[:organization], 'exercise.eid': json[:exercise][:bibliotheca_id], 'student.uid': json[:sender])
+    assignment.add_message!({content: json[:content], sender: json[:sender]}, json[:submission_id])
+    assignment
+  end
+
+end

data/lib/mumuki/classroom/models/notification.rb

@@ -0,0 +1,52 @@
+class Mumuki::Classroom::Notification < Mumuki::Classroom::Document
+  include Mongoid::Timestamps
+
+  field :organization, type: String
+  field :course, type: String
+  field :type, type: String
+  field :read, type: Mongoid::Boolean, default: false
+  field :sender, type: String
+
+  belongs_to :assignment
+
+  create_index({'organization': 1})
+  create_index({'organization': 1, 'read': 1})
+
+  def self.allowed(options, permissions)
+    where(options).select {|notification| permissions.has_permission? :teacher, notification.course}.map(&:with_assignment)
+  end
+
+  def self.page(organization, permissions, page, per_page)
+    where(organization: organization)
+      .sort(created_at: :desc)
+      .skip(per_page * (page - 1))
+      .limit(per_page)
+      .select {|notification| permissions.has_permission? :teacher, notification.course}
+      .map(&:with_assignment)
+  end
+
+  def self.unread(organization, permissions)
+    allowed({organization: organization, read: false}, permissions)
+  end
+
+  def self.import_from_json!(type, assignment)
+    Mumuki::Classroom::Notification.create! organization: assignment.organization,
+                         course: assignment.course,
+                         type: type,
+                         sender: assignment.student[:uid],
+                         assignment: assignment
+  end
+
+  def read!
+    update! read: true
+  end
+
+  def unread!
+    update! read: false
+  end
+
+  def with_assignment
+    as_json.except('assignment_id').merge(assignment: assignment.notification_preview, id: id.to_s)
+  end
+
+end

data/lib/mumuki/classroom/models/reporting.rb

@@ -0,0 +1,24 @@
+module Reporting
+
+  def self.build_pipeline(collection, query, paginated_params, query_params, projection)
+    ordering = "#{Criteria.name}::#{paginated_params[:order_by].to_s.camelize}".constantize
+    sorting = "#{Sorting.name}::#{collection.name.demodulize}::By#{paginated_params[:sort_by].to_s.camelize}".constantize
+    searching = Searching.filter_for(collection, query_params)
+    pipeline query, sorting, ordering, searching, projection
+  end
+
+  def self.aggregate(collection, query, paginated_params, query_params, projection)
+    pipeline = build_pipeline(collection, query, paginated_params, query_params, projection)
+    collection.collection.aggregate pipeline
+  end
+
+  def self.pipeline(query, sorting, ordering, searching, projection)
+    main_pipeline = []
+    main_pipeline << {'$match': query}
+    main_pipeline.concat searching.pipeline
+    main_pipeline.concat sorting.pipeline
+    main_pipeline << {'$project': projection}
+    main_pipeline << {'$sort': sorting.order_by(ordering)}
+  end
+
+end

data/lib/mumuki/classroom/models/searching.rb

@@ -0,0 +1,60 @@
+module Searching
+  VALID_PARAMS = [:query_param, :query_operand]
+
+  class BaseFilter
+    include ActiveModel::Model
+
+    attr_accessor *VALID_PARAMS
+
+    def query
+      {}
+    end
+
+    def pipeline
+      []
+    end
+  end
+
+  class StudentFilter < BaseFilter
+    def query
+      {'$text': {'$search': query_param}}
+    end
+  end
+
+  class NumericFilter < BaseFilter
+    def query_param=(query_param)
+      @query_param = query_param.to_i
+    end
+  end
+
+  def self.default_filter
+    StudentFilter
+  end
+
+  def self.filter_for(collection, query_params)
+    filter_class = filter_class_for(query_params[:query_criteria], collection) || default_filter
+    filter_class.new(valid_params(query_params))
+  end
+
+  def self.valid_params(params)
+    params.select { |it| VALID_PARAMS.include? it }
+  end
+
+  def self.filter_class_for(criteria, collection)
+    if criteria.present?
+      "#{self}::#{collection.model_name}::#{criteria.camelize}".safe_constantize
+    end
+  end
+
+  module QueryOperands
+    def current_query_operand
+      send current_query_operand_method, query_param
+    end
+
+    def current_query_operand_method
+      query_operand || default_query_operand
+    end
+  end
+end
+
+require_relative './searching/guide_progress'