gaku_core 0.0.3 → 0.1.0

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

@@ -1,49 +0,0 @@
-[module Gaku
-  class Students::StudentAchievementsController < GakuController
-
-    #load_and_authorize_resource :student, class: Gaku::Student
-    #load_and_authorize_resource :achievement, through: :student, class: Gaku::Achievement
-    skip_authorization_check
-
-    inherit_resources
-    belongs_to :student
-    respond_to :js, :html, :json
-
-    before_filter :student
-    before_filter :student_achievements, only: [:update]
-    before_filter :count, only: [:index, :create, :destroy]
-    before_filter :load_data
-
-    def index
-      @student_achievements = @student.student_achievements
-      respond_with @student_achievements
-    end
-
-    protected
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:student_achievement).permit(:achievement_id)]
-    end
-
-    private
-
-    def load_data
-      @achievements = Achievement.all.map { |s| [s.name, s.id] }
-    end
-
-    def student
-      @student = Student.find(params[:student_id])
-    end
-
-    def student_achievements
-      @student_achievements = @student.student_achievements
-    end
-
-    def count
-      @count = @student.student_achievements.count
-    end
-
-  end
-end
-]

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

@@ -1,60 +0,0 @@
-module Gaku
-  class Students::StudentSpecialtiesController < GakuController
-
-    #load_and_authorize_resource :student, class: Gaku::Student
-    #load_and_authorize_resource :specialty, through: :student, class: Gaku::Specialty
-    skip_authorization_check
-
-    inherit_resources
-    belongs_to :student
-    respond_to :js, :html
-
-    before_filter :load_data
-    before_filter :student
-    before_filter :student_specialties, only: :update
-    before_filter :count, only: [:index, :create, :destroy, :update]
-
-
-    def index
-      @student_specialties = @student.student_specialties
-      respond_with @student_specialties
-    end
-
-    def destroy
-      super do |format|
-        format.js { render }
-      end
-    end
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:student_specialty).permit(student_specialty_attr)]
-    end
-
-    private
-
-    def student_specialty_attr
-      %i(specialty_id major)
-    end
-
-    private
-
-    def load_data
-      @specialties = Gaku::Specialty.all.map { |s| [s.name, s.id] }
-    end
-
-    def student
-      @student = Student.find(params[:student_id])
-    end
-
-    def student_specialties
-      student
-      @student_specialties = @student.student_specialties
-    end
-
-    def count
-      @count = StudentSpecialty.count
-    end
-
-  end
-end

data/app/controllers/gaku/students_controller.rb

@@ -1,189 +0,0 @@
-module Gaku
-  class StudentsController < GakuController
-
-    # load_and_authorize_resource class: Gaku::Student,
-    #                             except: [:recovery, :destroy]
-
-    decorates_assigned :student
-
-    helper_method :sort_column, :sort_direction
-
-    respond_to :js,   only: %i( new create edit update index destroy recovery )
-    respond_to :html, only: %i( index edit show show_deleted soft_delete )
-    respond_to :pdf,  only: %i( index show )
-
-    before_action :load_data,             only: %i( new edit )
-    before_action :set_class_group,       only: %i( index new edit )
-    before_action :set_selected_students, only: %i( create index )
-    before_action :set_student,           only: %i( show edit update soft_delete )
-    before_action :set_unscoped_student,  only: %i( show_deleted destroy recovery )
-
-    def new
-      @student = Student.new
-      respond_with @student
-    end
-
-    def create
-      @student = Student.new(student_params)
-      @student.save
-      @student.make_enrolled if @student.valid?
-      @count = Student.count
-      respond_with @student
-    end
-
-    def index
-      set_index_vars
-      @enrolled_students = params[:enrolled_students]
-
-      @count = Student.count
-
-      @search = Student.active.search(params[:q])
-      results = @search.result(distinct: true)
-      @students = results.order('created_at ASC').page(params[:page])
-
-      respond_with(@students) do |format|
-        format.pdf do
-          send_data render_to_string, filename: 'sido_yoroku.pdf',
-                                      type: 'application/pdf',
-                                      disposition: 'attachment'
-        end
-      end
-    end
-
-
-    def show
-      respond_with @student do |format|
-        format.pdf do
-          send_data render_to_string, filename: "student-#{@student.id}.pdf",
-                                      type: 'application/pdf',
-                                      disposition: 'inline'
-        end
-      end
-    end
-
-    def show_deleted
-      respond_with(@student) do |format|
-        format.html { render :show }
-      end
-    end
-
-    def destroy
-      @student.destroy
-      @count = Student.count
-      respond_with @student
-    end
-
-    def recovery
-      @student.recover
-      flash.now[:notice] = t(:'notice.recovered', resource: t_resource)
-      respond_with @student
-    end
-
-    def soft_delete
-      @student.soft_delete
-      @count = Student.count
-      redirect_to students_path,
-                  notice: t(:'notice.destroyed', resource: t_resource)
-    end
-
-    def update
-      @student.update(student_params)
-      respond_with(@student) do |format|
-        if params[:student][:picture]
-          format.html do
-            redirect_to [:edit, @student],
-                        notice: t(:'notice.uploaded', resource: t(:'picture'))
-          end
-        else
-          format.html { redirect_to [:edit, @student] }
-          format.js   { render }
-          format.json { head :no_content }
-        end
-      end
-    end
-
-    def load_autocomplete_data
-      object = "Gaku::#{params[:class_name].capitalize}".constantize
-      @result = object.order(params[:column].to_sym)
-                      .where(params[:column] + ' like ?', "%#{params[:term]}%")
-      render json: @result.map(&params[:column].to_sym).uniq
-    end
-
-
-    private
-
-    def student_params
-      %i(name surname name_reading surname_reading birth_date gender class_group_ids scholarship_status_id enrollment_status_code commute_method_type_id admitted graduated picture)
-    end
-
-    def student_params
-      params.require(:student).permit(attributes)
-    end
-
-    def attributes
-      %i( name surname name_reading surname_reading birth_date gender class_group_ids scholarship_status_id enrollment_status_code commute_method_type_id admitted graduated picture )
-    end
-
-    def includes
-      [[contacts: :contact_type, addresses: :country], :guardians]
-    end
-
-    def t_resource
-      t(:'student.singular')
-    end
-
-    def set_class_group
-      @class_group_id ||= params[:class_group_id]
-    end
-
-    def set_index_vars
-      @enrollment_statuses = EnrollmentStatus.all.includes(:translations)
-      @countries = Country.all
-      @class_groups = ClassGroup.all
-      @courses = Course.all
-    end
-
-    def load_data
-      @class_groups = ClassGroup.all
-      @enrollment_statuses = EnrollmentStatus.includes(:translations)
-      @scholarship_statuses = ScholarshipStatus.includes(:translations)
-      @commute_method_types = CommuteMethodType.includes(:translations)
-    end
-
-    def set_selected_students
-      if params[:selected_students].nil?
-        @selected_students = []
-      else
-        @selected_students = params[:selected_students]
-      end
-    end
-
-    def set_notable
-      @notable = @student
-      @notable_resource = get_resource_name @notable
-    end
-
-    def set_student
-      @student ||= Student.includes(includes).find(params[:id])
-      set_notable
-    end
-
-    def set_unscoped_student
-      @student ||= Student.includes(includes).unscoped.find(params[:id])
-      set_notable
-    end
-
-    def sort_column
-      Student.column_names.include?(params[:sort]) ? params[:sort] : 'surname'
-    end
-
-    def sort_direction
-      if %w[asc desc].include?(params[:direction])
-        params[:direction]
-      else
-        'asc'
-       end
-    end
-
-  end
-end

data/app/controllers/gaku/syllabuses/assignments_controller.rb

@@ -1,20 +0,0 @@
-module Gaku
-  class Syllabuses::AssignmentsController < GakuController
-
-    before_filter :count, only: :create
-    def create
-      if @syllabus.update_attributes(params[:syllabus])
-        respond_to do |format|
-          format.js { render 'create' }
-        end
-      end
-    end
-
-    private
-
-    def count
-      @count = Syllabus.assignments.count
-    end
-
-  end
-end

data/app/controllers/gaku/syllabuses/exam_syllabuses_controller.rb

@@ -1,38 +0,0 @@
-module Gaku
-  class Syllabuses::ExamSyllabusesController < GakuController
-
-    #authorize_resource class: false
-    #load_and_authorize_resource :syllabus, class: Gaku::Syllabus
-    #load_and_authorize_resource :exam_syllabus, through: :syllabus, class: Gaku::ExamSyllabus
-
-    inherit_resources
-
-    defaults resource_class: ExamSyllabus,
-             instance_name: 'exam_syllabus'
-
-    actions :new, :create, :destroy
-    belongs_to :syllabus, parent_class: Gaku::Syllabus
-    respond_to :js, :html
-
-    before_filter :syllabus
-
-    def create
-      #@exam_syllabus = @syllabus.exams.create(params[:exam_syllabus])
-      create!(notice: t(:'notice.added', resource: t(:'exam.singular')))
-    end
-
-    protected
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:exam_syllabus).permit([:exam_id, :syllabus_id])]
-    end
-
-    private
-
-    def syllabus
-      @syllabus = Syllabus.find(params[:syllabus_id])
-    end
-
-  end
-end

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

@@ -1,53 +0,0 @@
-module Gaku
-  class Syllabuses::ExamsController < GakuController
-
-    load_and_authorize_resource :syllabus, class: Gaku::Syllabus
-    load_and_authorize_resource :exam, through: :syllabus, class: Gaku::Exam
-
-    inherit_resources
-    belongs_to :syllabus, parent_class: Gaku::Syllabus
-    respond_to :js, :html
-
-    before_filter :syllabus
-    before_filter :exam_syllabus, only: :update
-    before_filter :load_data
-
-    def create
-      @exam = @syllabus.exams.create(params[:exam])
-      create!
-    end
-
-    def new
-      @exam = @syllabus.exams.new
-      @exam.exam_portions.build
-      new!
-    end
-
-    protected
-
-    def resource_params
-      return [] if request.get?
-      [params.require(:exam).permit!]
-    end
-
-    private
-
-    def exam_attr
-      [:name, :description, :adjustments, { exam_portions_attributes: [] }]
-    end
-
-    def load_data
-      @grading_methods = GradingMethod.pluck(:name, :id)
-    end
-
-    def syllabus
-      @syllabus = Syllabus.find(params[:syllabus_id])
-    end
-
-    def exam_syllabus
-      @exam_syllabus = ExamSyllabus.find_by(exam_id: params[:id], syllabus_id: params[:syllabus_id])
-    end
-
-
-  end
-end

data/app/controllers/gaku/syllabuses_controller.rb

@@ -1,73 +0,0 @@
-module Gaku
-  class SyllabusesController < GakuController
-
-    #load_and_authorize_resource class: Gaku::Syllabus
-
-    respond_to :js,   only: %i( new create edit update destroy )
-    respond_to :html, only: %i( index edit show )
-
-    before_action :set_syllabus, only: %i( edit update destroy )
-
-    def new
-      @syllabus = Syllabus.new
-      respond_with @syllabus
-    end
-
-    def create
-      @syllabus = Syllabus.new(syllabus_params)
-      @syllabus.save
-      set_count
-      respond_with @syllabus
-    end
-
-    def index
-      @syllabuses = Syllabus.all
-      set_count
-      respond_with @syllabuses
-    end
-
-    def edit
-      set_grading_methods
-      set_notable
-    end
-
-    def update
-      @syllabus.update(syllabus_params)
-      respond_with @syllabus
-    end
-
-    def destroy
-      @syllabus.destroy
-      set_count
-      respond_with @syllabus
-    end
-
-    private
-
-    def syllabus_params
-      params.require(:syllabus).permit(syllabus_attr)
-    end
-
-    def syllabus_attr
-      %i( name code credits description )
-    end
-
-    def set_syllabus
-      @syllabus = Syllabus.find(params[:id])
-    end
-
-    def set_grading_methods
-      @grading_methods = GradingMethod.all
-    end
-
-    def set_notable
-      @notable = @syllabus
-      @notable_resource = get_resource_name @notable
-    end
-
-    def set_count
-      @count = Syllabus.count
-    end
-
-  end
-end

data/app/controllers/gaku/teachers_controller.rb

@@ -1,113 +0,0 @@
-module Gaku
-  class TeachersController < GakuController
-
-    #load_and_authorize_resource :teacher, class: Gaku::Teacher
-
-    decorates_assigned :teacher
-
-    respond_to :js,   only: %i( new create edit update destroy recovery )
-    respond_to :html, only: %i( index edit update show show_deleted soft_delete )
-
-    before_action :set_unscoped_teacher, only: %i( show_deleted destroy recovery )
-    before_action :set_teacher,          only: %i( edit show update soft_delete )
-
-    def recovery
-      @teacher.recover
-      flash.now[:notice] = t(:'notice.recovered', resource: t_resource)
-      respond_with @teacher
-    end
-
-    def soft_delete
-      @teacher.soft_delete
-      redirect_to teachers_path,
-                  notice: t(:'notice.destroyed', resource: t_resource)
-    end
-
-    def destroy
-      @teacher.destroy
-      set_count
-      respond_with @teacher
-    end
-
-    def show_deleted
-      respond_with(@teacher) do |format|
-        format.html { render :show }
-      end
-    end
-
-    def new
-      @teacher = Teacher.new
-      respond_with @teacher
-    end
-
-    def create
-      @teacher = Teacher.new(teacher_params)
-      @teacher.save
-      set_count
-      respond_with @teacher
-    end
-
-    def edit
-    end
-
-    def show
-    end
-
-    def update
-      @teacher.update(teacher_params)
-      respond_with(@teacher) do |format|
-        if params[:teacher][:picture]
-          format.html do
-            redirect_to @teacher,
-                        notice: t(:'notice.uploaded', resource: t(:'picture'))
-          end
-        else
-          format.js { render }
-          format.html { redirect_to [:edit, @teacher] }
-        end
-      end
-    end
-
-    def index
-      @search = Teacher.search(params[:q])
-      results = @search.result(distinct: true)
-      @teachers = results.page(params[:page]).per(Preset.teachers_per_page)
-      set_count
-      respond_with @teachers
-    end
-
-    private
-
-    def teacher_params
-      params.require(:teacher).permit(attributes)
-    end
-
-    def attributes
-      %i(name surname name_reading surname_reading birth_date gender picture)
-    end
-
-    def set_teacher
-      @teacher = Teacher.find(params[:id])
-      set_notable
-    end
-
-    def set_unscoped_teacher
-      @teacher = Teacher.unscoped.find(params[:id])
-      set_notable
-    end
-
-    def t_resource
-      t(:'teacher.singular')
-    end
-
-    def set_notable
-      @notable = @teacher
-      @notable_resource = get_resource_name @notable
-    end
-
-    def set_count
-      @count = Teacher.count
-    end
-
-  end
-end

data/app/helpers/gaku/autocomplete_helper.rb

@@ -1,31 +0,0 @@
-module Gaku::AutocompleteHelper
-
-  def autocomplete_text_field(form, options = {})
-    content_tag :div, class: 'span3' do
-      concat form.label options[:object_name], options[:tag_name]
-      concat form.text_field options[:object_name],
-                             class: 'js-autocomplete span12',
-                             data: { autocomplete_source: load_autocomplete_data_students_path(class_name: options[:class_name], column: options[:column]) }
-    end
-  end
-
-  def autocomplete_date_field(form, options = {})
-    content_tag :div, class: 'span3' do
-      concat form.label options[:object_name], options[:tag_name]
-      concat form.text_field options[:object_name], class: 'span12', placeholder: t(:'date.placeholder')
-    end
-  end
-
-  def autocomplete_select(form, options = {})
-    content_tag :div, class: 'span3' do
-      concat form.label options[:object_name], options[:tag_name]
-      concat form.select  options[:object_name],
-                          options[:collection],
-                          { prompt: options[:prompt],
-                            selected: options[:selected]
-                          },
-                          options[:html_options]
-    end
-  end
-
-end

data/app/helpers/gaku/count_helper.rb

@@ -1,13 +0,0 @@
-module Gaku::CountHelper
-
-  def count_div(html_class, &block)
-    content_tag :h4, class: "mt-xs mb-0 #{html_class}" do
-      block.call
-    end
-  end
-
-  def print_count(count, text)
-    count != 0 ? text + '(' + count.to_s + ')' : text
-  end
-
-end

data/app/helpers/gaku/flash_helper.rb

@@ -1,16 +0,0 @@
-module Gaku::FlashHelper
-
-  def flash_color(type)
-    case type
-      when :notice then 'alert alert-info'
-      when :success then 'alert alert-success'
-      when :error then 'alert alert-error'
-      when :alert then 'alert alert-error'
-    end
-  end
-
-  def render_flash
-    escape_javascript(render 'gaku/shared/flash', flash: flash)
-  end
-
-end