gaku_core 0.0.3 → 0.1.0

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

@@ -1,55 +0,0 @@
-module Gaku
-  class Exams::ExamPortionsController < GakuController
-
-    #load_and_authorize_resource :exam, class: Gaku::Exam
-    #load_and_authorize_resource :exam_portion, through: :exam, class: Gaku::ExamPortion
-    authorize_resource class: false
-
-    inherit_resources
-    belongs_to :exam
-    respond_to :js, :html
-
-    before_filter :exam
-    before_filter :count, only: [:create, :destroy]
-
-
-    def destroy
-      super do |format|
-        if @exam.exam_portions.empty?
-          if @exam.destroy
-            flash[:notice] = t(:'notice.destroyed', resource: t(:'exam.singular'))
-          end
-        end
-        format.js { render }
-      end
-    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
-
-    protected
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:exam_portion).permit(exam_portion_attr)]
-    end
-
-    private
-
-    def exam_portion_attr
-      %i(name weight problem_count max_score description adjustments)
-    end
-
-    def exam
-      @exam = Exam.find(params[:exam_id])
-    end
-
-    def count
-      @count = @exam.exam_portions.count
-    end
-  end
-end

data/app/controllers/gaku/exams_controller.rb

@@ -1,140 +0,0 @@
-module Gaku
-  class ExamsController < GakuController
-
-    #load_and_authorize_resource class: Gaku::Exam
-
-    inherit_resources
-    actions :index, :show, :new, :create, :update, :edit, :destroy
-    respond_to :html, :js, :json
-    respond_to :xls, only: :export
-
-    include Gaku::Grading::Calculations
-
-    before_filter :before_show, only: :show
-    before_filter :before_new,  only: :new
-    before_filter :count,       only: [:create, :destroy, :index]
-    before_filter :set_exam,    only: %i( show edit update soft_delete )
-    before_action :set_unscoped_exam,  only: %i( destroy recovery )
-
-    def recovery
-      @exam.recover
-      flash.now[:notice] = t(:'notice.recovered', resource: t_resource)
-      respond_with @exam
-    end
-
-    def soft_delete
-      @exam.soft_delete
-      redirect_to exams_path,
-                  notice: t(:'notice.destroyed', resource: t_resource)
-    end
-
-    def export
-      @course = Course.find(params[:course_id])
-    end
-
-    def index
-      if params[:course_id]
-        @exams = Course.find(params[:course_id]).syllabus.exams
-      else
-        @exams = Exam.all
-        @exam = Exam.new
-      end
-
-      @exam.exam_portions.build
-
-      respond_to do |format|
-        format.html
-        format.json { render json: @exams.as_json(include: {exam_portions: {include: :exam_portion_scores}})}
-      end
-    end
-
-    def grading
-      @course = Course.find(params[:course_id])
-      @students = @course.students #.select("id, surname, name")
-      find_exams
-
-      calculate_totals
-      calculate_exam_averages
-      calculate_deviation
-      calculate_rank_and_grade
-
-      @path_to_exam = course_path(id: params[:course_id])
-
-      #exam_portions need reload to properly include exam_portion_score in as_json
-      @exams.each { |exam| exam.exam_portions.reload }
-
-      respond_to do |format|
-        format.json do render json: {
-          student_total_scores: @student_total_scores.as_json,
-          exams: @exams.as_json(include: {exam_portions: {include: :exam_portion_scores }},root: false),
-          course: @course.as_json(root: false),
-          exam_averages: @exam_averages.as_json(root: false),
-          deviation: @deviation.as_json(root: false),
-          students: @students.to_json(root: false),
-          grades: @grades.as_json(root: false),
-          ranks: @ranks.as_json(root: false),
-          attendances: @student_portion_attendance.as_json(root: true, include: :attendance_type),
-          path_to_exam: @path_to_exam.to_json,
-          completion: @completion
-        }end
-        format.html { render 'gaku/exams/grading' }
-      end
-    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 resource_params
-      return [] if request.get?
-      [params.require(:exam).permit(exam_attr)]
-    end
-
-    private
-
-    def t_resource
-      t(:'exam.singular')
-    end
-
-    def exam_attr
-      [:name, :weight, :description, :adjustments, :use_weighting, { exam_portions_attributes: []}]
-    end
-
-    def before_new
-      @exam = Exam.new
-      @master_portion = @exam.exam_portions.new
-    end
-
-    def set_exam
-      @exam = Exam.find(params[:id])
-    end
-
-    def set_unscoped_exam
-      @exam = Exam.unscoped.find(params[:id])
-    end
-
-    def before_show
-      @notable = set_exam
-      @notable_resource = @notable.class.to_s.underscore.split('/')[1].gsub('_','-')
-    end
-
-    def count
-      @count = Exam.count
-    end
-
-    def find_exams
-      if params[:id] != nil
-        @exams = Exam.where(id: params[:id])
-      else
-        @exams = @course.syllabus.exams
-      end
-    end
-  end
-end

data/app/controllers/gaku/extracurricular_activities/students_controller.rb

@@ -1,55 +0,0 @@
-module Gaku
-  class ExtracurricularActivities::StudentsController < GakuController
-
-    authorize_resource class: false
-
-    inherit_resources
-    actions :index, :show, :create, :update, :edit, :delete
-
-    respond_to :js, :html
-
-    before_filter :extracurricular_activity, only: :new
-
-    def new
-      enrolled_students_ids = ExtracurricularActivityEnrollment.where(extracurricular_activity_id: @extracurricular_activity.id).map {|x| x.student_id}
-      @extracurricular_activity_enrollment = ExtracurricularActivityEnrollment.new
-      @students = Student.includes([:addresses, :extracurricular_activities, :enrollments]).all
-      render 'new'
-    end
-
-    def enroll_student
-      if params[:student_ids] && params[:student_ids] != ''
-        student_ids = params[:student_ids].split(',')
-        @extracurricular_activity = ExtracurricularActivity.find(params[:enrollment][:extracurricular_activity_id])
-        @students = []
-
-        student_ids.each do |student_id|
-          student = Student.find(student_id)
-          enrollment = ExtracurricularActivityEnrollment.new(extracurricular_activity_id: params[:enrollment][:extracurricular_activity_id], student_id: student.id)
-          enrollment.save!
-          @students << enrollment.student
-        end
-        respond_to do |format|
-          format.js { render 'enroll_student' }
-        end
-
-      end
-    end
-
-     def destroy
-      @extracurricular_activity_enrollment = ExtracurricularActivityEnrollment.find(params[:extracurricular_activity_enrollment])
-      @extracurricular_activity = ExtracurricularActivity.find(@extracurricular_activity_enrollment.extracurricular_activity_id)
-      @extracurricular_activity_enrollment.destroy
-      respond_with(@extracurricular_activity_enrollment) do |format|
-        format.js { render 'destroy' }
-      end
-    end
-
-    private
-
-    def extracurricular_activity
-      @extracurricular_activity =  ExtracurricularActivity.find(params[:extracurricular_activity_id])
-    end
-
-  end
-end

data/app/controllers/gaku/extracurricular_activities_controller.rb

@@ -1,48 +0,0 @@
-module Gaku
-  class ExtracurricularActivitiesController < GakuController
-
-    load_and_authorize_resource class: Gaku::ExtracurricularActivity
-
-    include StudentChooserController
-
-    inherit_resources
-    respond_to :js, :html
-
-    before_filter :count, only: [:create, :destroy, :index]
-
-    protected
-
-    def resource
-      @extracurricular_activity = ExtracurricularActivity.includes(includes)
-                                                         .find(params[:id])
-    end
-
-    def collection
-      @search = ExtracurricularActivity.search(params[:q])
-      results = @search.result(distinct: true)
-
-      @extracurricular_activities = results.page(params[:page])
-                                           .per(Preset.default_per_page)
-    end
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:extracurricular_activity).permit(extracurricular_activity_attr)]
-    end
-
-    def includes
-      #:student
-    end
-
-    private
-
-    def extracurricular_activity_attr
-      %i(name)
-    end
-
-    def count
-      @count = ExtracurricularActivity.count
-    end
-
-  end
-end

data/app/controllers/gaku/extracurricular_activity_enrollments_controller.rb

@@ -1,10 +0,0 @@
-module Gaku
-  class ExtracurricularActivityEnrollmentsController < GakuController
-
-    load_and_authorize_resource :extracurricular_activity_enrollment,
-                                class: Gaku::ExtracurricularActivityEnrollment
-
-    include EnrollmentsController
-
-  end
-end

data/app/controllers/gaku/home_controller.rb

@@ -1,10 +0,0 @@
-module Gaku
-  class HomeController < GakuController
-
-    skip_authorization_check
-
-    def index
-      redirect_to new_user_session_path unless user_signed_in?
-    end
-  end
-end

data/app/controllers/gaku/notes_controller.rb

@@ -1,81 +0,0 @@
-module Gaku
-  class NotesController < GakuController
-
-    #load_and_authorize_resource :note, class: Gaku::Note
-
-    before_action :set_notable
-    before_action :set_note,    only: %i( edit update destroy )
-    respond_to :js
-
-    def new
-      @note = Note.new
-      respond_with @note
-    end
-
-    def create
-      @note = @notable.notes.new(note_params)
-      @note.save
-      set_count
-      respond_with @note
-    end
-
-    def edit
-    end
-
-    def show
-    end
-
-    def update
-      @note.update(note_params)
-      respond_with @note
-    end
-
-    def destroy
-      @note.destroy
-      set_count
-      respond_with @note
-    end
-
-    private
-
-    def note_params
-      params.require(:note).permit(note_attr)
-    end
-
-    def note_attr
-      %i(title content)
-    end
-
-    def notable_klasses
-      [
-        Gaku::Student,
-        Gaku::Teacher,
-        Gaku::LessonPlan,
-        Gaku::Syllabus,
-        Gaku::ClassGroup,
-        Gaku::Course,
-        Gaku::Exam
-      ]
-    end
-
-    def set_count
-      @count = @notable.reload.notes_count
-    end
-
-    def set_note
-      @note = Note.find(params[:id])
-    end
-
-    def set_notable
-      unnamespaced_klass = ''
-      klass = notable_klasses.find do |c|
-        unnamespaced_klass = c.to_s.split('::')
-        params["#{unnamespaced_klass[1].underscore}_id"]
-      end
-
-      @notable = klass.find(params["#{unnamespaced_klass[1].underscore}_id"])
-      @notable_resource = get_resource_name @notable
-    end
-
-  end
-end

data/app/controllers/gaku/schedules_controller.rb

@@ -1,11 +0,0 @@
-module Gaku
-  class SchedulesController < GakuController
-
-    inherit_resources
-
-    def destroy
-      destroy! flash: !request.xhr?
-    end
-
-  end
-end

data/app/controllers/gaku/states_controller.rb

@@ -1,17 +0,0 @@
-module Gaku
-  class StatesController < GakuController
-    respond_to :js, :json
-
-    def index
-      if params[:country_id]
-        @country = Country.find(params[:country_id])
-        @states = State.where(country_iso: @country.iso)
-                       .order('name asc')
-      else
-        @states = State.all
-      end
-
-      respond_with @states
-    end
-  end
-end

data/app/controllers/gaku/students/class_group_enrollments_controller.rb

@@ -1,59 +0,0 @@
-module Gaku
-  class Students::ClassGroupEnrollmentsController < GakuController
-
-    load_and_authorize_resource :student, class: Gaku::Student
-    load_and_authorize_resource :class_group_enrollment, through: :student, class: Gaku::ClassGroupEnrollment
-
-    inherit_resources
-    actions :new, :create, :destroy
-    respond_to :js, :html
-
-    before_filter :student, only: [:new, :create]
-    before_filter :load_data
-
-    def create
-      @class_group_enrollment = ClassGroupEnrollment.new(class_group_enrollment_params)
-      respond_to do |format|
-        if @class_group_enrollment.save && @student.class_group_enrollments << @class_group_enrollment
-          @class_group = ClassGroup.find(@class_group_enrollment.class_group_id)
-        end
-        flash.now[:notice] = t('notice.enrolled', resource: t('student.singular'), to: t(:'class_group.singular'))
-        format.js { render 'create' }
-      end
-    end
-
-    def destroy
-      super do |format|
-        format.js { render nothing: true }
-      end
-    end
-
-    protected
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:class_group_enrollment).permit(class_group_enrollment_attr)]
-    end
-
-    private
-
-    def class_group_enrollment_attr
-      %i(class_group_id seat_number student_id)
-    end
-
-    def class_group_enrollment_params
-      params.require(:class_group_enrollment).permit(class_group_enrollment_attr)
-    end
-
-    private
-
-    def student
-      @student = Student.find(params[:student_id])
-    end
-
-    def load_data
-      @class_groups = ClassGroup.all.map { |s| [s.name.capitalize, s.id] }
-    end
-
-  end
-end

data/app/controllers/gaku/students/course_enrollments_controller.rb

@@ -1,43 +0,0 @@
-module Gaku
-  class Students::CourseEnrollmentsController < GakuController
-
-    load_and_authorize_resource :student
-    load_and_authorize_resource :course_enrollment, through: :student, class: Gaku::CourseEnrollment
-
-    inherit_resources
-    belongs_to :student, parent_class: Gaku::Student
-
-    defaults resource_class: CourseEnrollment,
-             instance_name: 'course_enrollment'
-
-    respond_to :js, :html
-
-    before_filter :load_data
-
-    def create
-      create! do |success, failure|
-        failure.js { render :error }
-      end
-    end
-
-    protected
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:course_enrollment).permit([:course_id, :student_id])]
-    end
-
-    private
-
-    def load_data
-      @courses = Course.includes(:syllabus).map do |c|
-        if c.syllabus_name
-          ["#{c.syllabus_name}-#{c.code}", c.id]
-        else
-          ["#{c.code}", c.id]
-        end
-      end
-    end
-
-  end
-end

data/app/controllers/gaku/students/guardians_controller.rb

@@ -1,85 +0,0 @@
-module Gaku
-  class Students::GuardiansController < GakuController
-
-    #load_and_authorize_resource :student, class: Gaku::Student
-    #load_and_authorize_resource :guardian, through: :student, class: Gaku::Guardian
-
-    inherit_resources
-    respond_to :js, :html
-
-    before_filter :student
-    before_filter :count, only: [:create,:destroy]
-    before_action :set_unscoped_guardian,  only: %i( destroy recovery )
-    before_action :set_guardian,           only: %i( soft_delete )
-
-    def create
-      super do |format|
-        if @student.guardians << @guardian
-          format.js { render }
-        end
-      end
-    end
-
-    def update
-      super do |format|
-        if params[:guardian][:picture]
-          format.html { redirect_to [:edit, student, @guardian], notice: t(:'notice.uploaded', resource: t(:'picture')) }
-        else
-          format.html { redirect_to [:edit, @student, @guardian] }
-          format.js { render }
-          format.json { head :no_content }
-         end
-      end
-    end
-
-    def recovery
-      @guardian.recover
-      flash.now[:notice] = t(:'notice.recovered', resource: t_resource)
-      respond_with @guardian
-    end
-
-    def soft_delete
-      @guardian.soft_delete
-      redirect_to student_guardians_path(@student),
-                  notice: t(:'notice.destroyed', resource: t_resource)
-    end
-
-    protected
-
-    def resource
-      @guardian = Guardian.includes(contacts: :contact_type).find(params[:id]).decorate
-    end
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:guardian).permit(guardian_attr)]
-    end
-
-    private
-
-    def guardian_attr
-      %i(name surname name_reading surname_reading birth_date gender relationship picture)
-    end
-
-    def student
-      @student = Student.find(params[:student_id])
-    end
-
-    def set_guardian
-      @guardian = Guardian.find(params[:id]).decorate
-    end
-
-    def set_unscoped_guardian
-      @guardian = Guardian.unscoped.find(params[:id]).decorate
-    end
-
-    def t_resource
-      t(:'guardian.singular')
-    end
-
-    def count
-      @count = @student.guardians.count
-    end
-
-  end
-end

data/app/controllers/gaku/students/simple_grades_controller.rb

@@ -1,59 +0,0 @@
-module Gaku
-  class Students::SimpleGradesController < GakuController
-
-    #skip_load_and_authorize_resource only: :index
-    skip_authorization_check
-
-    #load_and_authorize_resource :student, class: Gaku::Student
-    #load_and_authorize_resource :simple_grade, through: :student, class: Gaku::SimpleGrade
-
-    inherit_resources
-    belongs_to :student
-    respond_to :js, :html, :json
-
-    before_filter :load_data
-    before_filter :student
-    before_filter :count, only: [:index, :create, :destroy, :update]
-    before_filter :simple_grades, only: :update
-
-
-    protected
-
-    def collection
-      @simple_grades ||= end_of_association_chain.accessible_by(current_ability)
-    end
-
-    def begin_of_association_chain
-      @student
-    end
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:simple_grade).permit(simple_grade_attr)]
-    end
-
-    private
-
-    def simple_grade_attr
-      %i(name grade school_id)
-    end
-
-    def load_data
-      @schools = Gaku::School.all.map { |s| [s.name, s.id] }
-    end
-
-    def student
-      @student = Student.find(params[:student_id])
-    end
-
-    def count
-      @count = SimpleGrade.count
-    end
-
-    def simple_grades
-      @simple_grades = @student.simple_grades
-    end
-
-
-  end
-end