mumuki-classroom 8.0.0

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

@@ -0,0 +1,90 @@
+module Searching
+  module GuideProgress
+    module QueryOperands
+      include Searching::QueryOperands
+
+      def more_than(value)
+        {'$gte': value}
+      end
+
+      def less_than(value)
+        {'$lte': value}
+      end
+
+      def close_to(value)
+        more_than(value - 1).merge(less_than value + 1)
+      end
+
+      def default_query_operand
+        :more_than
+      end
+    end
+
+    class NotFailedAssignments < NumericFilter
+      include Searching::GuideProgress::QueryOperands
+
+      def pipeline
+        [
+          {
+            '$addFields':
+              {'stats.not_failed': {'$sum': %w($stats.passed $stats.passed_with_warnings)}}
+          },
+          {
+            '$match':
+              {'stats.not_failed': current_query_operand }
+          }
+        ]
+      end
+    end
+
+    class PassedAssignments < NumericFilter
+      include Searching::GuideProgress::QueryOperands
+
+      def query
+        {'stats.passed': current_query_operand}
+      end
+    end
+
+    class TotalAssignments < NumericFilter
+      include Searching::GuideProgress::QueryOperands
+
+      def pipeline
+        [
+          {
+            '$addFields': {'stats.total': {'$sum': %w($stats.passed $stats.passed_with_warnings $stats.failed)}}
+          },
+          {
+            '$match': {'stats.total': current_query_operand }
+          }
+        ]
+      end
+    end
+
+    class SolvedAssignmentsPercentage < NumericFilter
+      include Searching::GuideProgress::QueryOperands
+
+      def pipeline
+        [
+          {
+            '$addFields': {
+              'stats.solved_percentage': {
+                '$multiply': [
+                  {
+                    '$divide': [
+                      {'$sum': %w($stats.passed $stats.passed_with_warnings)},
+                      {'$sum': %w($stats.passed $stats.passed_with_warnings $stats.failed)}
+                    ]
+                  },
+                  100
+                ]
+              }
+            }
+          },
+          {
+            '$match': {'stats.solved_percentage': current_query_operand }
+          }
+        ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Sorting
+
+  def self.aggregate(collection, query, paginated_params, query_params)
+    reporting_pipeline = Reporting.build_pipeline(collection, query, paginated_params, query_params, projection)
+    query = collection.collection.aggregate(pipeline paginated_params, reporting_pipeline).first
+    query_results(query)
+  end
+
+  def self.query_results(query)
+    total = query[:total].first
+    [total.blank? ? 0 : total[:count], query[:results]]
+  end
+
+  def self.pipeline(params, pipeline)
+    paging_pipeline = []
+    paging_pipeline << {'$skip': params[:page] * params[:per_page]}
+    paging_pipeline << {'$limit': params[:per_page]}
+    pipeline << {'$facet': {
+      results: paging_pipeline,
+      total: [
+        {
+          '$count': 'count'
+        }
+      ]
+    }}
+  end
+
+  def self.projection
+    {
+      '_id': 0,
+      'assignments': 0,
+      'notifications': 0,
+      'guide._id': 0,
+      'student._id': 0,
+      'last_assignment._id': 0,
+      'last_assignment.guide._id': 0,
+      'last_assignment.exercise._id': 0,
+      'last_assignment.submission._id': 0,
+    }
+  end
+
+  class SortBy
+    def self.pipeline
+      []
+    end
+  end
+
+end
+
+module Criteria
+  module Base
+    def bson_type
+      value.bson_type
+    end
+
+    def to_bson(*args)
+      value.to_bson(*args)
+    end
+
+    def !
+      negated
+    end
+  end
+
+  module Asc
+    extend Criteria::Base
+
+    def self.value
+      1
+    end
+
+    def self.negated
+      Desc
+    end
+  end
+
+  module Desc
+    extend Criteria::Base
+
+    def self.value
+      -1
+    end
+
+    def self.negated
+      Asc
+    end
+  end
+end
+
+require_relative './sorting/total_stats_sort_by'
+require_relative './sorting/student'
+require_relative './sorting/guide_progress'

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

@@ -0,0 +1,147 @@
+module Sorting
+  module GuideProgress
+    class ByMessages < SortBy
+      def self.pipeline
+        [
+          {'$lookup': lookup_notifications},
+          {'$addFields': filter_unread_notifications},
+          {'$unwind': unwind_notifications},
+          {'$lookup': lookup_assignments},
+          {'$addFields': filter_guide_assignments},
+          {'$group': group_by_students_uid},
+          {'$addFields': generate_guide_progress},
+          {'$addFields': add_progress_count},
+          {'$replaceRoot': progress_to_document_root},
+        ]
+      end
+
+      def self.progress_to_document_root
+        {'newRoot': '$progresses'}
+      end
+
+      def self.add_progress_count
+        {
+          'progresses.unread': '$count'
+        }
+      end
+
+      def self.generate_guide_progress
+        {
+          'progresses': {'$arrayElemAt': ['$progresses', 0]},
+        }
+      end
+
+      def self.group_by_students_uid
+        {
+          '_id': '$student.uid',
+          'progresses': {'$push': '$$ROOT'},
+          'count': {
+            '$sum': {
+              '$cond': {
+                'if': {'$anyElementTrue': ['$assignments']},
+                'then': 1,
+                'else': 0
+              }
+            }
+          }
+        }
+      end
+
+      def self.filter_guide_assignments
+        {
+          'assignments': {
+            '$filter': {
+              'as': 'assignment',
+              'input': '$assignments',
+              'cond': {
+                '$eq': %w($$assignment.guide.slug $guide.slug),
+              }
+            }
+          }
+        }
+      end
+
+      def self.lookup_assignments
+        {
+          'from': 'assignments',
+          'localField': 'notifications.assignment_id',
+          'foreignField': '_id',
+          'as': 'assignments'
+        }
+      end
+
+      def self.unwind_notifications
+        {
+          'path': '$notifications',
+          'preserveNullAndEmptyArrays': true
+        }
+      end
+
+      def self.filter_unread_notifications
+        {
+          'notifications': {
+            '$filter': {
+              'as': 'notification',
+              'input': '$notifications',
+              'cond': {
+                '$and': [
+                  {'$eq': %w($$notification.organization $organization)},
+                  {'$eq': %w($$notification.sender $student.uid)},
+                  {'$eq': %w($$notification.course $course)},
+                  {'$eq': ['$$notification.read', false]}
+                ]
+              }
+            }
+          }
+        }
+      end
+
+      def self.lookup_notifications
+        {
+          'from': 'notifications',
+          'localField': 'organization',
+          'foreignField': 'organization',
+          'as': 'notifications'
+        }
+      end
+
+      def self.order_by(ordering)
+        {'unread': ordering,
+         'student.last_name': ordering,
+         'student.first_name': ordering}
+      end
+    end
+
+    class ByName < SortBy
+      def self.pipeline
+        [{'$addFields': {
+          'student.last_name': {'$toLower': '$student.last_name'},
+          'student.first_name': {'$toLower': '$student.first_name'}
+        }}]
+      end
+
+      def self.order_by(ordering)
+        {'student.last_name': ordering,
+         'student.first_name': ordering}
+      end
+    end
+
+    class ByProgress < SortBy
+      def self.order_by(ordering)
+        {'stats.passed': ordering,
+         'stats.passed_with_warnings': ordering,
+         'stats.failed': ordering,
+         'student.last_name': ordering,
+         'student.first_name': ordering}
+      end
+    end
+
+    class ByLastSubmissionDate < SortBy
+      def self.order_by(ordering)
+        {'last_assignment.submission.created_at': !ordering,
+         'last_name': ordering,
+         'first_name': ordering}
+      end
+    end
+  end
+end

data/lib/mumuki/classroom/models/sorting/student.rb

@@ -0,0 +1,45 @@
+module Sorting
+  module Student
+    class ByName < SortBy
+      def self.pipeline
+        [{'$addFields': {
+          'last_name': {'$toLower': '$last_name'},
+          'first_name': {'$toLower': '$first_name'}
+        }}]
+      end
+
+      def self.order_by(ordering)
+        {'last_name': ordering,
+         'first_name': ordering}
+      end
+    end
+
+    class ByProgress < TotalStatsSortBy
+
+      def self.order_by(ordering)
+        {'stats.total': ordering,
+         'stats.failed': !ordering,
+         'stats.passed_with_warnings': !ordering,
+         'stats.passed': !ordering,
+         'last_name': ordering,
+         'first_name': ordering}
+      end
+    end
+
+    class BySignupDate < SortBy
+      def self.order_by(ordering)
+        {'created_at': !ordering,
+         'last_name': ordering,
+         'first_name': ordering}
+      end
+    end
+
+    class ByLastSubmissionDate < SortBy
+      def self.order_by(ordering)
+        {'last_assignment.submission.created_at': !ordering,
+         'last_name': ordering,
+         'first_name': ordering}
+      end
+    end
+  end
+end

data/lib/mumuki/classroom/models/sorting/total_stats_sort_by.rb

@@ -0,0 +1,5 @@
+class TotalStatsSortBy
+  def self.pipeline
+    [{'$addFields': {'stats.total': {'$sum': %w($stats.passed $stats.passed_with_warnings $stats.failed)}}}]
+  end
+end

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

@@ -0,0 +1,88 @@
+class Mumuki::Classroom::Student < Mumuki::Classroom::Document
+  include CourseMember
+
+  field :personal_id, type: String
+  field :stats, type: Hash
+  field :detached, type: Mongoid::Boolean
+  field :detached_at, type: Time
+  embeds_one :last_assignment, class_name: 'Mumuki::Classroom::LastAssignment'
+
+  create_index({organization: 1, uid: 1})
+  create_index({'last_assignment.guide.slug': 1, 'last_assignment.exercise.eid': 1}, {name: 'ExBibIdIndex'})
+  create_index({first_name: 'text', last_name: 'text', email: 'text', personal_id: 'text'})
+
+  def course_name
+    course.to_mumukit_slug.course
+  end
+
+  def destroy_cascade!
+    Mumuki::Classroom::GuideProgress.destroy_all_by!(sub_student_query uid)
+    Mumuki::Classroom::Assignment.destroy_all_by!(sub_student_query uid)
+    destroy!
+  end
+
+  def update_all_stats
+    all_stats = Mumuki::Classroom::Assignment.stats_by(sub_student_query uid)
+    update_attributes!(stats: all_stats)
+  end
+
+  def sub_student_query(uid)
+    {'organization': organization, 'course': course, 'student.uid': uid}
+  end
+
+  def detach!
+    update_attributes! detached: true, detached_at: Time.now
+    Mumuki::Classroom::Assignment.detach_all_by! sub_student_query(uid)
+    Mumuki::Classroom::GuideProgress.detach_all_by! sub_student_query(uid)
+  end
+
+  def attach!
+    unset :detached, :detached_at
+    Mumuki::Classroom::Assignment.attach_all_by! sub_student_query(uid)
+    Mumuki::Classroom::GuideProgress.attach_all_by! sub_student_query(uid)
+  end
+
+  def transfer_to!(organization, course)
+    Mumuki::Classroom::Assignment.transfer_all_by! sub_student_query(uid), organization, course
+    Mumuki::Classroom::GuideProgress.transfer_all_by! sub_student_query(uid), organization, course
+    update_attributes! organization: organization, course: course
+  end
+
+  def update_last_assignment_for
+    update_attributes!(last_assignment: Mumuki::Classroom::GuideProgress.last_assignment_by(sub_student_query uid))
+  end
+
+  class << self
+    def report(criteria, &block)
+      where(criteria).select(&block).as_json(only: [:first_name, :last_name, :email, :created_at, :detached_at])
+    end
+
+    def update_all_stats(options)
+      where(options).each(&:update_all_stats)
+    end
+
+    def last_updated_student_by(query)
+      where(query).ne(detached: true).order_by(updated_at: :desc).first
+    end
+
+    def detach_all_by!(uids, query)
+      where(query).in(uid: uids).update_all(detached: true, detached_at: Time.now)
+      criteria = query.merge('student.uid': {'$in': uids})
+      Mumuki::Classroom::Assignment.detach_all_by! criteria
+      Mumuki::Classroom::GuideProgress.detach_all_by! criteria
+    end
+
+    def attach_all_by!(uids, query)
+      where(query).in(uid: uids).unset(:detached, :detached_at)
+      criteria = query.merge('student.uid': {'$in': uids})
+      Mumuki::Classroom::Assignment.attach_all_by! criteria
+      Mumuki::Classroom::GuideProgress.attach_all_by! criteria
+    end
+
+    def uid_field
+      :uid
+    end
+  end
+
+end
+