enju_leaf 1.2.0.beta.1 → 1.2.0.beta.2

data/app/controllers/concerns/enju_leaf/controller.rb

@@ -1,225 +0,0 @@
-module EnjuLeaf
-  module Controller
-    extend ActiveSupport::Concern
-
-    included do
-      before_action :get_library_group, :set_locale, :set_available_languages, :set_mobile_request
-      before_action :store_current_location, unless: :devise_controller?
-      rescue_from Pundit::NotAuthorizedError, with: :render_403
-      #rescue_from ActiveRecord::RecordNotFound, with: :render_404
-      rescue_from Errno::ECONNREFUSED, with: :render_500_nosolr
-      #rescue_from ActionView::MissingTemplate, with: :render_404_invalid_format
-    end
-
-    private
-
-    def render_403
-      return if performed?
-      if user_signed_in?
-        respond_to do |format|
-          format.html {render template: 'page/403', status: 403}
-          #format.html.phone {render template: 'page/403', status: 403}
-          format.xml {render template: 'page/403', status: 403}
-          format.json { render text: '{"error": "forbidden"}' }
-          format.rss {render template: 'page/403.xml', status: 403}
-        end
-      else
-        respond_to do |format|
-          format.html { redirect_to main_app.new_user_session_url }
-          #format.html.phone { redirect_to new_user_session_url }
-          format.xml { render template: 'page/403', status: 403 }
-          format.json { render text: '{"error": "forbidden"}' }
-          format.rss { render template: 'page/403.xml', status: 403 }
-        end
-      end
-    end
-
-    def render_404
-      return if performed?
-      respond_to do |format|
-        format.html { render template: 'page/404', status: 404 }
-        #format.html.phone { render template: 'page/404', status: 404 }
-        format.xml { render template: 'page/404', status: 404 }
-        format.json { render text: '{"error": "not_found"}' }
-        format.rss { render template: 'page/404.xml', status: 404 }
-      end
-    end
-
-    def render_404_invalid_format
-      return if performed?
-      render file: "#{Rails.root}/public/404", formats: [:html]
-    end
-
-    def render_500
-      return if performed?
-      respond_to do |format|
-        format.html {render file: "#{Rails.root}/public/500", layout: false, status: 500}
-        #format.html.phone {render file: "#{Rails.root}/public/500", layout: false, status: 500}
-        format.xml {render template: 'page/500', status: 500}
-        format.json { render text: '{"error": "server_error"}' }
-        format.xml {render template: 'page/500.xml', status: 500}
-      end
-    end
-
-    def render_500_nosolr
-      Rails.logger.fatal("please confirm that the Solr is running.")
-      return if performed?
-      #flash[:notice] = t('page.connection_failed')
-      respond_to do |format|
-        format.html {render template: "page/500_nosolr", layout: false, status: 500}
-        #format.html.phone {render template: "page/500_nosolr", layout: false, status: 500}
-        format.xml {render template: 'page/500', status: 500}
-        format.json { render text: '{"error": "server_error"}' }
-        format.xml {render template: 'page/500.xml', status: 500}
-      end
-    end
-
-    def after_sign_in_path_for(resource)
-      session[:locale] = nil
-      super
-    end
-
-    def set_locale
-      if params[:locale]
-        unless I18n.available_locales.include?(params[:locale].to_s.intern)
-          raise InvalidLocaleError
-        end
-      end
-      if user_signed_in?
-        locale = params[:locale] || session[:locale] || current_user.profile.try(:locale).try(:to_sym)
-      else
-        locale = params[:locale] || session[:locale]
-      end
-      if locale
-        I18n.locale = @locale = session[:locale] = locale.to_sym
-      else
-        I18n.locale = @locale = session[:locale] = I18n.default_locale
-      end
-    rescue InvalidLocaleError
-      @locale = I18n.default_locale
-    end
-
-    def default_url_options(options={})
-      {locale: nil}
-    end
-
-    def set_available_languages
-      if Rails.env == 'production'
-        @available_languages = Rails.cache.fetch('available_languages'){
-          Language.where(iso_639_1: I18n.available_locales.map{|l| l.to_s}).select([:id, :iso_639_1, :name, :native_name, :display_name, :position]).all
-        }
-      else
-        @available_languages = Language.where(iso_639_1: I18n.available_locales.map{|l| l.to_s})
-      end
-    end
-
-    def reset_params_session
-      session[:params] = nil
-    end
-
-    def not_found
-      raise ActiveRecord::RecordNotFound
-    end
-
-    def access_denied
-      raise Pundit::NotAuthorizedError
-    end
-
-    def get_user
-      @user = User.where(username: params[:user_id]).first if params[:user_id]
-      #authorize! :show, @user if @user
-    end
-
-    def get_user_group
-      @user_group = UserGroup.find(params[:user_group_id]) if params[:user_group_id]
-    end
-
-    def convert_charset
-      case params[:format]
-      when 'csv'
-        return unless LibraryGroup.site_config.settings[:csv_charset_conversion]
-        # TODO: 他の言語
-        if @locale.to_sym == :ja
-          headers["Content-Type"] = "text/csv; charset=Shift_JIS"
-          response.body = NKF::nkf('-Ws', response.body)
-        end
-      when 'xml'
-        if @locale.to_sym == :ja
-          headers["Content-Type"] = "application/xml; charset=Shift_JIS"
-          response.body = NKF::nkf('-Ws', response.body)
-        end
-      end
-    end
-
-    def store_page
-      if request.get? and request.format.try(:html?) and !request.xhr?
-        flash[:page] = params[:page] if params[:page].to_i > 0
-      end
-    end
-
-    def set_role_query(user, search)
-      role = user.try(:role) || Role.default_role
-      search.build do
-        with(:required_role_id).less_than_or_equal_to role.id
-      end
-    end
-
-    def get_version
-      @version = params[:version_id].to_i if params[:version_id]
-      @version = nil if @version == 0
-    end
-
-    def clear_search_sessions
-      session[:query] = nil
-      session[:params] = nil
-      session[:search_params] = nil
-      session[:manifestation_ids] = nil
-    end
-
-    def api_request?
-      true unless params[:format].nil? or params[:format] == 'html'
-    end
-
-    def get_top_page_content
-      if defined?(EnjuNews)
-        @news_feeds = Rails.cache.fetch('news_feed_all'){NewsFeed.order(:position)}
-        @news_posts = NewsPost.limit(LibraryGroup.site_config.settings[:news_post_number_top_page] || 10)
-      end
-      @libraries = Library.real
-    end
-
-    def set_mobile_request
-      case params[:view]
-      when 'phone'
-        session[:enju_view] = :phone
-      when 'desktop'
-        session[:enju_view] = :desktop
-      when 'reset'
-        session[:enju_view] = nil
-      end
-
-      case session[:enju_view].try(:to_sym)
-      when :phone
-        request.variant = :phone
-      when :desktop
-        request.variant = nil
-      else
-        request.variant = :phone if browser.device.mobile?
-      end
-    end
-
-    def move_position(resource, direction, redirect = true)
-      if ['higher', 'lower'].include?(direction)
-        resource.send("move_#{direction}")
-        if redirect
-          redirect_to url_for(controller: resource.class.to_s.pluralize.underscore)
-          return
-        end
-      end
-    end
-
-    def store_current_location
-      store_location_for(:user, request.url)
-    end
-  end
-end

data/app/controllers/my_accounts_controller.rb

@@ -1,93 +0,0 @@
-class MyAccountsController < ApplicationController
-  before_action :authenticate_user!
-  before_action :set_profile
-
-  def show
-    respond_to do |format|
-      format.html
-      format.html.phone
-      format.json { render json: @profile }
-    end
-  end
-
-  def edit
-    prepare_options
-  end
-
-  def update
-    user_attrs = [
-      :id, :email, :current_password, :password, :password_confirmation
-    ]
-    user_attrs += [
-      {:user_has_role_attributes => [:id, :role_id]}
-    ] if current_user.has_role?('Administrator')
-
-    user_params = ActionController::Parameters.new(params[:profile][:user_attributes]).permit(*user_attrs)
-
-    respond_to do |format|
-      saved = current_user.update_attributes(user_params)
-      @profile.assign_attributes(profile_params)
-
-      if saved
-        if @profile.save
-          bypass_sign_in(current_user)
-          format.html { redirect_to my_account_url, notice: t('controller.successfully_updated', model: t('activerecord.models.user')) }
-          format.json { head :no_content }
-        else
-          prepare_options
-          format.html { render action: "edit" }
-          format.json { render json: current_user.errors, status: :unprocessable_entity }
-        end
-      else
-        current_user.errors.full_messages.each do |msg|
-          @profile.errors[:base] << msg
-        end
-        prepare_options
-        format.html { render action: "edit" }
-        format.json { render json: current_user.errors, status: :unprocessable_entity }
-      end
-    end
-  end
-
-  def destroy
-    @profile.destroy
-
-    respond_to do |format|
-      format.html { redirect_to my_account_url, notice: 'devise.registrations.destroyed' }
-      format.json { head :no_content }
-    end
-  end
-
-  private
-  def set_profile
-    @profile = current_user.profile
-    authorize @profile
-  end
-
-  def profile_params
-    attrs = [
-      :full_name, :full_name_transcription, :user_number,
-      :library_id, :keyword_list, :note,
-      :locale, :required_role_id, :expired_at,
-      :locked, :birth_date,
-      :save_checkout_history, :checkout_icalendar_token, # EnjuCirculation
-      :save_search_history # EnjuSearchLog
-    ]
-    if current_user.has_role?('Librarian')
-      attrs << :user_group_id
-    end
-    params.require(:profile).permit(*attrs)
-  end
-
-  def prepare_options
-    @user_groups = UserGroup.order(:position)
-    @roles = Role.order(:position)
-    @libraries = Library.order(:position)
-    @languages = Language.order(:position)
-    if current_user.active_for_authentication?
-      current_user.locked = '0'
-    else
-      current_user.locked = '1'
-    end
-  end
-end

data/app/controllers/names_controller.rb

@@ -1,60 +0,0 @@
-class NamesController < ApplicationController
-  before_action :set_name, only: [:show, :edit, :update, :destroy]
-  before_action :check_policy, only: [:index, :new, :create]
-
-  # GET /names
-  def index
-    @names = Name.paginate(params[:page])
-  end
-
-  # GET /names/1
-  def show
-  end
-
-  # GET /names/new
-  def new
-    @name = Name.new
-  end
-
-  # GET /names/1/edit
-  def edit
-  end
-
-  # POST /names
-  def create
-    @name = Name.new(name_params)
-
-    if @name.save
-      redirect_to @name, notice: 'Name was successfully created.'
-    else
-      render :new
-    end
-  end
-
-  # PATCH/PUT /names/1
-  def update
-    if @name.update(name_params)
-      redirect_to @name, notice: 'Name was successfully updated.'
-    else
-      render :edit
-    end
-  end
-
-  # DELETE /names/1
-  def destroy
-    @name.destroy
-    redirect_to names_url, notice: 'Name was successfully destroyed.'
-  end
-
-  private
-    # Use callbacks to share common setup or constraints between actions.
-    def set_name
-      @name = Name.find(params[:id])
-      authorize @name
-    end
-
-    # Only allow a trusted parameter "white list" through.
-    def name_params
-      params.require(:name).permit(:first_name, :middle_name, :last_name, :language_id, :profile_id, :position)
-    end
-end

data/app/controllers/profiles_controller.rb

@@ -1,219 +0,0 @@
-class ProfilesController < ApplicationController
-  before_action :set_profile, only: [:show, :edit, :update, :destroy]
-  before_action :check_policy, only: [:index, :new, :create]
-  before_action :prepare_options, only: [:new, :edit]
-
-  # GET /profiles
-  # GET /profiles.json
-  def index
-    if params[:username].present?
-      profile = User.where(username: params[:username]).first.try(:profile)
-      if profile
-        redirect_to profile
-        return
-      end
-    end
-    query = flash[:query] = params[:query].to_s
-    @query = query.dup
-    @count = {}
-
-    sort = {sort_by: 'created_at', order: 'desc'}
-    case params[:sort_by]
-    when 'username'
-      sort[:sort_by] = 'username'
-    end
-    case params[:order]
-    when 'asc'
-      sort[:order] = 'asc'
-    when 'desc'
-      sort[:order] = 'desc'
-    end
-
-    query = params[:query]
-    page = params[:page] || 1
-    role = current_user.try(:role) || Role.default_role
-
-    search = Profile.search
-    search.build do
-      fulltext query if query
-      with(:required_role_id).less_than_or_equal_to role.id
-      order_by sort[:sort_by], sort[:order]
-    end
-    search.query.paginate(page.to_i, Profile.default_per_page)
-    @profiles = search.execute!.results
-    @count[:query_result] = @profiles.total_entries
-
-    respond_to do |format|
-      format.html # index.html.erb
-      format.json { render json: @profiles }
-    end
-  end
-
-  # GET /profiles/1
-  # GET /profiles/1.json
-  def show
-    if @profile.user == current_user
-      redirect_to my_account_url
-      return
-    end
-
-    respond_to do |format|
-      format.html # show.html.erb
-      format.html.phone
-      format.json { render json: @profile }
-    end
-  end
-
-  # GET /profiles/new
-  def new
-    @profile = Profile.new
-    @profile.user = User.new
-    @profile.user_group = current_user.profile.user_group
-    @profile.library = current_user.profile.library
-    @profile.locale = current_user.profile.locale
-
-    respond_to do |format|
-      format.html # new.html.erb
-      format.json { render json: @profile }
-    end
-  end
-
-  # GET /profiles/1/edit
-  def edit
-    if defined?(EnjuCirculation)
-      if params[:mode] == 'feed_token'
-        if params[:disable] == 'true'
-          @profile.delete_checkout_icalendar_token
-        else
-          @profile.reset_checkout_icalendar_token
-        end
-        render partial: 'feed_token', locals: {profile: @profile}
-        return
-      end
-    end
-    if @profile.user == current_user
-      redirect_to edit_my_account_url
-      return
-    end
-    if @profile.user.try(:locked_at?)
-      @profile.user.locked = true
-    end
-  end
-
-  # POST /profiles
-  # POST /profiles.json
-  def create
-    if current_user.has_role?('Librarian')
-      @profile = Profile.new(profile_params)
-      if @profile.user
-        password = @profile.user.set_auto_generated_password
-      end
-    else
-      @profile = Profile.new(profile_params)
-    end
-
-    respond_to do |format|
-      if @profile.save
-        if @profile.user
-          @profile.user.role = Role.where(name: 'User').first
-          flash[:temporary_password] = password
-        end
-        format.html { redirect_to @profile, notice: t('controller.successfully_created', model: t('activerecord.models.profile')) }
-        format.json { render json: @profile, status: :created, location: @profile }
-      else
-        prepare_options
-        format.html { render action: "new" }
-        format.json { render json: @profile.errors, status: :unprocessable_entity }
-      end
-    end
-  end
-
-  # PUT /profiles/1
-  # PUT /profiles/1.json
-  def update
-    @profile.update_attributes(profile_update_params)
-    if @profile.user
-      if @profile.user.auto_generated_password == "1"
-        password = @profile.user.set_auto_generated_password
-      end
-    end
-
-    respond_to do |format|
-      if @profile.save
-        flash[:temporary_password] = password
-        format.html { redirect_to @profile, notice: t('controller.successfully_updated', model: t('activerecord.models.profile')) }
-        format.json { head :no_content }
-      else
-        prepare_options
-        format.html { render action: "edit" }
-        format.json { render json: @profile.errors, status: :unprocessable_entity }
-      end
-    end
-  end
-
-  # DELETE /profiles/1
-  # DELETE /profiles/1.json
-  def destroy
-    @profile.destroy
-
-    respond_to do |format|
-      format.html { redirect_to profiles_url, notice: t('controller.successfully_deleted', model: t('activerecord.models.profile')) }
-      format.json { head :no_content }
-    end
-  end
-
-  private
-  def set_profile
-    @profile = Profile.find(params[:id])
-    authorize @profile
-  end
-
-  def check_policy
-    authorize Profile
-  end
-
-  def profile_params
-    attrs = [
-      :full_name, :full_name_transcription,
-      :keyword_list, :locale,
-      :save_checkout_history, :checkout_icalendar_token, # EnjuCirculation
-      :save_search_history, # EnjuSearchLog
-    ]
-    attrs += [
-      :library_id, :expired_at, :birth_date,
-      :user_group_id, :required_role_id, :note, :user_number, {
-        :user_attributes => [
-          :id, :username, :email, :current_password, :locked,
-          {:user_has_role_attributes => [:id, :role_id]}
-        ]
-      }
-    ] if current_user.has_role?('Librarian')
-    params.require(:profile).permit(*attrs)
-  end
-
-  def profile_update_params
-    attrs = [
-      :full_name, :full_name_transcription,
-      :keyword_list, :locale,
-      :save_checkout_history, :checkout_icalendar_token, # EnjuCirculation
-      :save_search_history, # EnjuSearchLog
-    ]
-    attrs += [
-      :library_id, :expired_at, :birth_date,
-      :user_group_id, :required_role_id, :note, :user_number, {
-        :user_attributes => [
-          :id, :email, :current_password, :auto_generated_password, :locked,
-          {:user_has_role_attributes => [:id, :role_id]}
-        ]
-      }
-    ] if current_user.has_role?('Librarian')
-    params.require(:profile).permit(*attrs)
-  end
-
-  def prepare_options
-    @user_groups = UserGroup.all
-    @roles = Role.all
-    @libraries = Library.all
-    @languages = Language.all
-  end
-end