mumuki-classroom 8.0.0

data/lib/mumuki/classroom/sinatra/messages.rb

@@ -0,0 +1,52 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  helpers do
+    def message
+      message = json_body[:message]
+      message[:sender] = current_user.uid
+      message
+    end
+
+    def render_threads(course)
+      authorize! :student
+      query = with_organization exercise_student_progress_query.merge(course: course, 'exercise.eid': exercise_id)
+      threads = Mumuki::Classroom::Assignment.find_by!(query).threads(params[:language])
+      erb :'threads.html', locals: {threads: threads, user: current_user}
+    end
+
+    def assignment_query
+      with_organization_and_course 'exercise.eid': json_body[:exercise_id], 'student.uid': json_body[:uid], 'guide.slug': json_body[:guide_slug]
+    end
+
+    def find_or_create_suggestion(assignment)
+      suggestion_id ? Mumuki::Classroom::Suggestion.find(suggestion_id) : Mumuki::Classroom::Suggestion.create_from(message, assignment)
+    end
+
+    def submission_id
+      json_body[:submission_id]
+    end
+
+    def suggestion_id
+      json_body[:suggestion_id]
+    end
+  end
+
+  Mumukit::Platform.map_organization_routes!(self) do
+    post '/courses/:course/messages' do
+      authorize! :teacher
+      assignment = Mumuki::Classroom::Assignment.find_by!(assignment_query)
+      submission = assignment.add_message_to_submission!(message, submission_id)
+      find_or_create_suggestion(assignment).add_submission!(submission)
+
+      {status: :created, message: Mumuki::Classroom::Message.new(message)}
+    end
+
+    get '/courses/:course/guides/:organization/:repository/:exercise_id/student/:uid/messages' do
+      render_threads(course_slug)
+    end
+
+    get '/api/guides/:organization/:repository/:exercise_id/student/:uid/messages' do
+      render_threads Mumuki::Classroom::Student.last_updated_student_by(with_organization uid: uid).course
+    end
+  end
+end
+

data/lib/mumuki/classroom/sinatra/notifications.rb

@@ -0,0 +1,29 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  Mumukit::Platform.map_organization_routes!(self) do
+    get '/notifications/unread' do
+      authorize! :teacher
+      { notifications: Mumuki::Classroom::Notification.unread(organization, current_user.permissions) }
+    end
+
+    get '/notifications' do
+      authorize! :teacher
+      page = params[:page].to_i
+      per_page = params[:per_page].to_i
+      {total: Mumuki::Classroom::Notification.count,
+       page: page,
+       notifications: Mumuki::Classroom::Notification.page(organization, current_user.permissions, page, per_page)}
+    end
+
+    put '/notifications/:notificationId/read' do
+      authorize! :teacher
+      Mumuki::Classroom::Notification.find(params[:notificationId]).read!
+      {status: :updated}
+    end
+
+    put '/notifications/:notificationId/unread' do
+      authorize! :teacher
+      Mumuki::Classroom::Notification.find(params[:notificationId]).unread!
+      {status: :updated}
+    end
+  end
+end

data/lib/mumuki/classroom/sinatra/organization.rb

@@ -0,0 +1,7 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  Mumukit::Platform.map_organization_routes!(self) do
+    get '/organization' do
+      organization_json
+    end
+  end
+end

data/lib/mumuki/classroom/sinatra/pagination.rb

@@ -0,0 +1,13 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  helpers do
+    def paginated_params
+      {
+        page: page,
+        sort_by: sort_by,
+        order_by: order_by,
+        per_page: per_page,
+        with_detached: with_detached
+      }
+    end
+  end
+end

data/lib/mumuki/classroom/sinatra/permissions.rb

@@ -0,0 +1,9 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  Mumukit::Platform.map_organization_routes!(self) do
+    get '/permissions' do
+      authorize! :teacher
+
+      {permissions: permissions}
+    end
+  end
+end

data/lib/mumuki/classroom/sinatra/ping.rb

@@ -0,0 +1,7 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  Mumukit::Platform.map_organization_routes!(self) do
+    get '/ping' do
+      {message: 'pong!', organization: tenant}
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  helpers do
+    def with_detached_and_search(params_hash, collection)
+      params_hash
+        .merge('detached': {'$exists': with_detached})
+        .merge_if(params[:students] == 'follow', followers_criteria(collection))
+        .merge_unless(query_params[:query_param].empty?, query_criteria_class_for(collection).query)
+    end
+
+    def query_criteria_class_for(collection)
+      Searching.filter_for(collection, query_params)
+    end
+
+    def query_params
+      {
+        query_param: query,
+        query_criteria: query_criteria,
+        query_operand: query_operand
+      }
+    end
+
+    def followers_criteria(collection)
+      uids = Mumuki::Classroom::Follower.find_by(with_organization_and_course email: current_user_uid)&.uids.to_a
+      {collection.uid_field.to_sym => {'$in': uids}}
+    end
+  end
+end

data/lib/mumuki/classroom/sinatra/students.rb

@@ -0,0 +1,111 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  helpers do
+    def normalize_student!
+      json_body[:email] = json_body[:email]&.downcase
+      json_body[:last_name] = json_body[:last_name]&.downcase&.titleize
+      json_body[:first_name] = json_body[:first_name]&.downcase&.titleize
+    end
+
+    def list_students(matcher)
+      authorize! :teacher
+      count, students = Sorting.aggregate(Mumuki::Classroom::Student, with_detached_and_search(matcher, Mumuki::Classroom::Student), paginated_params, query_params)
+      {page: page + 1, total: count, students: students}
+    end
+
+  end
+
+  Mumukit::Platform.map_organization_routes!(self) do
+
+    get '/courses/:course/students' do
+      list_students with_organization_and_course
+    end
+
+    get '/api/courses/:course/students' do
+      authorize! :teacher
+      query_params = params.slice('uid', 'personal_id')
+      {students: Mumuki::Classroom::Student.where(with_organization_and_course.merge query_params)}
+    end
+
+    get '/students' do
+      list_students with_organization
+    end
+
+    get '/students/report' do
+      authorize! :janitor
+      group_report with_organization, group_report_projection.merge(course: '$course')
+    end
+
+    # Retrieves the progress for a student in an specific course
+    get '/api/courses/:course/students/:uid' do
+      authorize! :teacher
+      {guide_students_progress: Mumuki::Classroom::GuideProgress.where(with_organization_and_course 'student.uid': uid).sort(created_at: :asc).as_json}
+    end
+
+    # Tries to resubmit all failed_submissions of a student to a specific tenant
+    post '/courses/:course/students/:uid' do
+      authorize! :janitor
+      Mumukit::Nuntius.notify! 'resubmissions', uid: uid, tenant: tenant
+      {status: :created}
+    end
+
+    # Detaches a student of a course
+    post '/courses/:course/students/:uid/detach' do
+      authorize! :janitor
+      Mumuki::Classroom::Student.find_by!(with_organization_and_course uid: uid).detach!
+      update_user_permissions!(uid, 'remove', course_slug)
+      {status: :updated}
+    end
+
+    # Attaches a student to a course
+    post '/courses/:course/students/:uid/attach' do
+      authorize! :janitor
+      Mumuki::Classroom::Student.find_by!(with_organization_and_course uid: uid).attach!
+      update_user_permissions!(uid, 'add', course_slug)
+      {status: :updated}
+    end
+
+    # Transfers a student to another course
+    post '/courses/:course/students/:uid/transfer' do
+      authorize! :admin
+
+      destination = Mumukit::Auth::Slug.join organization, json_body[:destination]
+
+      Mumuki::Classroom::Student.find_by!(with_organization_and_course uid: uid).transfer_to!  organization, destination.to_s
+
+      update_user_permissions!(uid, 'update', course_slug, destination.to_s)
+      {status: :updated}
+    end
+
+    # Retrieves info for a particular student
+    get '/courses/:course/student/:uid' do
+      authorize! :teacher
+
+      Mumuki::Classroom::Student.find_by!(with_organization_and_course uid: uid).as_json
+    end
+
+    # Creates student and tries to resubmit all failed submissions to that student
+    post '/courses/:course/students' do
+      authorize! :janitor
+      ensure_course_existence!
+
+      student_json = create_course_member! :student
+
+      Mumukit::Nuntius.notify! 'resubmissions', uid: student_json[:uid], tenant: tenant
+
+      {status: :created}
+    end
+
+    # Updates student information
+    put '/courses/:course/students/:uid' do
+      authorize! :janitor
+      ensure_course_existence!
+
+      student = Mumuki::Classroom::Student.find_by!(with_organization_and_course uid: uid)
+      student.update! Mumuki::Classroom::Student.normalized_attributes_from_json(json_body).except(:uid)
+
+      upsert_user! :student, student.as_user
+
+      {status: :updated}
+    end
+  end
+end

data/lib/mumuki/classroom/sinatra/suggestions.rb

@@ -0,0 +1,17 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  helpers do
+    def exercise_id
+      params[:exercise_id].to_i
+    end
+  end
+
+  Mumukit::Platform.map_organization_routes!(self) do
+    get '/suggestions/:organization/:repository/:exercise_id' do
+      authorize! :teacher
+      { suggestions: Mumuki::Classroom::Suggestion
+        .where(guide_slug: repo_slug, 'exercise.eid': exercise_id)
+        .sort(updated_at: :desc)
+        .map { |s| s.as_json(methods: :content_html).merge(id: s.id) } }
+    end
+  end
+end

data/lib/mumuki/classroom/sinatra/teachers.rb

@@ -0,0 +1,14 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  Mumukit::Platform.map_organization_routes!(self) do
+    get '/courses/:course/teachers' do
+      authorize! :headmaster
+      {teachers: Mumuki::Classroom::Teacher.where(with_organization_and_course).as_json}
+    end
+
+    post '/courses/:course/teachers' do
+      authorize! :headmaster
+
+      create_course_member! :teacher
+    end
+  end
+end

data/lib/mumuki/classroom/version.rb

@@ -0,0 +1,5 @@
+module Mumuki
+  module Classroom
+    VERSION = '8.0.0'
+  end
+end

data/lib/mumuki/profile.rb

@@ -0,0 +1,17 @@
+class Mumukit::Auth::Profile
+  attr_accessor :attributes
+
+  FIELDS = [:uid, :social_id, :email, :name, :first_name, :last_name, :image_url]
+
+  def initialize(attributes)
+    @attributes = attributes
+  end
+
+  def self.extract(profile_like)
+    new profile_like.as_json(only: FIELDS).with_indifferent_access
+  end
+
+  def ==(other)
+    other.class == self.class && other.attributes == self.attributes
+  end
+end

data/lib/mumuki/views/threads.html.erb

@@ -0,0 +1,43 @@
+<div class="mu-messages">
+  <ol class="mu-chat">
+    <% threads.each_with_index do |thread, index| %>
+        <div class="thread">
+          <li class="solution self">
+            <a onclick="toggleCollapse('toggle-<%= index %>')">
+              <i class="fa fa-<%= threads.last == thread ? 'minus' : 'plus' %>-square-o toggle-<%= index %>"></i>
+              <span>&nbsp;</span>
+              <span> <%= I18n.t(:view_solution) %> </span>
+            </a>
+            <div id="toggle-<%= index %>" class="<%= thread[:status] %> message visible">
+              <%= thread[:content] %>
+              <time style="font-weight: bold;"><%= thread[:created_at] %></time>
+            </div>
+          </li>
+          <% thread[:messages].each do |message| %>
+              <li class="<%= message.sent_by?(user) ? 'self' : 'other' %>">
+                <div class="message">
+                  <p> <%= message.content %></p>
+                  <div class="sender"><%= message.sender %></div>
+                  <time><%= message.created_at %></time>
+                </div>
+              </li>
+          <% end %>
+        </div>
+    <% end %>
+  </ol>
+</div>
+
+
+<script>
+  function toggleCollapse(target) {
+    var $target = $('#' + target);
+    var $icon = $('i.' + target);
+    $icon.toggleClass('fa-minus-square-o');
+    $icon.toggleClass('fa-plus-square-o');
+    $target.toggleClass('hidden');
+  }
+
+  $('.mu-view-messages time').each(function (i, e) {
+    return e.innerText = moment(e.innerText).fromNow();
+  });
+</script>

data/lib/tasks/mumuki/messages.rake

@@ -0,0 +1,20 @@
+namespace :classroom do
+  namespace :messages do
+    task listen: :environment do
+      Mumukit::Nuntius::Logger.info 'Listening to student messages'
+
+      Mumukit::Nuntius::Consumer.negligent_start! 'student-messages' do |body|
+        begin
+          Mumukit::Nuntius::Logger.info "Processing message #{body}"
+
+          Mumuki::Classroom::Message.import_from_json!(body).try do |assignment|
+            Mumuki::Classroom::Notification.import_from_json! 'Mumuki::Classroom::Message', assignment
+          end
+
+        rescue => e
+          Mumukit::Nuntius::Logger.warn "Mumuki::Classroom::Message failed #{e}. body was: #{body}"
+        end
+      end
+    end
+  end
+end

data/lib/tasks/mumuki/resubmissions.rake

@@ -0,0 +1,15 @@
+namespace :classroom do
+  namespace :resubmissions do
+    task listen: :environment do
+      Mumukit::Nuntius::Logger.info 'Listening to resubmissions'
+
+      Mumukit::Nuntius::Consumer.negligent_start! 'resubmissions' do |body|
+        destination = body['tenant']
+        uid = body['uid']
+
+        Mumukit::Nuntius::Logger.info "Processing resubmission #{uid}"
+        Mumuki::Classroom::FailedSubmission.reprocess! uid, destination
+      end
+    end
+  end
+end

data/lib/tasks/mumuki/students.rake

@@ -0,0 +1,31 @@
+namespace :classroom do
+  namespace :students do
+    namespace :reports do
+      task :registered, [:organization, :course, :from, :to, :format] => [:environment] do |_t, args|
+        args.with_defaults(format: 'table')
+
+        from = Date.parse(args[:from])
+        to = args[:to].try { |it| Date.parse(it) } || 1.day.since
+        format = args[:format]
+
+        stats = Mumuki::Classroom::Student.report(organzation: args[:organization], course: args[:course]).select do |user|
+          Date.parse(user[:created_at]) >= from && Date.parse(user[:created_at]) < to
+        end
+        puts Mumuki::Classroom::Reports::Formats.format_report(format, stats)
+      end
+
+      task :active, [:organization, :course, :from, :to, :format] => [:environment] do |_t, args|
+        args.with_defaults(format: 'table')
+
+        from = Date.parse(args[:from])
+        to = args[:to].try { |it| Date.parse(it) } || 1.day.since
+        format = args[:format]
+
+        stats = Mumuki::Classroom::Student.report(organization: args[:organization], course: args[:course]).select do |user|
+          (user[:detached_at].blank? || Date.parse(user[:detached_at]) >= from) && Date.parse(user[:created_at]) < to
+        end
+        puts Mumuki::Classroom::Reports::Formats.format_report(format, stats)
+      end
+    end
+  end
+end

data/lib/tasks/mumuki/submissions.rake

@@ -0,0 +1,17 @@
+namespace :classroom do
+  namespace :submissions do
+    task listen: :environment do
+      Mumukit::Nuntius::Logger.info 'Listening to submissions'
+
+      Mumukit::Nuntius::Consumer.negligent_start! 'submissions' do |body|
+        begin
+          Mumukit::Nuntius::Logger.info "Processing submission #{body['uid']}"
+          Mumuki::Classroom::Submission.process! body
+        rescue => e
+          Mumukit::Nuntius::Logger.warn "Mumuki::Classroom::Submission failed #{e}. body was: #{body.except('test_results')}"
+          Mumuki::Classroom::FailedSubmission.create! body
+        end
+      end
+    end
+  end
+end