mumuki-classroom 8.0.0

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

@@ -0,0 +1,62 @@
+require 'net/http'
+
+class Mumuki::Classroom::Submission < Mumuki::Classroom::Document
+
+  extend WithSubmissionProcess
+
+  field :sid, type: String
+  field :content
+  field :created_at, type: Time
+  field :expectation_results, type: Array
+  field :feedback, type: String
+  field :result, type: String
+  field :status, type: String
+  field :submissions_count, type: Integer
+  field :test_results, type: Array
+  field :comments, type: Array
+  field :manual_evaluation, type: String
+  field :origin_ip, type: String
+
+  embeds_many :messages, class_name: 'Mumuki::Classroom::Message'
+
+  embedded_in :assignment, class_name: 'Mumuki::Classroom::Assignment'
+  embedded_in :suggestion, class_name: 'Mumuki::Classroom::Suggestion'
+  embedded_in :last_assignment, class_name: 'Mumuki::Classroom::LastAssignment'
+
+  def evaluate_manually!(comment, status)
+    self.status = status
+    self.manual_evaluation = comment
+  end
+
+  def add_message!(message)
+    self.messages << Mumuki::Classroom::Message.new(message.as_json)
+  end
+
+  def expectation_results
+    self[:expectation_results]&.map do |expectation|
+      {html: Mulang::Expectation.parse(expectation).translate, result: expectation['result']} # TODO translate with keywords
+    end
+  end
+
+  def thread(language)
+    {
+      status: status,
+      content: Mumukit::ContentType::Markdown.to_html(Mumukit::ContentType::Markdown.highlighted_code language, content || ''),
+      messages: messages,
+      created_at: created_at
+    } if messages.present?
+  end
+
+  def manual_evaluation
+    Mumukit::ContentType::Markdown.to_html(self[:manual_evaluation]) if self[:manual_evaluation]
+  end
+
+  def with_full_messages(user)
+    self.tap do |submission|
+      submission[:messages] = messages.map do |message|
+        message.with_full_messages user
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,35 @@
+class Mumuki::Classroom::Suggestion < Mumuki::Classroom::Document
+  include Mongoid::Timestamps
+
+  field :sender, type: String
+  field :email, type: String
+  field :content, type: String
+  field :date, type: String
+  field :guide_slug, type: String
+  field :times_used, type: Integer
+
+  before_save :update_times_used
+
+  embeds_one :exercise
+  embeds_many :submissions, class_name: 'Mumuki::Classroom::Submission'
+
+  create_index({'guide_slug': 1, 'exercise.eid': 1})
+
+  def add_submission!(submission)
+    update_attributes! submissions: submissions + [submission]
+  end
+
+  def content_html
+    Mumukit::ContentType::Markdown.to_html content
+  end
+
+  def self.create_from(message, assignment)
+    create message.merge(guide_slug: assignment.guide['slug'], exercise: assignment.exercise)
+  end
+
+  private
+
+  def update_times_used
+    self.times_used = submissions.size
+  end
+end

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

@@ -0,0 +1,3 @@
+class Mumuki::Classroom::Teacher < Mumuki::Classroom::Document
+  include CourseMember
+end

data/lib/mumuki/classroom/permissions_diff.rb

@@ -0,0 +1,83 @@
+class Hash
+  def to_mumukit_permissions
+    Mumukit::Auth::Permissions.parse self
+  end
+end
+
+class Mumukit::Auth::Permissions
+  def to_mumukit_permissions
+    self
+  end
+
+  def grants_for(role)
+    scope_for(role).grants
+  end
+end
+
+class Mumukit::Auth::Permissions
+  class Change
+    attr_accessor :role, :grant, :type
+
+    def initialize(role, grant, change_type)
+      @role = role
+      @grant = grant
+      @type = change_type
+    end
+
+    def description
+      "#{role}_#{type}"
+    end
+
+    def organization
+      granted_slug.organization
+    end
+
+    def granted_slug
+      grant.to_mumukit_slug
+    end
+
+    def as_json(options = {})
+      {role: @role, grant: @grant, type: @type}.as_json options
+    end
+  end
+
+  class Diff
+    attr_accessor :changes
+
+    def initialize
+      @changes = []
+    end
+
+    def changes_by_organization
+      changes.group_by(&:organization).with_indifferent_access
+    end
+
+    def empty?
+      changes.empty?
+    end
+
+    def compare_grants!(role, some_permissions, another_permissions, change_type)
+      some_permissions
+        .grants_for(role)
+        .select { |grant| !another_permissions.role_allows?(role, grant) }
+        .each { |grant| changes << Change.new(role, grant, change_type) }
+    end
+
+    def self.diff(old_permissions, new_permissions)
+      return Mumukit::Auth::Permissions::Diff.new if new_permissions.nil?
+
+      old_permissions = old_permissions.to_mumukit_permissions
+      new_permissions = new_permissions.to_mumukit_permissions
+      new.tap do |it|
+        Mumukit::Auth::Roles::ROLES.each do |role|
+          it.compare_grants! role, old_permissions, new_permissions, :removed
+          it.compare_grants! role, new_permissions, old_permissions, :added
+        end
+      end
+    end
+
+    def as_json(options = {})
+      {changes: @changes}.as_json options
+    end
+  end
+end

data/lib/mumuki/classroom/reports.rb

@@ -0,0 +1,4 @@
+module Mumuki::Classroom::Reports
+end
+
+require_relative './reports/formats'

data/lib/mumuki/classroom/reports/formats.rb

@@ -0,0 +1,35 @@
+class Mumuki::Classroom::Reports::Formats
+  module Json
+    def self.format_report(stats)
+      stats.to_json
+    end
+  end
+
+  module Csv
+    def self.format_report(stats)
+      stats.to_csv
+    end
+  end
+
+  module Table
+    def self.format_report(stats)
+      return '<no data>' if stats.empty?
+
+      header = stats.first.keys.join(' | ')
+      body = stats.map { |it| it.values.join(' | ') }.join("\n")
+<<EOF
+      #{header}
+      #{header.size.times.map { '-' }.join}
+      #{body}
+EOF
+    end
+  end
+
+  def self.format_for(key)
+    "Mumuki::Classroom::Reports::Formats::#{key.capitalize}".constantize
+  end
+
+  def self.format_report(key, stats)
+    format_for(key).format_report(stats)
+  end
+end

data/lib/mumuki/classroom/sinatra.rb

@@ -0,0 +1,301 @@
+require 'sinatra/base'
+require 'sinatra/namespace'
+require 'sinatra/cross_origin'
+
+class Mumuki::Classroom::App < Sinatra::Application
+  configure do
+    enable :cross_origin
+    set :allow_methods, [:get, :put, :post, :options, :delete]
+    set :show_exceptions, false
+
+    set :app_name, 'classroom'
+    set :static, true
+    set :public_folder, 'public'
+
+    use ::Rack::CommonLogger, Rails.logger
+  end
+
+  helpers do
+    Mumukit::Login.configure_controller! self
+
+    def authenticate!
+      halt 401 unless current_user?
+    end
+
+    def json_body
+      @json_body ||= JSON.parse(request.body.read).with_indifferent_access rescue nil
+    end
+
+    def with_organization(hash = {})
+      {organization: organization}.merge hash
+    end
+
+    # FIXME only provisional
+    def with_current_organization(hash = {})
+      {organization: current_organization}.merge hash.except(:organization)
+    end
+
+    # FIXME only provisional
+    def with_current_organization_and_course(hash = {})
+      with_current_organization.merge(course: current_course).merge hash.except(:organization, :course)
+    end
+
+    def with_organization_and_course(hash = {})
+      with_organization.merge(course: course_slug).merge hash
+    end
+
+    def authorization_slug
+      slug
+    end
+
+    def slug
+      if route_slug_parts.present?
+        Mumukit::Auth::Slug.join(*route_slug_parts)
+      elsif json_body
+        Mumukit::Auth::Slug.parse(json_body['slug'])
+      else
+        raise Mumukit::Auth::InvalidSlugFormatError.new('Slug not available')
+      end
+    end
+
+    def permissions
+      current_user.permissions
+    end
+
+    def course
+      params[:course]
+    end
+
+    def uid
+      params[:uid]
+    end
+
+    def exercise_id
+      params[:exercise_id].to_i
+    end
+
+    def exercise_student_progress_query
+      {'guide.slug': repo_slug, 'student.uid': uid}
+    end
+
+    def tenant
+      Mumukit::Platform.organization_name(request)
+    end
+
+    def organization
+      tenant
+    end
+
+    def route_slug_parts
+      [tenant, course].compact
+    end
+
+    def course_slug
+      @course_slug ||= Mumukit::Auth::Slug.join_s(*route_slug_parts)
+    end
+
+    def repo_slug
+      @repo_slug ||= Mumukit::Auth::Slug.join_s(params[:organization], params[:repository])
+    end
+
+    def tenantized_json_body
+      json_body.merge(tenant: tenant)
+    end
+
+    def ensure_course_existence!
+      Course.locate! course_slug
+    end
+
+    def ensure_member_not_exists!(member_json, member_collection)
+      member_collection.ensure_not_exists! with_organization_and_course uid: member_json[:uid]
+    end
+
+    def collection_for(role)
+      "Mumuki::Classroom::#{role.to_s.titleize}".constantize
+    end
+
+    def create_course_member!(role)
+      member_collection = collection_for role
+
+      member_collection.normalized_attributes_from_json(json_body).tap do |member_json|
+        ensure_member_not_exists! member_json, member_collection
+        member = member_collection.create!(with_organization_and_course member_json)
+        upsert_user! role, member.as_user
+      end
+    end
+
+    def set_locale!
+      I18n.locale = current_organization.locale
+    end
+
+    def organization_json
+      @organization_json ||= current_organization.as_json
+    end
+
+    def current_organization
+      @current_organization ||= Organization.locate!(organization).switch!
+    end
+
+    def current_course
+      @current_course ||= Course.locate!(course_slug)
+    end
+
+    def update_user_permissions!(uid, method, *slugs)
+      user = User.locate!(uid)
+      user.send("#{method}_permission!", :student, *slugs)
+      user.save!
+    end
+
+    def page
+      (params[:page] || 1).to_i - 1
+    end
+
+    def per_page
+      (params[:per_page] || 30).to_i
+    end
+
+    def sort_by
+      params[:sort_by] || :name
+    end
+
+    def with_detached
+      params[:with_detached].boolean_value
+    end
+
+    def query
+      params[:q] || ''
+    end
+
+    def query_criteria
+      params[:query_criteria]
+    end
+
+    def query_operand
+      params[:query_operand]
+    end
+
+    def order_by
+      params[:order_by] || :asc
+    end
+
+    def csv_projection_for(projection)
+      projection.transform_values do |val|
+        next val if val == 0
+        {'$ifNull': [val, nil]}
+      end
+    end
+
+    def group_report_projection
+      {
+        '_id': 0,
+        'last_name': '$last_name',
+        'first_name': '$first_name',
+        'email': '$email',
+        'personal_id': '$personal_id',
+        'detached': {'$eq': ['$detached', true]},
+        'created_at': '$created_at',
+        'last_submission_date': '$last_assignment.submission.created_at',
+        'passed_count': '$stats.passed',
+        'passed_with_warnings_count': '$stats.passed_with_warnings',
+        'failed_count': '$stats.failed',
+        'last_lesson_type': '$last_assignment.guide.parent.type',
+        'last_lesson_name': '$last_assignment.guide.parent.name',
+        'last_exercise_number': '$last_assignment.exercise.number',
+        'last_exercise_name': '$last_assignment.exercise.name',
+        'last_chapter': '$last_assignment.guide.parent.chapter.name',
+      }
+    end
+
+    def group_report(matcher, projection)
+      projection = csv_projection_for projection
+      aggregation = Mumuki::Classroom::Student.where(matcher).project(projection)
+      pipeline_with_sort_criterion = aggregation.pipeline << {'$sort': {passed_count: -1, passed_with_warnings_count: -1, failed_count: -1, last_name: 1, first_name: 1}}
+      json = Mumuki::Classroom::Student.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
+  end
+
+
+  before do
+    content_type 'application/json', 'charset' => 'utf-8'
+  end
+
+  after do
+    error_message = env['sinatra.error']
+    if response.body.is_a?(Array) && response.body[0].is_a?(String)
+      if content_type != 'application/csv'
+        content_type 'text/html'
+        response.body[0] = <<HTML
+      <html>
+        <body>
+          #{response.body[0]}
+        </body>
+      </html>
+HTML
+      end
+      response.body = response.body[0]
+    elsif error_message.blank?
+      response.body = response.body.to_json
+    else
+      begin
+        json = JSON.parse(error_message.message)
+        response.body = json.to_json
+      rescue
+        response.body = {message: error_message.message}.to_json
+      end
+    end
+  end
+
+  error JSON::ParserError do
+    halt 400
+  end
+
+  error ActiveRecord::RecordInvalid do
+    halt 400
+  end
+
+  error ActiveRecord::RecordNotFound do
+    halt 404
+  end
+
+  error Mumukit::Auth::InvalidTokenError do
+    halt 401
+  end
+
+  error Mumukit::Auth::UnauthorizedAccessError do
+    halt 403
+  end
+
+  error Mumukit::Auth::InvalidSlugFormatError do
+    halt 400
+  end
+
+  before do
+    set_locale! if current_organization
+  end
+
+  options '*' do
+    response.headers['Allow'] = settings.allow_methods.map { |it| it.to_s.upcase }.join(',')
+    response.headers['Access-Control-Allow-Headers'] = 'X-Mumuki-Auth-Token, X-Requested-With, X-HTTP-Method-Override, Content-Type, Cache-Control, Accept, Authorization'
+    200
+  end
+end
+
+require_relative './sinatra/errors'
+require_relative './sinatra/pagination'
+require_relative './sinatra/courses'
+require_relative './sinatra/guides'
+require_relative './sinatra/messages'
+require_relative './sinatra/exams'
+require_relative './sinatra/followers'
+require_relative './sinatra/organization'
+require_relative './sinatra/ping'
+require_relative './sinatra/teachers'
+require_relative './sinatra/students'
+require_relative './sinatra/permissions'
+require_relative './sinatra/notifications'
+require_relative './sinatra/suggestions'
+require_relative './sinatra/manual_evaluation'
+require_relative './sinatra/searching'
+require_relative './sinatra/massive'