gaku_frontend 0.1.0

data/app/controllers/concerns/polymorphic_resource_concern.rb

@@ -0,0 +1,48 @@
+module PolymorphicResourceConcern
+
+  private
+
+  def set_polymorphic_resource
+    klasses = polymorphic_klasses.select do |c|
+      params[c.to_s.foreign_key]
+    end
+
+    @nested_resources = nested_resources(klasses)
+    #puts "nested_resources :::::::::::::::::::: #{@nested_resources}"
+    #puts "resource_name:::::::::::::::::::: #{resource_name}"
+    @polymorphic_resource_name = resource_name
+  end
+
+  def nested_resources(klasses)
+    nested_resources = []
+    last_klass_foreign_key = params[klasses.last.to_s.foreign_key]
+    if klasses.is_a? Array
+      @polymorphic_resource = klasses.last.find(last_klass_foreign_key)
+      klasses.pop #remove @polymorphic_resource resource
+      klasses.each do |klass|
+        nested_resources.append klass.find(params[klass.to_s.foreign_key])
+      end
+    else
+      @polymorphic_resource = klasses.find(params[klasses.to_s.foreign_key])
+    end
+
+    #prepend :admin for admin/namespacing
+    nested_resources.prepend(:admin) if @polymorphic_resource.class == Gaku::Campus
+    nested_resources
+  end
+
+  def resource_name
+    resource_name = []
+    @nested_resources.each do |resource|
+      if resource.is_a?(Symbol)
+        resource_name.append(resource.to_s)
+      else
+        resource_name.append(get_class(resource))
+      end
+    end
+    resource_name.append get_class(@polymorphic_resource)
+    resource_name.append resource_klass
+    resource_name.join '-'
+  end
+
+end

data/app/controllers/concerns/student_chooser_controller.rb

@@ -0,0 +1,41 @@
+module StudentChooserController
+
+  include Gaku::ClassNameDetector
+
+  def student_chooser
+    set_preset
+    set_students
+
+    set_collection
+    set_resource
+
+    respond_to { |format| format.js }
+  end
+
+  private
+
+  def set_preset
+    @preset = Gaku::Preset.active
+  end
+
+  def set_students
+    @search = Gaku::Student.active.search(params[:q])
+    @students = @search.result.page(params[:page])
+
+    params[:selected_students].nil? ? @selected_students = [] : @selected_students = params[:selected_students]
+
+    # Example: @enrolled_students = @class_group.students.map {|i| i.id.to_s }
+    @enrolled_students = instance_variable_get("@#{class_name_underscored}").students.map {|i| i.id.to_s }
+  end
+
+  def set_collection
+    # Example: @class_groups = class_name.constantize.all
+    instance_variable_set("@#{class_name_underscored_plural}", class_name.constantize.all)
+  end
+
+  def set_resource
+    # Example: @class_group = class_name.constantize.find(params[:id])
+    instance_variable_set("@#{class_name_underscored}", class_name.constantize.find(params[:id]))
+  end
+
+end

data/app/controllers/gaku/addresses_controller.rb

@@ -0,0 +1,94 @@
+module Gaku
+  class AddressesController < GakuController
+
+    include PolymorphicResourceConcern
+
+    respond_to :js
+
+    before_action :set_countries,        only: %i( new edit )
+    before_action :set_unscoped_address, only: %i( recovery destroy )
+    before_action :set_address,          only: %i( edit update soft_delete make_primary )
+    before_action :set_polymorphic_resource
+
+    def new
+      @address = Address.new
+      respond_with @address
+    end
+
+    def create
+      @address = @polymorphic_resource.addresses.new(address_params)
+      @address.save
+      set_count
+      respond_with @address
+    end
+
+    def edit
+    end
+
+    def update
+      @address.update(address_params)
+      respond_with @address
+    end
+
+    def make_primary
+      @address.make_primary
+      respond_with @address
+    end
+
+    def recovery
+      @address.recover
+      respond_with @address
+    end
+
+    def destroy
+      if @address.destroy
+        @polymorphic_resource.addresses.first.try(:make_primary) if @address.primary?
+      end
+      set_count
+      respond_with @address
+    end
+
+    def soft_delete
+      @primary_address = true if @address.primary?
+      @address.soft_delete
+      @poymorphic_resource.addresses.first.try(:make_primary) if @address.primary?
+      set_count
+      respond_with @address
+    end
+
+    private
+
+    def address_params
+      params.require(:address).permit(attributes)
+    end
+
+    def attributes
+      %i( title country_id state_id zipcode state_name city address1 address2 )
+    end
+
+    def resource_klass
+      'address'
+    end
+
+    def polymorphic_klasses
+      [Gaku::Student, Gaku::Campus, Gaku::Guardian, Gaku::Teacher]
+    end
+
+    def set_countries
+      @countries = Country.all
+    end
+
+    def set_address
+      @address = Address.find(params[:id])
+    end
+
+    def set_unscoped_address
+      @address = Address.unscoped.find(params[:id])
+    end
+
+    def set_count
+      @count = @polymorphic_resource.reload.addresses_count
+    end
+
+  end
+end

data/app/controllers/gaku/attachments_controller.rb

@@ -0,0 +1,90 @@
+module Gaku
+  class AttachmentsController < GakuController
+
+    before_action :set_attachment, only: %i( show edit update soft_delete download )
+    before_action :set_unscoped_attachment, only: %i( recovery destroy )
+    respond_to :js, :html
+
+    # TODO: merge and refactor two controllers
+
+    def new
+      @attachment = Attachment.new
+      respond_with @attachment
+    end
+
+
+    def create
+      @attachable = find_attachable
+      @attachment = @attachable.attachments.build(params[:attachment])
+      respond_to do |format|
+        if @attachment.save
+          format.html { redirect_to :back, flash: { notice: 'Asset upload was successful!' } }
+        else
+          format.html { redirect_to :back, flash: {success: 'Error when upload asset'} }
+        end
+      end
+    end
+
+    def edit
+      respond_with @attachment
+    end
+
+    def update
+      @attachment.update(attachment_params)
+      respond_with(@attachment) do |format|
+        format.html { redirect_to :back }
+      end
+    end
+
+    def destroy
+      @attachment.destroy!
+      respond_with @attachment
+    end
+
+    def soft_delete
+      @attachment.soft_delete
+      respond_with @attachment
+    end
+
+    def download
+      @attachment = Attachment.find(params[:id])
+      send_file @attachment.asset.path
+    end
+
+    def recovery
+      @attachment.recover
+      respond_with @attachment
+    end
+
+    def attachment_params
+      params.require(:attachment).permit(attachment_attr)
+    end
+
+    private
+
+
+    def attachment_attr
+      [:name, :description, :asset]
+    end
+
+    def set_attachment
+      @attachment = Attachment.find(params[:id])
+    end
+
+    def set_unscoped_attachment
+      @attachment = Attachment.unscoped.find(params[:id])
+    end
+
+    def find_attachable
+      # unnamespaced_klass = ''
+      # klass = [Gaku::Student, Gaku::LessonPlan, Gaku::Syllabus, Gaku::ClassGroup, Gaku::Course, Gaku::Exam].detect 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 = @notable.class.to_s.underscore.split('/')[1].gsub("_","-")
+    end
+
+  end
+end

data/app/controllers/gaku/attendances_controller.rb

@@ -0,0 +1,28 @@
+module Gaku
+  class AttendancesController < GakuController
+
+    respond_to :js, :json, only: %i( create show )
+
+    def create
+      exam_portion_score = ExamPortionScore.find(params[:exam_portion_score_id])
+      @attendance = exam_portion_score.attendances.build(
+                      student_id: exam_portion_score.student_id,
+                      attendance_type_id: params[:attendance][:attendance_type_id],
+                      reason: params[:attendance][:reason])
+      if @attendance.save
+        respond_with(@attendance) do |format|
+          format.json { render json: @attendance.to_json(root: false, include: :attendance_type) }
+        end
+      end
+    end
+
+    def show
+      super do |format|
+        format.json do
+          render json: @attendance.as_json(root: false, include: :attendance_type)
+        end
+      end
+    end
+
+  end
+end

data/app/controllers/gaku/class_group_enrollments_controller.rb

@@ -0,0 +1,15 @@
+module Gaku
+  class ClassGroupEnrollmentsController < GakuController
+
+  load_and_authorize_resource :class_group_enrollment,
+                              class: Gaku::ClassGroupEnrollment
+
+  include EnrollmentsController
+
+
+  def create
+    @enrollment = ClassGroupEnrollment.create(params[:class_group_enrollment])
+  end
+
+  end
+end

data/app/controllers/gaku/class_groups/courses_controller.rb

@@ -0,0 +1,50 @@
+module Gaku
+  class ClassGroups::CoursesController < GakuController
+
+    respond_to :js, only: %i( new create destroy )
+
+    before_action :set_class_group
+    before_action :set_enrollment, only: %i( destroy )
+
+    def new
+      @class_group_course_enrollment = ClassGroupCourseEnrollment.new
+    end
+
+    def create
+      @class_group_course_enrollment = ClassGroupCourseEnrollment.new(class_group_course_enrollment_params)
+      @class_group_course_enrollment.save
+      set_count
+      respond_with @class_group_course_enrollment
+    end
+
+    def destroy
+      @class_group_course_enrollment.destroy
+      set_count
+      respond_with @class_group_course_enrollment
+    end
+
+
+    private
+
+    def class_group_course_enrollment_params
+      params.require(:class_group_course_enrollment).permit(attributes)
+    end
+
+    def attributes
+      %i( course_id class_group_id )
+    end
+
+    def set_enrollment
+      @class_group_course_enrollment = ClassGroupCourseEnrollment.find(params[:id])
+    end
+
+    def set_class_group
+      @class_group = ClassGroup.find(params[:class_group_id])
+    end
+
+    def set_count
+      @count = @class_group.courses.count
+    end
+
+  end
+end

data/app/controllers/gaku/class_groups/semester_class_groups_controller.rb

@@ -0,0 +1,63 @@
+module Gaku
+  class ClassGroups::SemesterClassGroupsController < GakuController
+
+    respond_to :js, only: %i( new create edit update destroy )
+
+    before_action :set_class_group
+    before_action :set_semester_class_group, only: %i( edit update destroy )
+    before_action :set_semesters, only: %i( new edit )
+
+    def new
+      @semester_class_group = SemesterClassGroup.new
+    end
+
+    def create
+      @semester_class_group = @class_group.semester_class_groups.build(semester_class_group_params)
+      @semester_class_group.save
+      set_count
+      respond_with @semester_class_group, alert: t(:'semester_class_group.uniqueness')
+    end
+
+    def edit
+    end
+
+    def update
+      @semester_class_group.update(semester_class_group_params)
+      respond_with @semester_class_group
+    end
+
+    def destroy
+      @semester_class_group.destroy
+      set_count
+      respond_with @semester_class_group
+    end
+
+    private
+
+    def semester_class_group_params
+      params.require(:semester_class_group).permit(attributes)
+    end
+
+    def attributes
+      %i( semester_id )
+    end
+
+    def set_semesters
+      @semesters = Semester.all
+    end
+
+    def set_class_group
+      @class_group =  ClassGroup.find(params[:class_group_id])
+    end
+
+    def set_semester_class_group
+      #@semester_class_group =  SemesterClassGroup.find(params[:id])
+      @semester_class_group =  @class_group.semester_class_groups.find(params[:id])
+    end
+
+    def set_count
+      @count = @class_group.semesters.count
+    end
+
+  end
+end

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

@@ -0,0 +1,37 @@
+module Gaku
+  class ClassGroups::StudentsController < GakuController
+
+    respond_to :js, only: %i( new destroy enroll_student )
+
+    def new
+      @class_group = ClassGroup.find(params[:class_group_id])
+      @students = Student.includes([:addresses, :class_groups, :class_group_enrollments]).all
+    end
+
+    def enroll_student
+      unless params[:student_ids].blank?
+        @class_group = ClassGroup.find(params[:class_group_enrollment][:class_group_id])
+        student_ids = params[:student_ids].split(',')
+        enroll_student_ids(student_ids)
+      end
+    end
+
+    def destroy
+      @class_group_enrollment = ClassGroupEnrollment.find(params[:class_group_enrollment])
+      @class_group = ClassGroup.find(@class_group_enrollment.class_group_id)
+      @class_group_enrollment.destroy
+    end
+
+    private
+
+    def enroll_student_ids(student_ids)
+      @students = []
+      student_ids.each  do |student_id|
+        student = Student.find(student_id)
+        enrollment = ClassGroupEnrollment.create!(class_group_id: params[:class_group_enrollment][:class_group_id], student_id: student.id)
+        @students << enrollment.student
+      end
+    end
+
+  end
+end