gaku_core 0.0.1

data/app/controllers/gaku/extracurricular_activity_enrollments_controller.rb

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

data/app/controllers/gaku/gaku_controller.rb

@@ -0,0 +1,93 @@
+module Gaku
+  class GakuController < ActionController::Base
+    protect_from_forgery
+    #check_authorization
+
+    self.responder = AppResponder
+    respond_to :html
+
+    rescue_from CanCan::AccessDenied do |exception|
+      redirect_to root_url, alert: exception.message
+    end
+
+    before_filter :set_locale
+    before_filter :users_check
+
+    layout :resolve_layout
+
+
+    helper_method :preset
+
+    def user_for_paper_trail
+      user_signed_in? ? current_user : 'Public user'  # or whatever
+    end
+
+    def preset(name)
+      Gaku::Preset.get(name)
+    end
+
+    protected
+
+    def get_resource_name(object)
+      object.class.to_s.underscore.split('/')[1].gsub('_', '-')
+    end
+
+    def get_class(object)
+      object.class.to_s.underscore.dasherize.split('/').last
+    end
+
+    private
+
+    def current_ability
+      @current_ability ||= Gaku::Ability.new(current_user)
+    end
+
+    def resolve_layout
+      case action_name
+      when 'index'
+        'gaku/layouts/index'
+      when 'show'
+        'gaku/layouts/show'
+      when 'edit'
+        'gaku/layouts/edit'
+      else
+        'gaku/layouts/gaku'
+      end
+    end
+
+    def set_locale
+      if current_user && params[:locale]
+        I18n.locale = params[:locale]
+        current_user.settings[:locale] = params[:locale]
+        notice = "Language is set to #{t('languages.' + current_user.locale)}"
+        flash[:notice] = notice if current_user.save
+      elsif current_user
+        I18n.locale = current_user.settings[:locale]
+      else
+        I18n.default_locale
+      end
+    end
+
+    def users_check
+      if User.count == 0
+        redirect_to set_up_admin_account_path
+      end
+    end
+
+    def extract_locale_from_accept_language_header
+      request.env['HTTP_ACCEPT_LANGUAGE'].scan(/^[a-z]{2}/).first
+    end
+
+    def after_sign_in_path_for(resource_or_scope)
+      unless current_user.settings[:locale].blank?
+        I18n.locale = current_user.settings[:locale]
+      end
+      super
+    end
+
+    def after_sign_out_path_for(resource_or_scope)
+      root_path
+    end
+
+  end
+end

data/app/controllers/gaku/home_controller.rb

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

@@ -0,0 +1,72 @@
+module Gaku
+  class NotesController < GakuController
+
+    load_and_authorize_resource :note, class: Gaku::Note
+
+    before_filter :notable
+    inherit_resources
+    respond_to :js, :html
+
+    def new
+      @note = @notable.notes.new
+      new!
+    end
+
+    def create
+      @note = @notable.notes.new(note_params)
+      create!
+    end
+
+    protected
+
+    # def begin_of_association_chain
+    #   notable
+    #   @notable.notes
+    # end
+
+    def note_params
+      params.require(:note).permit(note_attr)
+    end
+
+    def resource_params
+      return [] if request.get?
+      [params.require(:note).permit(note_attr)]
+    end
+
+    private
+
+    def note_attr
+      %i(title content)
+    end
+
+    def collection
+      @notes = @notable.notes
+    end
+
+    private
+
+    def notable_klasses
+      [
+        Gaku::Student,
+        Gaku::Teacher,
+        Gaku::LessonPlan,
+        Gaku::Syllabus,
+        Gaku::ClassGroup,
+        Gaku::Course,
+        Gaku::Exam
+      ]
+    end
+
+    def 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

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

data/app/controllers/gaku/states_controller.rb

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

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

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

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

@@ -0,0 +1,75 @@
+# -*- encoding: utf-8 -*-
+require 'GenSheet'
+module Gaku
+  class Students::ImporterController < GakuController
+
+    skip_authorization_check
+    before_action :load_templates, only: :index
+
+    def index
+      @importer_types = {I18n.t('student.roster_sheet') => :import_roster, 'School Station' => :import_school_station_zaikousei}
+      # render 'gaku/students/importer/index'
+    end
+
+    def get_roster
+      template = Template.find(params[:template][:id])
+      #read file from paperclip obejct
+      source_file = File.new(template.file.path)
+      #process with GenSheet
+      sheet = GenSheet.new(source_file).to_xls
+
+      send_file sheet
+    end
+
+    def get_registration_roster
+      exporter = Gaku::Exporters::RosterExporter.new
+      file = exporter.export({})
+    end
+
+    def create
+      redirect_to importer_index_path, alert: I18n.t('errors.messages.file_unreadable') && return if params[:importer][:data_file].nil?
+      file = ImportFile.new(import_params)
+      file.context = 'students'
+      raise 'COULD NOT SAVE FILE' unless file.save
+
+      case params[:importer][:importer_type]
+      when 'import_roster'
+        import_roster(file)
+      when 'import_school_station_zaikousei'
+        import_school_station_zaikousei(file)
+      end
+    end
+
+    private
+
+    def import_params
+      params.require(:importer).permit(:data_file, :importer_type)
+    end
+
+    def load_templates
+      @templates ||= Template.all
+    end
+
+
+    def import_roster(file)
+      if file.data_file.content_type == 'application/vnd.ms-excel' ||
+          file.data_file.content_type == 'application/vnd.oasis.opendocument.spreadsheet' ||
+          file.data_file.content_type == 'application/xls'
+        Gaku::Importers::Students::RosterWorker.perform_async(file.id)
+        render text: 'Importing Roster'
+      else
+        redirect_to importer_index_path, alert: '[' + file.data_file.content_type + '] ' + I18n.t('errors.messages.file_type_unsupported')
+      end
+    end
+
+    def import_school_station_zaikousei(file)
+      if file.data_file.content_type == 'application/vnd.ms-excel'
+        Gaku::Importers::Students::SchoolStationZaikouseiWorker.perform_async(file.id)
+        render text: '在校生をSchoolStationからインポート中。'
+      else
+        redirect_to importer_index_path, alert: I18n.t('errors.messages.file_type_unsupported')
+      end
+    end
+
+  end
+end