gaku 0.2.4 → 0.3.0.pre.0

data/frontend/app/controllers/gaku/devise/passwords_controller.rb

@@ -1,4 +0,0 @@
-class Gaku::Devise::PasswordsController < Devise::PasswordsController
-  # helper Gaku::GakuHelper
-  layout 'gaku/layouts/gaku'
-end

data/frontend/app/controllers/gaku/devise/registrations_controller.rb

@@ -1,60 +0,0 @@
-class Gaku::Devise::RegistrationsController < Devise::RegistrationsController
-  # helper Gaku::GakuHelper
-  layout 'gaku/layouts/gaku'
-
-  def set_up_admin_account
-    resource = build_resource({})
-    respond_with resource
-  end
-
-  def create
-    build_resource(user_params)
-
-    if resource.save
-      if resource.active_for_authentication?
-        set_flash_message :notice, :signed_up if is_navigational_format?
-        sign_up(resource_name, resource)
-        respond_with resource, location: after_sign_up_path_for(resource)
-      else
-        set_flash_message :notice, :"signed_up_but_#{resource.inactive_message}" if is_navigational_format?
-        expire_session_data_after_sign_in!
-        respond_with resource, location: after_inactive_sign_up_path_for(resource)
-      end
-    else
-      clean_up_passwords resource
-      respond_with resource
-    end
-  end
-
-  def create_admin
-    build_resource(user_params)
-    admin_role = Gaku::Role.where(name: 'Admin').first_or_create!
-    resource.roles << admin_role
-
-    if resource.save
-      if resource.active_for_authentication?
-        set_flash_message :notice, :signed_up if is_navigational_format?
-        sign_up(resource_name, resource)
-        respond_with resource, location: after_sign_up_path_for(resource)
-      else
-        set_flash_message :notice, :"signed_up_but_#{resource.inactive_message}" if is_navigational_format?
-        expire_session_data_after_sign_in!
-        respond_with resource, location: after_inactive_sign_up_path_for(resource)
-      end
-    else
-      clean_up_passwords resource
-      respond_with resource
-    end
-  end
-
-  protected
-
-  def user_params
-    params.require(:user).permit(user_attr)
-  end
-
-  def user_attr
-    %i( username email password password_confirmation )
-  end
-
-end

data/frontend/app/controllers/gaku/devise/sessions_controller.rb

@@ -1,15 +0,0 @@
-class Gaku::Devise::SessionsController < Devise::SessionsController
-  # helper Gaku::GakuHelper
-  layout 'gaku/layouts/gaku'
-
-  skip_before_filter :require_login, except: %i( new create )
-
-  def create
-    self.resource = warden.authenticate!(auth_options)
-    set_flash_message(:notice, :signed_in)
-    sign_in(resource_name, resource)
-    yield resource if block_given?
-    redirect_to session['previous_url'] || root_path
-  end
-
-end

data/frontend/app/controllers/gaku/enrollments_controller.rb

@@ -1,130 +0,0 @@
-module Gaku
-  class EnrollmentsController < GakuController
-
-    respond_to :js, only: %i( new create destroy student_selection create_from_selection )
-
-    before_action :set_enrollmentable
-    before_action :set_enrollment, only: %i( destroy )
-    before_action :set_students, only: %i( new )
-
-    def index
-    end
-
-    def student_selection
-      @enrollment = @enrollmentable.enrollments.new
-      @student_selection = Gaku::StudentSelection.new(current_user).all
-    end
-
-    def new
-      @enrollment = @enrollmentable.enrollments.new
-    end
-
-    def create_from_selection
-      if params[:selected_students].blank?
-        missing_selected_students
-      else
-        @enrollments, students = [], {}
-        students[:enrolled], students[:not_found], students[:failed] = [], [], []
-
-        params[:selected_students].each  do |student_id|
-          student = Student.where(id: student_id).first
-          if student
-            enrollment = @enrollmentable.enrollments.build(student_id: student_id)
-            if enrollment.save
-              @enrollments << enrollment
-              students[:enrolled] << student.decorate.full_name
-            else
-              students[:failed] << enrollment
-            end
-          else
-            students[:not_found] << student_id
-          end
-        end
-
-        set_flash_messages(students)
-        set_count
-      end
-    end
-
-    def create
-      @enrollment = @enrollmentable.enrollments.build(enrollment_params)
-      @enrollment.save
-      set_count
-      respond_with @enrollment
-    end
-
-    def destroy
-      @enrollment.destroy
-      set_count
-      respond_with @enrollment
-    end
-
-    private
-
-    def set_enrollmentable
-      resource, id = request.path.split('/')[1, 2]
-      @enrollmentable = resource.insert(0, 'gaku/').pluralize.classify.constantize.find(id)
-      @enrollmentable_resource = @enrollmentable.class.to_s.demodulize.underscore.dasherize
-    end
-
-    def set_enrollment
-      @enrollment = Enrollment.find(params[:id])
-    end
-
-    def enrollment_params
-      params.require(:enrollment).permit(attributes)
-    end
-
-    def attributes
-      %i( student_id )
-    end
-
-    def set_count
-      @count = @enrollmentable.reload.enrollments_count
-    end
-
-    def set_students
-      @students = Student.all
-    end
-
-    def missing_selected_students
-      set_count
-      flash.now[:error] = 'No students selected!'
-      redirect_to [@enrollmentable, :enrollments]
-    end
-
-    def set_flash_messages(students)
-      flash_success(students[:enrolled])     if students[:enrolled].size > 0
-      flash_not_found(students[:not_found])  if students[:not_found].size > 0
-      flash_failure(students[:failed])       if students[:failed].size > 0
-    end
-
-    def flash_failure(enrollments)
-      msg = ''
-      enrollments.each do |enrollment|
-        student = Gaku::Student.find(enrollment.student_id)
-        msg += msg_for_failed_enrollment(student, enrollment.errors.full_messages.join(', '))
-      end
-      flash.now[:error] = msg.html_safe
-    end
-
-    def flash_not_found(ids)
-      flash.now[:error] = "Students with ids: #{ids.join(', ')} not found".html_safe
-    end
-
-    def flash_success(students)
-      msg = ''
-      students.each { |student| msg += msg_for_enrollment(student) }
-      flash.now[:success] = msg.html_safe
-    end
-
-    def msg_for_enrollment(student)
-      "<p>#{student} : <span style='color:green;'> #{t(:'success.enrolled')}</span></p>"
-    end
-
-    def msg_for_failed_enrollment(student, errors)
-      "<p>#{student} : <span style='color:orange;'> #{errors}</span></p>"
-    end
-
-  end
-end

data/frontend/app/controllers/gaku/exam_portion_scores_controller.rb

@@ -1,49 +0,0 @@
-module Gaku
-  class ExamPortionScoresController < GakuController
-
-    respond_to :js
-
-    before_action :set_course, only: :update
-    before_action :set_exam, only: :update
-
-    def update
-      exam_portion_score = ExamPortionScore.find(params[:id])
-      exam_portion_score.update_attributes(exam_portion_score_params)
-
-      student         = exam_portion_score.student
-      grading_methods = @course.grading_methods
-
-      calculations = Grading::Single::Calculations.new(grading_methods, student, @exam, @course.students).calculate
-
-      message = {
-                  exam_id: @exam.id,
-                  course_id: @course.id,
-                  calculations: calculations,
-                  exam_portion_score: exam_portion_score
-                }
-
-      $redis.publish('grading-change', message.to_json)
-
-      render nothing: true
-    end
-
-    private
-
-    def exam_portion_score_params
-      params.require(:exam_portion_score).permit(attributes)
-    end
-
-    def attributes
-      %i( score )
-    end
-
-    def set_course
-      @course = Course.find(params[:course_id])
-    end
-
-    def set_exam
-      @exam = Exam.find(params[:exam_id])
-    end
-
-  end
-end

data/frontend/app/controllers/gaku/exams/exam_portions_controller.rb

@@ -1,84 +0,0 @@
-module Gaku
-  class Exams::ExamPortionsController < GakuController
-
-    authorize_resource class: false
-
-    respond_to :js, :html
-
-    before_action :set_exam, only: %i( new show create edit update destroy sort index )
-    before_action :set_exam_portion, only: %i( show edit update destroy )
-    before_action :set_attachable, only: %i( edit )
-
-    def index
-    end
-
-    def new
-      @exam_portion = ExamPortion.new
-      respond_with @exam_portion
-    end
-
-    def create
-      @exam_portion = @exam.exam_portions.create(exam_portion_params)
-      set_count
-      respond_with @exam_portion
-    end
-
-    def show
-      respond_with @exam_portion
-    end
-
-    def edit
-      respond_with @exam_portion
-    end
-
-    def update
-      @exam_portion.update(exam_portion_params)
-      respond_with @exam_portion# , location: [@exam, :exam_portions]
-    end
-
-    def destroy
-      @exam_portion.destroy
-      # if @exam.exam_portions.empty?
-      #   if @exam.destroy!
-      #     flash[:notice] = t(:'notice.destroyed', resource: t(:'exam.singular'))
-      #   end
-      # end
-      set_count
-      respond_with @exam_portion
-    end
-
-    def sort
-      params[:'exam-portion'].each_with_index do |id, index|
-        @exam.exam_portions.update_all({ position: index }, { id: id })
-      end
-      render nothing: true
-    end
-
-    private
-
-    def exam_portion_params
-      params.require(:exam_portion).permit(attributes)
-    end
-
-    def attributes
-      %i( name weight problem_count max_score description adjustments )
-    end
-
-    def set_exam_portion
-      @exam_portion = ExamPortion.find(params[:id])
-    end
-
-    def set_exam
-      @exam = Exam.find(params[:exam_id])
-    end
-
-    def set_count
-      @count = @exam.reload.exam_portions_count
-    end
-
-    def set_attachable
-      @attachable = @exam_portion
-      @attachable_resource = 'exam-exam-portion-attachment'
-    end
-  end
-end

data/frontend/app/controllers/gaku/exams/exam_sessions_controller.rb

@@ -1,58 +0,0 @@
-module Gaku
-  class Exams::ExamSessionsController < GakuController
-
-    respond_to :js, except: :index
-
-    before_filter :set_exam_session, only: %i( edit update destroy )
-    before_filter :load_data, only: %i( new edit )
-    before_filter :set_count, only: :create
-
-    def new
-      @exam_session = ExamSession.new
-      respond_with @exam_session
-    end
-
-    def create
-      @exam_session = ExamSession.create(exam_session_params)
-      set_count
-      respond_with @exam_session
-    end
-
-    def edit
-      respond_with @exam_session
-    end
-
-    def update
-      @exam_session.update(exam_session_params)
-      respond_with @exam_session, location: [:edit, @exam_session]
-    end
-
-    def destroy
-      @exam_session.destroy!
-      respond_with @exam_session, location: [:exams]
-    end
-
-    private
-
-    def exam_session_params
-      params.require(:exam_session).permit(attributes)
-    end
-
-    def attributes
-      %i( name session_time exam_id session_start )
-    end
-
-    def set_exam_session
-      @exam_session = ExamSession.find(params[:id])
-    end
-
-    def load_data
-      @exams = Exam.all
-    end
-
-    def set_count
-      @count = ExamSession.count
-    end
-
-  end
-end

data/frontend/app/controllers/gaku/exams_controller.rb

@@ -1,127 +0,0 @@
-module Gaku
-  class ExamsController < GakuController
-
-    respond_to :html, :js, :json
-    respond_to :xls, only: :export
-
-    before_action :set_exam,    only: %i( show edit update destroy )
-    before_action :load_data, only: %i( new edit )
-
-    def index
-      if params[:course_id]
-        @exams = Course.find(params[:course_id]).syllabus.exams
-      else
-        @search = Exam.includes(:department).search(params[:q])
-        results = @search.result(distinct: true)
-        @exams = results.page(params[:page])
-        @exam = Exam.new
-        @exam_sessions = ExamSession.all
-      end
-
-      @exam.exam_portions.build
-      set_count
-      respond_to do |format|
-        format.html
-        format.json { render json: @exams.as_json(include: { exam_portions: { include: :exam_portion_scores } }) }
-      end
-    end
-
-    def show
-      respond_with @exam
-    end
-
-    def new
-      @exam = Exam.new
-      @master_portion = @exam.exam_portions.new
-      respond_with @exam
-    end
-
-    def create
-      @exam = Exam.new(exam_params)
-      @exam.use_primary_grading_method_set if @exam.save
-      set_count
-      respond_with @exam
-    end
-
-    def edit
-      respond_with @exam
-    end
-
-    def update
-      @exam.update(exam_params)
-      respond_with @exam, location: [:edit, @exam]
-    end
-
-    def destroy
-      @exam.destroy
-      set_count
-      respond_with @exam
-    end
-
-    def export
-      @course = Course.find(params[:course_id])
-    end
-
-    def completed
-      @exam = Exam.find(params[:id])
-      @course = Course.find(params[:course_id])
-      @students = @course.students
-
-      respond_with @exam.completed_by_students(@students)
-    end
-
-    protected
-
-    def exam_params
-      params.require(:exam).permit(attributes)
-    end
-
-    private
-
-    def load_data
-      @departments = Department.all
-    end
-
-    def t_resource
-      t(:'exam.singular')
-    end
-
-    def attributes
-      [:name, :department_id, :weight, :description, :adjustments, :use_weighting,
-       exam_portions_attributes: [:id, :name, :weight, :problem_count, :max_score, :description, :adjustments]
-      ]
-    end
-
-    def includes
-      { grading_method_connectors: :grading_method }
-    end
-
-    def set_exam
-      @exam = Exam.includes(includes).find(params[:id])
-      set_notable
-      set_gradable
-    end
-
-    def set_notable
-      @notable = @exam
-      @notable_resource = @notable.class.to_s.demodulize.underscore.dasherize
-    end
-
-    def set_gradable
-      @gradable = @exam
-      @gradable_resource = @gradable.class.to_s.demodulize.underscore.dasherize
-    end
-
-    def set_count
-      @count = Exam.count
-    end
-
-    def find_exams
-      if params[:id]
-        @exams = Exam.where(id: params[:id])
-      else
-        @exams = @course.syllabus.exams
-      end
-    end
-  end
-end