mumuki-classroom 8.0.0

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

@@ -0,0 +1,157 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  helpers do
+    def allowed_courses
+      {courses: Course.allowed_for(current_user).as_json}
+    end
+
+    def guide_progress_query
+      with_detached_and_search with_organization_and_course('guide.slug': repo_slug), Mumuki::Classroom::GuideProgress
+    end
+
+    def student_query
+      with_organization_and_course('guide.slug': repo_slug)
+    end
+
+    def student_assignment_query(student)
+      student_info = student.slice('first_name', 'last_name', 'email').transform_keys { |it| "student.#{it}" }
+      student_query.merge(student_info)
+    end
+
+    def guide_report_projection
+      {
+        '_id': 0,
+        'last_name': '$student.last_name',
+        'first_name': '$student.first_name',
+        'email': '$student.email',
+        'passed_count': '$stats.passed',
+        'passed_with_warnings_count': '$stats.passed_with_warnings',
+        'failed_count': '$stats.failed',
+        'items_to_review': ''
+      }
+    end
+
+    def csv_with_headers(csv, projection)
+      headers = projection.symbolize_keys.except(:_id).keys.join(',')
+      "#{headers}\n#{csv}"
+    end
+
+    def add_failed_tags(report_json, exercises)
+      report_json.each do |student|
+        items_to_review = Mumuki::Classroom::Assignment.items_to_review(student_assignment_query(student), exercises)
+        student['items_to_review'] = items_to_review.join ', '
+      end
+    end
+
+    def normalized_exercises
+      json_body[:exercises].map do |it|
+        {language: json_body[:language]}.merge(it.symbolize_keys)
+      end
+    end
+
+    def ensure_organization_existence!
+      Organization.locate! organization
+    end
+
+    # TODO: Use JSON Builder
+    def with_last_invitation(course)
+      course.as_json(except: [:created_at, :updated_at, :id], methods: [:current_invitation]).tap do |it|
+        it['invitation'] = it['current_invitation']
+        it.except! 'current_invitation'
+      end
+    end
+
+    def guide_progress_report(matcher, projection)
+      projection = csv_projection_for projection
+      aggregation = Mumuki::Classroom::GuideProgress.where(matcher).project(projection)
+      pipeline_with_sort_criterion = aggregation.pipeline << {'$sort': {email: 1, passed_count: -1, passed_with_warnings_count: -1, failed_count: -1, last_name: 1, first_name: 1}}
+      json = Mumuki::Classroom::GuideProgress.collection.aggregate(pipeline_with_sort_criterion).as_json
+      content_type 'application/csv'
+      csv_with_headers(Mumuki::Classroom::Reports::Formats.format_report('csv', json), projection)
+    end
+
+    def guide_progress_report_projection
+      {
+          '_id': 0,
+          'last_name': '$student.last_name',
+          'first_name': '$student.first_name',
+          'email': '$student.email',
+          'last_submission': '$last_assignment.submission.created_at',
+          'detached': {'$eq': ['$detached', true]},
+          'guide_slug': '$guide.slug',
+          'passed_count': '$stats.passed',
+          'passed_with_warnings_count': '$stats.passed_with_warnings',
+          'failed_count': '$stats.failed'
+      }
+    end
+  end
+
+  Mumukit::Platform.map_organization_routes!(self) do
+    get '/courses' do
+      allowed_courses
+    end
+
+    get '/api/courses' do
+      allowed_courses
+    end
+
+    post '/courses' do
+      current_user.protect! :janitor, json_body[:slug]
+      ensure_organization_existence!
+      Course.create! with_current_organization(json_body)
+      {status: :created}
+    end
+
+    get '/courses/:course' do
+      authorize! :teacher
+      {course: with_last_invitation(Course.locate!(course_slug))}
+    end
+
+    post '/courses/:course/invitation' do
+      authorize! :janitor
+      course = Course.locate! course_slug
+      {invitation: course.invite!(json_body[:expiration_date])}
+    end
+
+    get '/courses/:course/guides/:organization/:repository' do
+      authorize! :teacher
+      count, guide_progress = Sorting.aggregate(Mumuki::Classroom::GuideProgress, guide_progress_query, paginated_params, query_params)
+      {
+        total: count,
+        page: page + 1,
+        guide_students_progress: guide_progress
+      }
+    end
+
+    post '/courses/:course/guides/:organization/:repository/report' do
+      authorize! :teacher
+      json = Reporting.aggregate(Mumuki::Classroom::GuideProgress, guide_progress_query, paginated_params, query_params, guide_report_projection).as_json
+      add_failed_tags json, normalized_exercises
+      content_type 'application/csv'
+      csv_with_headers(Mumuki::Classroom::Reports::Formats.format_report('csv', json), guide_report_projection)
+    end
+
+    get '/courses/:course/guides/:organization/:repository/:uid' do
+      authorize! :teacher
+      {exercise_student_progress: Mumuki::Classroom::Assignment.with_full_messages(with_organization_and_course(exercise_student_progress_query), current_user)}
+    end
+
+    get '/courses/:course/progress' do
+      authorize! :admin
+      {exercise_student_progress: Mumuki::Classroom::Assignment.where(with_organization_and_course).as_json}
+    end
+
+    get '/courses/:course/report' do
+      authorize! :teacher
+      group_report with_organization_and_course, group_report_projection
+    end
+
+    get '/courses/:course/guide_progress_report' do
+      authorize! :janitor
+      guide_progress_report with_organization_and_course, guide_progress_report_projection
+    end
+
+    get '/courses/:course/guides/:organization/:repository/:uid/:exercise_id' do
+      Mumuki::Classroom::Assignment.find_by!(with_organization_and_course exercise_student_progress_query.merge('exercise.eid': exercise_id)).as_json
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  error Mumuki::Classroom::CourseMemberExistsError do
+    halt 400
+  end
+
+  error Mongoid::Errors::DocumentNotFound do
+    halt 404
+  end
+
+  error Mongo::Error::OperationFailure do |e|
+    halt 422 if e.message =~ /^E11000/
+  end
+end

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

@@ -0,0 +1,71 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  helpers do
+    def exam_id
+      params[:exam_id]
+    end
+
+    def exam_query
+      {classroom_id: exam_id}
+    end
+
+    def exam_from_classroom_json(json)
+      exam = json.with_indifferent_access
+      Exam.adapt_json_values exam
+      Exam.whitelist_attributes exam
+    end
+
+    def exam_body
+      exam_from_classroom_json with_current_organization_and_course(json_body)
+    end
+
+    def exam_as_json_response(exam)
+      exam.as_json
+          .merge(eid: exam.classroom_id, name: exam.guide.name, language: exam.guide.language.name,
+                 slug: exam.guide.slug, uids: exam.users.map(&:uid), course: exam.course.slug,
+                 organization: exam.organization.name, passing_criterion: exam.passing_criterion.as_json)
+          .except(:classroom_id, :guide_id, :course_id, :organization_id,
+                  :passing_criterion_type, :passing_criterion_value)
+    end
+  end
+
+  Mumukit::Platform.map_organization_routes!(self) do
+    get '/courses/:course/exams/:exam_id' do
+      authorize! :teacher
+      exam = Exam.find_by!(exam_query)
+      exam_as_json_response exam
+    end
+
+    put '/courses/:course/exams/:exam_id' do
+      authorize! :teacher
+      exam = Exam.find_by!(exam_query)
+      exam.update_attributes! exam_body
+      {status: :updated}.merge(eid: exam_id)
+    end
+
+    ['/api', ''].each do |route_prefix|
+      get "#{route_prefix}/courses/:course/exams" do
+        authorize! :teacher
+        {exams: Exam.where(with_current_organization_and_course).map { |it| exam_as_json_response(it) }}
+      end
+
+      post "#{route_prefix}/courses/:course/exams" do
+        authorize! :teacher
+        exam = Exam.create! exam_body
+        {status: :created}.merge(eid: exam.classroom_id)
+      end
+
+      post "#{route_prefix}/courses/:course/exams/:exam_id/students/:uid" do
+        authorize! :teacher
+        Exam.upsert_students!(eid: exam_id, added: [uid])
+        {status: :updated}.merge(eid: exam_id)
+      end
+
+      delete "#{route_prefix}/courses/:course/exams/:exam_id/students/:uid" do
+        authorize! :teacher
+        Exam.upsert_students!(eid: exam_id, deleted: [uid])
+        {status: :updated}.merge(eid: exam_id)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,29 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  helpers do
+    def follower_query
+      with_organization_and_course email: current_user.uid
+    end
+  end
+
+  Mumukit::Platform.map_organization_routes!(self) do
+    post '/courses/:course/followers' do
+      authorize! :teacher
+      Mumuki::Classroom::Follower.find_or_create_by!(follower_query).add!(json_body[:uid])
+      {status: :created}
+    end
+
+    get '/courses/:course/followers' do
+      {followers: Mumuki::Classroom::Follower
+                    .where(follower_query)
+                    .select { |it| permissions.has_permission? :teacher, it.course }
+                    .as_json
+      }
+    end
+
+    delete '/courses/:course/followers/:uid' do
+      authorize! :teacher
+      Mumuki::Classroom::Follower.find_by!(follower_query).remove!(params[:uid])
+      {status: :created}
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  Mumukit::Platform.map_organization_routes!(self) do
+    get '/guides/:organization/:repository' do
+      authorize! :teacher
+      guide = Guide.locate!(repo_slug)
+      validate_usage! guide
+      {guide: guide_needed_fields(guide)}
+    end
+
+    get '/courses/:course/guides' do
+      get_current_guides
+    end
+
+    get '/api/courses/:course/guides' do
+      get_current_guides
+    end
+  end
+
+  helpers do
+    # TODO: Use JSON Builder
+    def get_current_guides
+      authorize! :teacher
+      ensure_organization_exists!
+      ensure_course_exists!
+      {
+        chapters: chapter_needed_fields(current_organization.book.chapters.includes(topic: {lessons: {guide: :language}})),
+        complements: guide_container_needed_fields(current_organization.book.complements.includes(guide: :language)),
+        exams: guide_container_needed_fields(current_organization.exams.where(course: current_course).includes(guide: :language))
+      }
+    end
+
+    def except_fields
+      [:id, :created_at, :updated_at, :language_id, :guide_id, :topic_id, :book_id]
+    end
+
+    def guide_as_json_opts
+      {except: except_fields, include: {language: {only: [:name, :devicon]}}}
+    end
+
+    def guide_container_as_json_opts
+      {except: except_fields, include: {guide: guide_as_json_opts}}
+    end
+
+    def chapter_as_json_opts
+      {except: except_fields, include: {lessons: guide_container_as_json_opts}, methods: :name}
+    end
+
+    def guide_needed_fields(guide)
+      guide.as_json guide_as_json_opts
+    end
+
+    def with_guide_progress_count(containers)
+      containers.each do |container|
+        container.tap do |it|
+          it['guide']['students_count'] = Mumuki::Classroom::GuideProgress
+                                            .where(with_organization_and_course 'guide.slug': it['guide']['slug'])
+                                            .count
+        end
+      end
+    end
+
+    def guide_container_needed_fields(containers)
+      with_guide_progress_count containers.as_json(guide_container_as_json_opts)
+    end
+
+    def chapter_needed_fields(chapters)
+      chapters.as_json(chapter_as_json_opts).tap do |chs|
+        chs.each do |chapter|
+          with_guide_progress_count(chapter['lessons'])
+        end
+      end
+    end
+
+    # TODO: Extract to domain
+    def validate_usage!(guide)
+      raise ActiveRecord::RecordNotFound, "Couldn't find #{Guide.name} with #{Guide.sync_key_id_field}: #{guide.slug}" unless guide.usage_in_organization
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+class Mumuki::Classroom::App < Sinatra::Application
+  helpers do
+    def manual_evaluation_assignment_query
+      with_organization_and_course 'exercise.eid': params[:exercise_id].to_i, 'student.uid': params[:uid], 'guide.slug': repo_slug
+    end
+  end
+
+  Mumukit::Platform.map_organization_routes!(self) do
+    post '/courses/:course/guides/:organization/:repository/:exercise_id/student/:uid/manual_evaluation' do
+      assignment = Mumuki::Classroom::Assignment.find_by!(manual_evaluation_assignment_query)
+      assignment.evaluate_manually!(json_body[:sid], json_body[:comment], json_body[:status])
+      assignment.notify_manual_evaluation!(json_body[:sid])
+    end
+  end
+end
+

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

@@ -0,0 +1,206 @@
+class Mumuki::Classroom::App < Sinatra::Application
+
+  Mumukit::Platform.map_organization_routes!(self) do
+
+    namespace '/api/courses/:course/massive' do
+
+      before do
+        next if request.options?
+        authorize! :janitor
+        ensure_organization_exists!
+        ensure_course_exists!
+      end
+
+      get '/students' do
+        per_page = MASSIVE_BATCH_LIMIT
+        progress = guide_progress_at_page per_page
+        count = progress.count
+        guide_progress = progress.select(&:student).map { |it| as_guide_progress_response it }
+        {
+          page: page + 1,
+          total_pages: (count / per_page.to_f).ceil,
+          total_results: count,
+          total_page_results: [per_page, guide_progress.size].min,
+          guide_students_progress: guide_progress
+        }
+      end
+
+      post '/students' do
+        create_members! :student do |user|
+          Mumukit::Nuntius.notify! 'resubmissions', uid: user.uid, tenant: tenant
+        end
+      end
+
+      post '/teachers' do
+        create_members! :teacher
+      end
+
+      post '/students/detach' do
+        update_students! do |processed|
+          update_students_at_course! :detach, :remove, processed
+        end
+      end
+
+      post '/students/attach' do
+        update_students! do |processed|
+          update_students_at_course! :attach, :add, processed
+        end
+      end
+
+      post '/exams/:exam_id/students' do
+        update_students! do |processed|
+          Exam.upsert_students! eid: exam_id, added: processed
+        end
+      end
+    end
+  end
+
+  MASSIVE_BATCH_LIMIT = 100
+
+  helpers do
+    def with_massive_batch_limit(elements)
+      elements.to_a.take MASSIVE_BATCH_LIMIT
+    end
+
+    def uids
+      json_body[:uids]
+    end
+
+    def massive_uids
+      with_massive_batch_limit uids
+    end
+
+    def students
+      @students ||= json_body[:students].map do |it|
+        Mumuki::Classroom::Student.normalized_attributes_from_json it
+      end
+    end
+
+    def teachers
+      @teachers ||= json_body[:teachers].map do |it|
+        Mumuki::Classroom::Teacher.normalized_attributes_from_json it
+      end
+    end
+
+    def massive_students
+      @massive_students ||= with_massive_batch_limit students
+    end
+
+    def massive_teachers
+      @massive_teachers ||= with_massive_batch_limit teachers
+    end
+
+    def user_from_member_json(member_json)
+      User.whitelist_attributes member_json
+    end
+
+    def upsert_user!(role, member)
+      user = User.find_or_initialize_by(uid: member[:uid])
+      user.assign_attributes user_from_member_json(member)
+      user.add_permission! role, course_slug
+      user.verify_name!
+      yield user if block_given?
+    end
+
+    #FIXME: This method now doesn't perform a bulk update as PG doesn't support it
+    def upsert_users!(role, members, &block)
+      members.each { |it| upsert_user! role, it, &block }
+    end
+
+    def massive_response(processed, unprocessed, errored, errored_msg, hash = {})
+      add_massive_response_field(:errored_members, errored, errored_msg, hash)
+      add_massive_response_field(:unprocessed, unprocessed, unprocessed_msg, hash)
+      hash.merge(processed_count: processed.size, processed: processed)
+    end
+
+    def unprocessed_msg
+      "This endpoint process only first #{MASSIVE_BATCH_LIMIT} elements"
+    end
+
+    def students_does_not_belong_msg
+      'Students does not belong to current course'
+    end
+
+    def add_massive_response_field(field, list, message, hash)
+      unless list.empty?
+        hash["#{field}_reason".to_sym] = message
+        hash["#{field}_count".to_sym] = list.size
+        hash[field.to_sym] = list
+      end
+    end
+
+    def members_for(role)
+      send role.to_s.pluralize
+    end
+
+    def massive_members_for(role)
+      send "massive_#{role.to_s.pluralize}"
+    end
+
+    def unprocessed_members_for(role)
+      members_for(role) - massive_members_for(role)
+    end
+
+    def create_members!(role, &block)
+      members_collection = collection_for role
+      massive_members = massive_members_for role
+      existing_members = existing_members_in_course(members_collection, massive_members)
+      existing_members_uids = existing_members.map { |it| it[:uid] }
+      processed_members = massive_members.reject { |it| existing_members_uids.include? it[:uid] }.uniq { |it| it[:uid]}
+      members_collection.collection.insert_many(processed_members.map { |member| with_organization_and_course member })
+      upsert_users! role, processed_members, &block
+      massive_response(processed_members, unprocessed_members_for(role), existing_members,
+                       "#{role.to_s.pluralize.titleize} already belong to current course", status: :created)
+    end
+
+    def existing_members_in_course(col, massive_members)
+      col.where(with_organization_and_course)
+        .in(uid: massive_members.map { |it| it[:uid] })
+        .map { |it| col.normalized_attributes_from_json(it) }
+    end
+
+    def update_students!
+      processed = students_from(massive_uids).map(&:uid)
+      yield processed if block_given?
+      massive_response processed, (uids - massive_uids), (massive_uids - processed),
+                       students_does_not_belong_msg, status: :updated
+    end
+
+    def update_students_at_course!(method, action, students_uids)
+      Mumuki::Classroom::Student.send "#{method}_all_by!", students_uids, with_organization_and_course
+      User.where(uid: students_uids).each do |user|
+        user.send "#{action}_permission!", :student, course_slug
+        user.save!
+      end
+    end
+
+    def students_from(uids)
+      Mumuki::Classroom::Student.where(with_organization_and_course).in(uid: uids)
+    end
+
+    def ensure_course_exists!
+      Course.locate!(course_slug)
+    end
+
+    def ensure_organization_exists!
+      Organization.locate!(organization).tap &:switch!
+    end
+
+    def guide_progress_at_page(per_page)
+      Mumuki::Classroom::GuideProgress
+        .where(with_organization_and_course)
+        .sort('organization': :asc, 'course': :asc, 'student.uid': :asc)
+        .limit(per_page)
+        .skip(page * per_page)
+    end
+
+    def as_guide_progress_response(guide_progress)
+      {
+        student: guide_progress.student.uid,
+        guide: guide_progress.slug,
+        progress: guide_progress.as_json.except(:student, :guide)
+      }
+    end
+  end
+end
+