gaku_core 0.0.3 → 0.1.0

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

@@ -1,43 +0,0 @@
-module Gaku
-  class ClassGroups::StudentsController < GakuController
-
-    load_and_authorize_resource :class_group, class: ClassGroup
-    load_and_authorize_resource :student,
-                                through: :class_group,
-                                class: Student
-
-    inherit_resources
-    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

data/app/controllers/gaku/class_groups_controller.rb

@@ -1,59 +0,0 @@
-module Gaku
-  class ClassGroupsController < GakuController
-
-    include StudentChooserController
-
-    load_and_authorize_resource class:  ClassGroup
-
-    respond_to :js, :html
-
-    helper_method :sort_column, :sort_direction
-
-    inherit_resources
-
-    before_filter :load_data
-    before_filter :load_before_show, only: :show
-    before_filter :count, only: %i(create destroy index)
-
-    def index
-      @class_groups = SemesterClassGroup.group_by_semester
-      @class_groups_without_semester = ClassGroup.without_semester
-    end
-
-    protected
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:class_group).permit(attributes)]
-    end
-
-    private
-
-    def attributes
-      %i(name grade homeroom)
-    end
-
-    def load_data
-      @courses = Course.includes(:syllabus).map { |c| [c, c.id] }
-    end
-
-    def load_before_show
-      @notable = ClassGroup.find(params[:id])
-      @notable_resource = get_resource_name(@notable)
-      @class_group_course_enrollment = ClassGroupCourseEnrollment.new
-    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
-
-    def count
-      @count = ClassGroup.count
-    end
-
-  end
-end

data/app/controllers/gaku/contacts_controller.rb

@@ -1,103 +0,0 @@
-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_unscoped_contact, only: %i( recovery destroy )
-    before_action :set_contact,          only: %i( edit update soft_delete 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
-      flash.now[:notice] = t(:'notice.destroyed', resource: t_resource)
-      set_count
-      respond_with @contact
-    end
-
-    def recovery
-      @contact.recover
-      flash.now[:notice] = t(:'notice.recovered', resource: t_resource)
-      respond_with @contact
-    end
-
-    def soft_delete
-      @primary_contact = true if @contact.primary?
-      @contact.soft_delete
-      @polymorphic_resource.contacts.first.try(:make_primary) if @contact.primary?
-      flash.now[:notice] = t(:'notice.destroyed', resource: t_resource)
-      set_count
-      respond_with @contact
-    end
-
-    def make_primary
-      @contact.make_primary
-      respond_with @contact
-    end
-
-    private
-
-    def set_unscoped_contact
-      @contact = Contact.unscoped.find(params[:id])
-    end
-
-    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 t_resource
-      t(:'contact.singular')
-    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

@@ -1,10 +0,0 @@
-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

@@ -1,50 +0,0 @@
-module Gaku
-  class CourseGroups::CourseGroupEnrollmentsController < GakuController
-
-    load_and_authorize_resource :course_group_enrollment,
-                                class: 'Gaku::CourseGroupEnrollment'
-
-    inherit_resources
-    respond_to :js, only: %i( new create destroy )
-
-    before_filter :course_group, only: %i( new create destroy )
-    before_filter :count,        only: %i( create destroy )
-
-    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'))
-        respond_with @course_group_enrollment
-      else
-        render :error
-      end
-    end
-
-    protected
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:course_group_enrollment).permit(course_group_enrollment_attr)]
-    end
-
-    private
-
-    def course_group_enrollment_attr
-      %i(course_id course_group_id)
-    end
-
-    def course_group_enrollment_params
-      params.require(:course_group_enrollment).permit(course_group_enrollment_attr)
-    end
-
-    def course_group
-      @course_group = CourseGroup.find(params[:course_group_id])
-    end
-
-    def count
-      course_group
-      @count = @course_group.courses.count
-    end
-
-  end
-end

data/app/controllers/gaku/course_groups_controller.rb

@@ -1,81 +0,0 @@
-module Gaku
-  class CourseGroupsController < GakuController
-
-    load_and_authorize_resource class: Gaku::CourseGroup
-
-    helper_method :sort_column, :sort_direction
-
-    inherit_resources
-    #actions :show, :new, :create, :update, :edit, :destroy
-    respond_to :js, :html
-
-    before_filter :before_show,  only: [:show]
-    before_filter :count, only: [:create, :destroy, :index]
-    before_filter :unscoped_course_group, only: :destroy
-    before_filter :load_data
-
-    def index
-      @course_groups = CourseGroup.order(sort_column + ' ' + sort_direction)
-    end
-
-    def soft_delete
-      @course_group = CourseGroup.find(params[:id])
-      @course_group.update_attribute(:deleted, true)
-      redirect_to course_groups_path,
-                  notice: t(:'notice.destroyed', resource: t_resource)
-    end
-
-    def recovery
-      unscoped_course_group
-      @course_group.update_attribute(:deleted, false)
-      @course_groups = CourseGroup.where(deleted: true)
-      flash.now[:notice] = t(:'notice.recovered', resource: t_resource)
-      respond_to do |format|
-        format.js { render :recovery }
-      end
-    end
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:course_group).permit(course_group_attr)]
-    end
-
-    private
-
-    def course_group_attr
-      %i(name code)
-    end
-
-    private
-
-    def t_resource
-      t(:'course_group.singular')
-    end
-
-    def unscoped_course_group
-      @course_group = CourseGroup.unscoped.find(params[:id])
-    end
-
-    def load_data
-      @courses = Course.includes(:syllabus).map { |c| [c, c.id] }
-    end
-
-    def before_show
-      @course_group_enrollment = CourseGroupEnrollment.new
-      @courses = Course.all
-    end
-
-    def 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

@@ -1,55 +0,0 @@
-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/semester_courses_controller.rb

@@ -1,37 +0,0 @@
-module Gaku
-  class Courses::SemesterCoursesController < GakuController
-
-    load_and_authorize_resource :course, class: Gaku::Course
-    # load_and_authorize_resource :semester, through: :class_group, class: Gaku::Semester
-
-    inherit_resources
-    respond_to :js, :html
-    belongs_to :course, parent_class: Gaku::Course
-
-    before_filter :count, only: [:create, :destroy]
-    before_filter :load_data
-
-    protected
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:semester_course).permit(semester_course_attr)]
-    end
-
-    private
-
-    def semester_course_attr
-      %i(semester_id)
-    end
-
-    def count
-      course = Course.find(params[:course_id])
-      @count = course.semesters.count
-    end
-
-    def load_data
-      @semesters = Semester.all.map { |s| [s.to_s, s.id] }
-    end
-
-  end
-end

data/app/controllers/gaku/courses_controller.rb

@@ -1,73 +0,0 @@
-module Gaku
-  class CoursesController < GakuController
-
-    load_and_authorize_resource class: Gaku::Course
-
-    include StudentChooserController
-
-    helper_method :sort_column, :sort_direction
-
-    inherit_resources
-    respond_to :js, :html
-
-    before_filter :before_show,  only: :show
-    before_filter :count,        only: [:create, :destroy, :index]
-    before_filter :load_data
-
-    def index
-      @courses = SemesterCourse.group_by_semester
-      @courses_without_semester = Course.without_semester
-    end
-
-    def show
-      super do |format|
-        format.json { render json: @course.as_json(include: :students) }
-      end
-    end
-
-    protected
-
-    def collection
-      @courses = Course.includes(:syllabus).all
-    end
-
-    def resource
-      @course = Course.includes(syllabus: {exams: :exam_portion_scores})
-                      .find(params[:id])
-    end
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:course).permit(course_attr)]
-    end
-
-    private
-
-    def course_attr
-      %i(syllabus_id code)
-    end
-
-    def load_data
-      @syllabuses = Syllabus.all.map { |s| [s.name, s.id] }
-    end
-
-    def count
-      @count = Course.count
-    end
-
-    def before_show
-      @notable = Course.find(params[:id])
-      @notable_resource = get_resource_name(@notable)
-      @class_groups = ClassGroup.all.map { |s| [s.name, s.id] }
-    end
-
-    def sort_column
-      Student.column_names.include?(params[:sort]) ? params[:sort] : 'surname'
-    end
-
-    def sort_direction
-      %w[asc desc].include?(params[:direction]) ? params[:direction] : 'asc'
-    end
-
-  end
-end

data/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/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/app/controllers/gaku/devise/sessions_controller.rb

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

data/app/controllers/gaku/exam_portion_scores_controller.rb

@@ -1,18 +0,0 @@
-module Gaku
-  class ExamPortionScoresController < GakuController
-    inherit_resources
-
-    respond_to :js, :json, :html
-
-    def update
-      @exam_portion_score = ExamPortionScore.find(params[:id])
-      if @exam_portion_score.update_attributes(params[:exam_portion_score])
-        respond_to do |format|
-          format.js { render nothing: true }
-        end
-      else
-        #render :edit
-      end
-    end
-  end
-end

data/app/controllers/gaku/exams/exam_portions/attachments_controller.rb

@@ -1,53 +0,0 @@
-module Gaku
-  class Exams::ExamPortions::AttachmentsController < GakuController
-
-    respond_to :js, :html
-    inherit_resources
-    actions :index, :show, :new, :create, :update, :edit, :destroy
-
-    before_filter :exam, only: [:new, :create]
-    before_filter :exam_portion, only: [:new, :create,  :index]
-    before_filter :count, only: :index
-
-
-    def create
-      @attachment = @exam_portion.attachments.build(attachment_params)
-      respond_to do |format|
-        if @attachment.save
-          format.html { redirect_to [@exam, @exam_portion], notice: t(:'notice.uploaded', resource: t(:'attachment.singular') ) }
-        else
-          format.html { redirect_to [@exam, @exam_portion], flash: {error: t(:'errors.not_uploaded', resource: t(:'attachment.singular')) } }
-        end
-      end
-    end
-
-    protected
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:attachment).permit(attachment_attr)]
-    end
-
-    private
-
-    def attachment_attr
-      [:name, :description, :asset]
-    end
-
-    def attachment_params
-      params.require(:attachment).permit(attachment_attr)
-    end
-
-    def exam
-      @exam = Exam.find(params[:exam_id])
-    end
-
-    def exam_portion
-      @exam_portion = ExamPortion.find(params[:id] || params[:exam_portion_id])
-    end
-
-    def count
-      @count = @exam_portion.attachments.count
-    end
-  end
-end