mumuki-classroom 8.0.0

data/lib/mumuki/classroom/collection.rb

@@ -0,0 +1,10 @@
+class Mongo::Collection
+  revamp :insert_many do |_, _, documents, *args, hyper|
+    now = Time.now
+    documents.map do |it|
+      it[:created_at] = now
+      it[:updated_at] = now
+    end
+    hyper.call documents, *args
+  end
+end

data/lib/mumuki/classroom/engine.rb

@@ -0,0 +1,8 @@
+module Mumuki
+  module Classroom
+    class Engine < ::Rails::Engine
+      endpoint Mumuki::Classroom::App
+      config.generators.api_only = true
+    end
+  end
+end

data/lib/mumuki/classroom/event.rb

@@ -0,0 +1,4 @@
+module Mumuki::Classroom::Event
+end
+
+require_relative './event/user_changed'

data/lib/mumuki/classroom/event/user_changed.rb

@@ -0,0 +1,54 @@
+class Mumuki::Classroom::Event::UserChanged
+  class << self
+
+    attr_accessor :changes
+
+    def execute!(user_h)
+      set_diff_permissions user_h
+      update_user_model user_h
+    end
+
+    private
+
+    def update_user_model(user)
+      Organization.pluck(:name).each do |organization|
+        changes[organization]&.each do |change|
+          message = change.description
+          self.send message, organization, user, change.granted_slug if self.respond_to? message, true
+        end
+      end
+    end
+
+    def set_diff_permissions(user)
+      self.changes = Mumukit::Auth::Permissions::Diff.diff(user[:old_permissions], user[:new_permissions]).changes_by_organization
+    end
+
+    def student_added(organization, user, granted_slug)
+      uid = user[:uid]
+      students = Mumuki::Classroom::Student.where(organization: organization, course: granted_slug.to_s, uid: uid)
+      if students.exists?
+        students.first.attach!
+      else
+        student = Mumuki::Classroom::Student.attributes_from_uid uid
+        Mumuki::Classroom::Student.create! student.merge(organization: organization, course: granted_slug.to_s)
+      end
+    end
+
+    def student_removed(organization, user, granted_slug)
+      student = Mumuki::Classroom::Student.find_by!(organization: organization, course: granted_slug.to_s, uid: user[:uid])
+      student.detach!
+    end
+
+    def teacher_added(organization, user, granted_slug)
+      uid = user[:uid]
+      teacher = Mumuki::Classroom::Teacher.find_or_create_by!(organization: organization, course: granted_slug.to_s, uid: uid)
+      teacher.update_attributes!(Mumuki::Classroom::Teacher.attributes_from_uid(uid))
+    end
+
+    def teacher_removed(organization, user, granted_slug)
+      teacher = Mumuki::Classroom::Teacher.find_by!(organization: organization, course: granted_slug.to_s, uid: user[:uid])
+      teacher.destroy!
+    end
+
+  end
+end

data/lib/mumuki/classroom/locales/en.yml

@@ -0,0 +1,3 @@
+---
+en:
+  view_solution: View solution

data/lib/mumuki/classroom/locales/es-CL.yml

@@ -0,0 +1,3 @@
+---
+es-CL:
+  view_solution: Ver solución

data/lib/mumuki/classroom/locales/es.yml

@@ -0,0 +1,3 @@
+---
+es:
+  view_solution: Ver solución

data/lib/mumuki/classroom/locales/pt.yml

@@ -0,0 +1,3 @@
+---
+pt:
+  view_solution: Ver solução

data/lib/mumuki/classroom/models.rb

@@ -0,0 +1,22 @@
+require_relative './models/concerns/extensions'
+require_relative './models/concerns/with_submission_process'
+require_relative './models/concerns/with_failed_submission_reprocess'
+require_relative './models/concerns/course_member'
+
+require_relative './models/document'
+require_relative './models/message'
+require_relative './models/submission'
+require_relative './models/exercise'
+require_relative './models/last_assignment'
+require_relative './models/failed_submission'
+require_relative './models/guide_progress'
+require_relative './models/assignment'
+require_relative './models/follower'
+require_relative './models/student'
+require_relative './models/teacher'
+require_relative './models/notification'
+require_relative './models/suggestion'
+
+require_relative './models/sorting'
+require_relative './models/searching'
+require_relative './models/reporting'

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

@@ -0,0 +1,148 @@
+class Mumuki::Classroom::Assignment < Mumuki::Classroom::Document
+  include Mongoid::Timestamps
+
+  field :guide, type: Hash
+  field :student, type: Hash
+  field :organization, type: String
+  field :course, type: Mumukit::Auth::Slug
+  embeds_one :exercise, class_name: 'Mumuki::Classroom::Exercise'
+  embeds_many :submissions, class_name: 'Mumuki::Classroom::Submission'
+
+  create_index({'organization': 1, 'course': 1, 'student.uid': 1})
+  create_index({'organization': 1, 'exercise.eid': 1, 'student.uid': 1})
+  create_index({'organization': 1, 'course': 1, 'guide.slug': 1, 'exercise.eid': 1, 'student.uid': 1})
+  create_index({'organization': 1, 'course': 1, 'guide.slug': 1, 'student.uid': 1, 'exercise.eid': 1})
+  create_index({'guide.slug': 1, 'exercise.eid': 1}, {name: 'ExBibIdIndex'})
+
+  def evaluate_manually!(sid, comment, status)
+    submission = submission(sid)
+    submission.evaluate_manually! comment, status
+    update_submissions!
+  end
+
+  def submission(sid)
+    submissions.find_by!(sid: sid)
+  end
+
+  def add_message!(message, sid)
+    submission(sid).tap do |it|
+      it.add_message! message
+      update_submissions!
+    end
+  end
+
+  def add_submission!(submission)
+    self.submissions << Mumuki::Classroom::Submission.new(submission.as_json)
+    update_submissions!
+  end
+
+  def notify_message!(message, sid)
+    Mumukit::Nuntius.notify! 'teacher-messages', json_to_notify(message, sid)
+  end
+
+  def notify_manual_evaluation!(sid)
+    assignment = {submission_id: sid}.merge(submission(sid).as_json only: [:status, :manual_evaluation])
+    Mumukit::Nuntius.notify_event!('AssignmentManuallyEvaluated', {assignment: assignment}, {sender: :classroom})
+  end
+
+  def json_to_notify(message, sid)
+    {
+      message: message,
+      submission_id: sid,
+      exercise_id: exercise.eid,
+      organization: organization
+    }.as_json
+  end
+
+  def threads(language)
+    language = guide[:language][:name] if language.blank?
+    submissions.map { |it| it.thread(language) }.compact
+  end
+
+  def with_full_messages(user)
+    self[:submissions] = submissions.map { |it| it.with_full_messages user }
+    self
+  end
+
+  def add_message_to_submission!(message, sid)
+    submission = add_message! message, sid
+    notify_message! message, sid
+    submission
+  end
+
+  def notification_preview
+    as_json(
+        only: %i(course exercise guide student),
+        include: {
+            exercise: {
+                only: %i(eid name)
+            },
+            guide: {
+                only: %i(slug)
+            },
+            student: {
+                only: %i(first_name last_name image_url uid)
+            }
+        }
+    )
+  end
+
+  private
+
+  def update_submissions!
+    update_attributes! submissions: submissions
+  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 empty_stats
+      {passed: 0, failed: 0, passed_with_warnings: 0}
+    end
+
+    def with_full_messages(query, user)
+      where(query)
+        .map { |assignment| assignment.with_full_messages(user) }
+    end
+
+    def items_to_review(query, exercises)
+      passed_exercises_ids = where(query)
+                               .map { |assignment| [assignment.exercise.eid, assignment.submissions.max_by(&:created_at)] }
+                               .map { |eid, submission| eid if solved?(submission.status) }
+      exercises.reject { |exercise| passed_exercises_ids.include? exercise[:id] }
+        .pluck(:tag_list, :language)
+        .flatten
+        .uniq
+    end
+
+    def solved?(status)
+      status.passed? || status.skipped?
+    end
+
+    def stats_by(query)
+      stats = where(query)
+                .map { |assignment| assignment.submissions.max_by(&:created_at) }
+                .group_by { |submission| submission.status }
+                .map { |status, submissions| [status.to_sym, submissions.size] }
+                .to_h.compact
+      stats = empty_stats.merge(stats)
+      stats[:failed] += stats.delete(:errored) || 0
+      stats.slice(*empty_stats.keys)
+    end
+  end
+
+end

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

@@ -0,0 +1,53 @@
+module CourseMember
+  extend ActiveSupport::Concern
+
+  included do
+    include Mongoid::Timestamps
+
+    field :uid, type: String
+    field :first_name, type: String
+    field :last_name, type: String
+    field :image_url, type: String
+    field :name, type: String
+    field :email, type: String
+    field :social_id, type: String
+    field :organization, type: String
+    field :course, type: Mumukit::Auth::Slug
+
+    create_index({organization: 1, course: 1, uid: 1}, {unique: true})
+  end
+
+  def as_user(verified: true)
+    member_json = as_json.merge_if(verified, validated_first_name: first_name, validated_last_name: last_name)
+    User.whitelist_attributes member_json
+  end
+
+  class_methods do
+    def ensure_not_exists!(query)
+      existing_members = where(query)
+      raise Mumuki::Classroom::CourseMemberExistsError, {existing_members: existing_members.map(&:uid)}.to_json if existing_members.exists?
+    end
+
+    def attributes_from_uid(uid)
+      whitelist_attributes User.locate!(uid).to_resource_h
+    end
+
+    def create_from_json!(member_json)
+      create! normalized_attributes_from_json(member_json)
+    end
+
+    def normalized_attributes_from_json(member_json)
+      whitelist_attributes as_normalized_json(member_json)
+    end
+
+    def as_normalized_json(member = {})
+      member.as_json.merge uid: (member[:uid] || member[:email])&.downcase,
+                           email: member[:email]&.downcase,
+                           last_name: member[:last_name]&.downcase&.titleize,
+                           first_name: member[:first_name]&.downcase&.titleize
+    end
+  end
+end
+
+class Mumuki::Classroom::CourseMemberExistsError < Exception
+end

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

@@ -0,0 +1,90 @@
+module Mongoid
+  module Document
+
+    def as_json(options = {})
+      super(options).as_json(except: ['_id', :_id]).deep_compact.with_indifferent_access
+    end
+
+    def upsert_attributes(attrs)
+      assign_attributes(attrs)
+      upsert
+    end
+
+    module ClassMethods
+      def create_index(*args)
+        index *args
+        Mumuki::Classroom.register_index! self
+      end
+
+      def drop_index(index_name)
+        collection.indexes.drop_one(index_name) if has_index_named?(index_name)
+      end
+
+      def has_index_named?(index_name)
+        collection.indexes.any? { |spec| spec['name'] == index_name }
+      end
+    end
+
+  end
+end
+
+
+class Hash
+  def deep_compact
+    compact
+    each_pair do |k, v|
+      if self[k].respond_to? :deep_compact
+        self[k].deep_compact
+      end
+      self.delete(k) if self[k].nil?
+    end
+  end
+
+  def merge_unless(criterion, hash)
+    return merge hash unless criterion
+    self
+  end
+
+  def merge_if(criterion, hash)
+    return merge hash if criterion
+    self
+  end
+end
+
+
+class Array
+  def deep_compact
+    compact
+    each do |e|
+      if e.respond_to? :deep_compact
+        e.deep_compact
+      end
+      self.delete(e) if e.nil?
+    end
+  end
+end
+
+
+class String
+  def boolean_value
+    downcase.strip == 'true'
+  end
+end
+
+class TrueClass
+  def boolean_value
+    self
+  end
+end
+
+class FalseClass
+  def boolean_value
+    self
+  end
+end
+
+class NilClass
+  def boolean_value
+    false
+  end
+end

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

@@ -0,0 +1,74 @@
+module WithFailedSubmissionReprocess
+
+  def reprocess!(uid, destination)
+    reprocess_from_organization uid, destination, destination
+  end
+
+  private
+
+  def reprocess_from_organization(uid, source, destination)
+    Mumuki::Classroom::FailedSubmission.for(source).find_by_uid(uid).each do |failed_submission|
+      delete_failed_submission failed_submission, source
+      try_reprocess failed_submission, source, destination
+    end
+  end
+
+  def try_reprocess(failed_submission, source, destination)
+    begin
+      reprocess_failed_submission destination, failed_submission
+    rescue => e
+      Mumukit::Nuntius::Logger.warn "Resubmission failed #{e}. it was: #{failed_submission.as_json}"
+      insert_failed_submission failed_submission, source
+    end
+  end
+
+  def insert_failed_submission(failed_submission, source)
+    Mumuki::Classroom::FailedSubmission.create! failed_submission.as_json.merge(organization: source)
+  end
+
+  def reprocess_failed_submission(destination, it)
+    json = it.as_json
+    json['organization'] = destination
+    Mumuki::Classroom::Submission.process! json
+  end
+
+  def delete_failed_submission(it, source)
+    Mumuki::Classroom::FailedSubmission.for(source).where(_id: it._id).destroy_all
+  end
+
+  def new_failed_submission(progress, submission)
+    submission.merge({
+                       exercise: exercise_from(progress[:exercise]),
+                       guide: guide_from(progress[:guide]),
+                       submitter: submitter_from(progress[:student])
+                     })
+  end
+
+  def submitter_from(student)
+    {
+      uid: student[:uid],
+      name: student[:name],
+      email: student[:email],
+      social_id: student[:social_id],
+      image_url: student[:image_url]
+    }.compact
+  end
+
+  def guide_from(guide)
+    {
+      name: guide[:name],
+      slug: guide[:slug],
+      parent: guide[:parent],
+      lesson: guide[:lesson],
+      language: guide[:language]
+    }.compact
+  end
+
+  def exercise_from(exercise)
+    {
+      eid: exercise[:eid],
+      name: exercise[:name],
+      number: exercise[:number]
+    }.compact
+  end
+end