gaku_frontend 0.1.0

data/app/controllers/gaku/class_groups_controller.rb

@@ -0,0 +1,120 @@
+module Gaku
+  class ClassGroupsController < GakuController
+
+    include StudentChooserController
+
+    #respond_to :js,   only: %i( new create destroy recovery )
+    #respond_to :html, only: %i( index edit update soft_delete )
+
+    respond_to :html, :js
+
+    before_action :set_courses
+    before_action :set_class_group,       only: %i( edit update destroy student_chooser )
+
+
+    def destroy
+      @class_group.destroy
+      set_count
+      respond_with @class_group
+    end
+
+    def new
+      @class_group = ClassGroup.new
+      respond_with @class_group
+    end
+
+    def create
+      @class_group = ClassGroup.new(class_group_params)
+      @class_group.save
+      set_count
+      respond_with @class_group
+    end
+
+    def edit
+      @class_group_course_enrollment = ClassGroupCourseEnrollment.new
+    end
+
+    def update
+      @class_group.update(class_group_params)
+      respond_with @class_group, location: [:edit, @class_group]
+    end
+
+    def index
+      @semesters = Semester.with_class_group.active.includes(:class_groups)
+      @count = @semesters.count
+    end
+
+    def with_semester
+      @semesters = Semester.with_class_group.includes(:class_groups)
+      @count = @semesters.count
+      render :with_semester, layout: 'gaku/layouts/index'
+    end
+
+    def without_semester
+      @class_groups = ClassGroup.without_semester.includes(:semester_class_groups)
+      @count = @class_groups.count
+      render :without_semester, layout: 'gaku/layouts/index'
+    end
+
+    def advanced_search
+      @semesters = Semester.with_class_group.collect{|p| [p.to_s, p.id]}
+      @search = ClassGroup.search(params[:q])
+      results = @search.result(distinct: true)
+      @class_groups = results.page(params[:page])
+    end
+
+    def semester_advanced_search
+      @search = Semester.with_class_group.includes(:class_groups).search(params[:q])
+      results = @search.result(distinct: true)
+      @semesters = results.page(params[:page])
+      @semesters_for_select = Semester.with_class_group.collect{|p| [p.to_s, p.id]}
+    end
+
+    def search_semester
+      @search = Semester.includes(:class_groups).search(params[:q])
+      results = @search.result(distinct: true)
+      @semesters = results.page(params[:page])
+      @count = results.count
+      render :with_semester, layout: 'gaku/layouts/index'
+    end
+
+    def search
+      @semesters = Semester.with_class_group.collect{|p| [p.to_s, p.id]}
+      @search = ClassGroup.without_semester.search(params[:q])
+      results = @search.result(distinct: true)
+      @class_groups = results.page(params[:page])
+      @count = results.count
+      render :without_semester, layout: 'gaku/layouts/index'
+    end
+
+
+    private
+
+    def class_group_params
+      params.require(:class_group).permit(attributes)
+    end
+
+    def attributes
+      %i( name grade homeroom )
+    end
+
+    def set_class_group
+      @class_group = ClassGroup.find(params[:id])
+      set_notable
+    end
+
+    def set_notable
+      @notable = @class_group
+      @notable_resource = get_resource_name @notable
+    end
+
+    def set_count
+      @count = ClassGroup.count
+    end
+
+    def set_courses
+      @courses = Course.all.map { |c| [c, c.id] }
+    end
+
+  end
+end

data/app/controllers/gaku/contacts_controller.rb

@@ -0,0 +1,79 @@
+module Gaku
+  class ContactsController < GakuController
+
+    #load_and_authorize_resource :contact, class: Gaku::Contact
+
+    include PolymorphicResourceConcern
+
+    respond_to :js
+
+    before_action :set_contact_types,    only: %i( new edit )
+    before_action :set_contact,          only: %i( edit update destroy make_primary )
+    before_action :set_polymorphic_resource
+
+    def new
+      @contact = Contact.new
+      respond_with @contact
+    end
+
+    def create
+      @contact = @polymorphic_resource.contacts.new(contact_params)
+      @contact.save
+      set_count
+      respond_with @contact
+    end
+
+    def edit
+    end
+
+    def update
+      @contact.update(contact_params)
+      respond_with @contact
+    end
+
+    def destroy
+      if @contact.destroy
+        @polymorphic_resource.contacts.first.try(:make_primary) if @contact.primary?
+      end
+      set_count
+      respond_with @contact
+    end
+
+
+    def make_primary
+      @contact.make_primary
+      respond_with @contact
+    end
+
+    private
+
+    def set_contact
+      @contact = Contact.find(params[:id])
+    end
+
+    def contact_params
+      params.require(:contact).permit(attributes)
+    end
+
+    def attributes
+      %i( data details contact_type_id primary emergency )
+    end
+
+    def resource_klass
+      'contact'
+    end
+
+    def polymorphic_klasses
+      [Gaku::School, Gaku::Campus, Gaku::Student, Gaku::Guardian, Gaku::Teacher]
+    end
+
+    def set_contact_types
+      @contact_types = ContactType.all
+    end
+
+    def set_count
+      @count = @polymorphic_resource.reload.contacts_count
+    end
+
+  end
+end

data/app/controllers/gaku/course_enrollments_controller.rb

@@ -0,0 +1,10 @@
+module Gaku
+  class CourseEnrollmentsController < GakuController
+
+    load_and_authorize_resource :course_enrollment,
+                                class: Gaku::CourseEnrollment
+
+    include EnrollmentsController
+
+  end
+end

data/app/controllers/gaku/course_groups/course_group_enrollments_controller.rb

@@ -0,0 +1,54 @@
+module Gaku
+  class CourseGroups::CourseGroupEnrollmentsController < GakuController
+
+    respond_to :js, only: %i( new create destroy )
+
+    before_action :set_course_group
+    before_action :set_course_group_enrollment, only: :destroy
+
+    def new
+      @course_group_enrollment = CourseGroupEnrollment.new
+      respond_with @course_group_enrollment
+    end
+
+    def create
+      @course_group_enrollment = CourseGroupEnrollment.new(course_group_enrollment_params)
+      if @course_group_enrollment.save
+        flash.now[:notice] = t(:'notice.added', resource: t(:'course.singular'))
+        set_count
+        respond_with @course_group_enrollment
+      else
+        render :error
+      end
+    end
+
+    def destroy
+      @course_group_enrollment.destroy
+      set_count
+      respond_with @course_group_enrollment
+    end
+
+    private
+
+    def attributes
+      %i( course_id course_group_id )
+    end
+
+    def course_group_enrollment_params
+      params.require(:course_group_enrollment).permit(attributes)
+    end
+
+    def set_course_group
+      @course_group = CourseGroup.find(params[:course_group_id])
+    end
+
+    def set_course_group_enrollment
+      @course_group_enrollment = CourseGroupEnrollment.find(params[:id])
+    end
+
+    def set_count
+      @count = @course_group.courses.count
+    end
+
+  end
+end

data/app/controllers/gaku/course_groups_controller.rb

@@ -0,0 +1,91 @@
+module Gaku
+  class CourseGroupsController < GakuController
+
+    helper_method :sort_column, :sort_direction
+
+    # respond_to :js,   only: %i( new create edit update destroy recovery )
+    # respond_to :html, only: %i( index edit update soft_delete )
+    respond_to :html, :js
+
+    before_action :set_course_group,          only: %i( edit show update destroy )
+    before_action :set_courses
+
+    def destroy
+      @course_group.destroy
+      set_count
+      respond_with @course_group
+    end
+
+    def new
+      @course_group = CourseGroup.new
+      respond_with @course_group
+    end
+
+    def create
+      @course_group = CourseGroup.new(course_group_params)
+      @course_group.save
+      set_count
+      respond_with @course_group
+    end
+
+    def edit
+      @course_group_enrollment = CourseGroupEnrollment.new
+    end
+
+    def update
+      @course_group.update(course_group_params)
+      respond_with(@course_group) do |format|
+        format.js { render }
+        format.html { redirect_to [:edit, @course_group] }
+      end
+    end
+
+    def index
+      @course_groups = CourseGroup.order(sort_column + ' ' + sort_direction)
+      set_count
+      respond_with @course_groups
+    end
+
+    private
+
+    def course_group_params
+      params.require(:course_group).permit(attributes)
+    end
+
+    def attributes
+      %i( name code )
+    end
+
+    def set_course_group
+      @course_group = CourseGroup.find(params[:id])
+      set_notable
+    end
+
+
+    def set_courses
+      @courses = Course.all
+    end
+
+    def t_resource
+      t(:'course_group.singular')
+    end
+
+    def set_notable
+      @notable = @course_group
+      @notable_resource = get_resource_name @notable
+    end
+
+    def set_count
+      @count = CourseGroup.count
+    end
+
+    def sort_column
+      ClassGroup.column_names.include?(params[:sort]) ? params[:sort] : 'name'
+    end
+
+    def sort_direction
+      %w[asc desc].include?(params[:direction]) ? params[:direction] : 'asc'
+    end
+
+  end
+end

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

@@ -0,0 +1,55 @@
+module Gaku
+  class Courses::EnrollmentsController < GakuController
+
+    authorize_resource class: false
+
+    respond_to :js, only: %i( new enrolled_student enroll_class_group )
+
+    def new
+      @course = Course.find(params[:course_id])
+      render 'gaku/courses/enrollments/class_groups/new'
+    end
+
+    def enroll_student
+      @course = Course.find(params[:course_enrollment][:course_id])
+
+      @course_enrollment = CourseEnrollment.new(params[:course_enrollment])
+      if @course_enrollment.save
+        render 'gaku/courses/enrollments/students/enroll'
+      else
+        @errors = @course_enrollment.errors
+        render :error
+      end
+    end
+
+
+    def enroll_class_group
+      @course = Course.find(params[:course_id])
+      @not_added_students = []
+
+      unless params[:course][:class_group_id].blank?
+        @class_group = ClassGroup.find(params[:course][:class_group_id])
+        if @class_group.students.empty?
+          flash_error(@course, t(:'alert.empty', resource: t(:'class_group.singular'))) && return
+        else
+          @not_added_students = @class_group.students - @course.students
+          if @not_added_students.empty?
+            flash_error(@course, t(:'alert.already_added', resource: t(:'student.plural'))) && return
+          end
+        end
+        @course.enroll_class_group(@class_group)
+        render 'gaku/courses/enrollments/class_groups/enroll'
+      else
+        flash_error(@course,t(:'alert.not_selected', resource: t(:'class_group.singular')))
+      end
+    end
+
+    private
+
+    def flash_error(respond_with_var,message)
+      @course.errors[:base] << message
+      render 'gaku/courses/enrollments/class_groups/enroll'
+    end
+
+  end
+end

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

@@ -0,0 +1,28 @@
+module Gaku
+  class Courses::ExamsController < GakuController
+
+    respond_to :html
+
+    def grading
+      @course = Course.find(params[:course_id])
+      @exam = Exam.find(params[:id])
+      @students = @course.students
+      init_portion_scores
+
+      respond_with @exam
+    end
+
+    private
+
+    def init_portion_scores
+      @students.each do |student|
+        @exam.exam_portions.each do |portion|
+          unless portion.exam_portion_scores.pluck(:student_id).include?(student.id)
+            ExamPortionScore.create!(exam_portion: portion, student: student)
+          end
+        end
+      end
+    end
+
+  end
+end

data/app/controllers/gaku/courses/semester_courses_controller.rb

@@ -0,0 +1,64 @@
+module Gaku
+  class Courses::SemesterCoursesController < GakuController
+
+    respond_to :js, only: %i( new create edit update destroy )
+
+    before_action :set_course
+    before_action :set_semester_course, only: %i( edit update destroy )
+    before_action :set_semesters, only: %i( new edit )
+
+    def new
+      @semester_course = SemesterCourse.new
+      respond_with @semester_course
+    end
+
+    def create
+      @semester_course = @course.semester_courses.build(semester_course_params)
+      @semester_course.save
+      set_count
+      respond_with @semester_course
+    end
+
+    def edit
+    end
+
+    def update
+      @semester_course.update(semester_course_params)
+      respond_with @semester_course
+    end
+
+    def destroy
+      @semester_course.destroy
+      set_count
+      respond_with @semester_course
+    end
+
+
+    private
+
+    def set_course
+      @course = Course.find(params[:course_id])
+    end
+
+    def set_semester_course
+      @semester_course = SemesterCourse.find(params[:id])
+    end
+
+    def semester_course_params
+      params.require(:semester_course).permit(attributes)
+    end
+
+    def attributes
+      %i( semester_id )
+    end
+
+    def set_count
+      @count = @course.semesters.count
+    end
+
+    def set_semesters
+      @semesters = Semester.all
+    end
+
+  end
+end