enju_biblio 0.1.0.pre42 → 0.1.0.pre43

data/app/controllers/patrons_controller.rb

@@ -1,22 +1,22 @@
 # -*- encoding: utf-8 -*-
-class PatronsController < ApplicationController
+class AgentsController < ApplicationController
   load_and_authorize_resource :except => :index
   authorize_resource :only => :index
-  before_filter :get_work, :get_expression, :get_manifestation, :get_item, :get_patron, :except => [:update, :destroy]
+  before_filter :get_work, :get_expression, :get_manifestation, :get_item, :get_agent, :except => [:update, :destroy]
   if defined?(EnjuResourceMerge)
-    before_filter :get_patron_merge_list, :except => [:create, :update, :destroy]
+    before_filter :get_agent_merge_list, :except => [:create, :update, :destroy]
   end
   before_filter :prepare_options, :only => [:new, :edit]
   before_filter :store_location
   before_filter :get_version, :only => [:show]
   after_filter :solr_commit, :only => [:create, :update, :destroy]
-  cache_sweeper :patron_sweeper, :only => [:create, :update, :destroy]
+  cache_sweeper :agent_sweeper, :only => [:create, :update, :destroy]
 
-  # GET /patrons
-  # GET /patrons.json
+  # GET /agents
+  # GET /agents.json
   def index
     #session[:params] = {} unless session[:params]
-    #session[:params][:patron] = params
+    #session[:params][:agent] = params
     # 最近追加されたパトロン
     #@query = params[:query] ||= "[* TO *]"
     if params[:mode] == 'add'
@@ -35,12 +35,12 @@ class PatronsController < ApplicationController
     order = nil
     @count = {}
 
-    search = Patron.search(:include => [:patron_type, :required_role])
-    search.data_accessor_for(Patron).select = [
+    search = Agent.search(:include => [:agent_type, :required_role])
+    search.data_accessor_for(Agent).select = [
       :id,
       :full_name,
       :full_name_transcription,
-      :patron_type_id,
+      :agent_type_id,
       :required_role_id,
       :created_at,
       :updated_at,
@@ -61,14 +61,14 @@ class PatronsController < ApplicationController
       work = @work
       expression = @expression
       manifestation = @manifestation
-      patron = @patron
-      patron_merge_list = @patron_merge_list
+      agent = @agent
+      agent_merge_list = @agent_merge_list
       search.build do
         with(:work_ids).equal_to work.id if work
         with(:expression_ids).equal_to expression.id if expression
         with(:manifestation_ids).equal_to manifestation.id if manifestation
-        with(:original_patron_ids).equal_to patron.id if patron
-        with(:patron_merge_list_ids).equal_to patron_merge_list.id if patron_merge_list
+        with(:original_agent_ids).equal_to agent.id if agent
+        with(:agent_merge_list_ids).equal_to agent_merge_list.id if agent_merge_list
       end
     end
 
@@ -79,138 +79,138 @@ class PatronsController < ApplicationController
 
     page = params[:page].to_i || 1
     page = 1 if page == 0
-    search.query.paginate(page, Patron.default_per_page)
-    @patrons = search.execute!.results
+    search.query.paginate(page, Agent.default_per_page)
+    @agents = search.execute!.results
 
     flash[:page_info] = {:page => page, :query => query}
 
     respond_to do |format|
       format.html # index.html.erb
-      format.xml  { render :xml => @patrons }
+      format.xml  { render :xml => @agents }
       format.rss  { render :layout => false }
       format.atom
-      format.json { render :json => @patrons }
+      format.json { render :json => @agents }
       format.mobile
     end
   end
 
-  # GET /patrons/1
-  # GET /patrons/1.json
+  # GET /agents/1
+  # GET /agents/1.json
   def show
     case
     when @work
-      @patron = @work.creators.find(params[:id])
+      @agent = @work.creators.find(params[:id])
     when @manifestation
-      @patron = @manifestation.publishers.find(params[:id])
+      @agent = @manifestation.publishers.find(params[:id])
     when @item
-      @patron = @item.patrons.find(params[:id])
+      @agent = @item.agents.find(params[:id])
     else
       if @version
-        @patron = @patron.versions.find(@version).item if @version
+        @agent = @agent.versions.find(@version).item if @version
       end
     end
 
-    patron = @patron
+    agent = @agent
     role = current_user.try(:role) || Role.default_role
     @works = Manifestation.search do
-      with(:creator_ids).equal_to patron.id
+      with(:creator_ids).equal_to agent.id
       with(:required_role_id).less_than_or_equal_to role.id
       paginate :page => params[:work_list_page], :per_page => Manifestation.default_per_page
     end.results
     @expressions = Manifestation.search do
-      with(:contributor_ids).equal_to patron.id
+      with(:contributor_ids).equal_to agent.id
       with(:required_role_id).less_than_or_equal_to role.id
       paginate :page => params[:expression_list_page], :per_page => Manifestation.default_per_page
     end.results
     @manifestations = Manifestation.search do
-      with(:publisher_ids).equal_to patron.id
+      with(:publisher_ids).equal_to agent.id
       with(:required_role_id).less_than_or_equal_to role.id
       paginate :page => params[:manifestation_list_page], :per_page => Manifestation.default_per_page
     end.results
 
     respond_to do |format|
       format.html # show.html.erb
-      format.json { render :json => @patron }
+      format.json { render :json => @agent }
       format.js
       format.mobile
     end
   end
 
-  # GET /patrons/new
-  # GET /patrons/new.json
+  # GET /agents/new
+  # GET /agents/new.json
   def new
-    @patron = Patron.new
-    @patron.required_role = Role.where(:name => 'Guest').first
-    @patron.language = Language.where(:iso_639_1 => I18n.default_locale.to_s).first || Language.first
-    @patron.country = current_user.library.country
+    @agent = Agent.new
+    @agent.required_role = Role.where(:name => 'Guest').first
+    @agent.language = Language.where(:iso_639_1 => I18n.default_locale.to_s).first || Language.first
+    @agent.country = current_user.library.country
     prepare_options
 
     respond_to do |format|
       format.html # new.html.erb
-      format.json { render :json => @patron }
+      format.json { render :json => @agent }
     end
   end
 
-  # GET /patrons/1/edit
+  # GET /agents/1/edit
   def edit
     prepare_options
   end
 
-  # POST /patrons
-  # POST /patrons.json
+  # POST /agents
+  # POST /agents.json
   def create
-    @patron = Patron.new(params[:patron])
-    #if @patron.user_username
-    #  @patron.user = User.find(@patron.user_username) rescue nil
+    @agent = Agent.new(params[:agent])
+    #if @agent.user_username
+    #  @agent.user = User.find(@agent.user_username) rescue nil
     #end
     #unless current_user.has_role?('Librarian')
-    #  if @patron.user != current_user
+    #  if @agent.user != current_user
     #    access_denied; return
     #  end
     #end
 
     respond_to do |format|
-      if @patron.save
+      if @agent.save
         case
         when @work
-          @patron.works << @work
+          @agent.works << @work
         when @manifestation
-          @patron.manifestations << @manifestation
+          @agent.manifestations << @manifestation
         when @item
-          @patron.items << @item
+          @agent.items << @item
         end
-        format.html { redirect_to @patron, :notice => t('controller.successfully_created', :model => t('activerecord.models.patron')) }
-        format.json { render :json => @patron, :status => :created, :location => @patron }
+        format.html { redirect_to @agent, :notice => t('controller.successfully_created', :model => t('activerecord.models.agent')) }
+        format.json { render :json => @agent, :status => :created, :location => @agent }
       else
         prepare_options
         format.html { render :action => "new" }
-        format.json { render :json => @patron.errors, :status => :unprocessable_entity }
+        format.json { render :json => @agent.errors, :status => :unprocessable_entity }
       end
     end
   end
 
-  # PUT /patrons/1
-  # PUT /patrons/1.json
+  # PUT /agents/1
+  # PUT /agents/1.json
   def update
     respond_to do |format|
-      if @patron.update_attributes(params[:patron])
-        format.html { redirect_to @patron, :notice => t('controller.successfully_updated', :model => t('activerecord.models.patron')) }
+      if @agent.update_attributes(params[:agent])
+        format.html { redirect_to @agent, :notice => t('controller.successfully_updated', :model => t('activerecord.models.agent')) }
         format.json { head :no_content }
       else
         prepare_options
         format.html { render :action => "edit" }
-        format.json { render :json => @patron.errors, :status => :unprocessable_entity }
+        format.json { render :json => @agent.errors, :status => :unprocessable_entity }
       end
     end
   end
 
-  # DELETE /patrons/1
-  # DELETE /patrons/1.json
+  # DELETE /agents/1
+  # DELETE /agents/1.json
   def destroy
-    @patron.destroy
+    @agent.destroy
 
     respond_to do |format|
-      format.html { redirect_to patrons_url, :notice => t('controller.successfully_deleted', :model => t('activerecord.models.patron')) }
+      format.html { redirect_to agents_url, :notice => t('controller.successfully_deleted', :model => t('activerecord.models.agent')) }
       format.json { head :no_content }
     end
   end
@@ -218,9 +218,9 @@ class PatronsController < ApplicationController
   private
   def prepare_options
     @countries = Country.all_cache
-    @patron_types = PatronType.all
+    @agent_types = AgentType.all
     @roles = Role.all
     @languages = Language.all_cache
-    @patron_type = PatronType.where(:name => 'Person').first
+    @agent_type = AgentType.where(:name => 'Person').first
   end
 end

data/app/controllers/picture_files_controller.rb

@@ -59,7 +59,7 @@ class PictureFilesController < ApplicationController
       redirect_to picture_files_url
       return
     end
-    #raise unless @event or @manifestation or @shelf or @patron
+    #raise unless @event or @manifestation or @shelf or @agent
     @picture_file = PictureFile.new
     @picture_file.picture_attachable = @attachable
 
@@ -140,9 +140,9 @@ class PictureFilesController < ApplicationController
       @attachable = @manifestation
       return
     end
-    get_patron
-    if @patron
-      @attachable = @patron
+    get_agent
+    if @agent
+      @attachable = @agent
       return
     end
     get_event

data/app/controllers/produces_controller.rb

@@ -1,6 +1,6 @@
 class ProducesController < ApplicationController
   load_and_authorize_resource
-  before_filter :get_patron, :get_manifestation
+  before_filter :get_agent, :get_manifestation
   before_filter :prepare_options, :only => [:new, :edit]
   after_filter :solr_commit, :only => [:create, :update, :destroy]
   cache_sweeper :page_sweeper, :only => [:create, :update, :destroy]
@@ -9,8 +9,8 @@ class ProducesController < ApplicationController
   # GET /produces.json
   def index
     case
-    when @patron
-      @produces = @patron.produces.order('produces.position').page(params[:page])
+    when @agent
+      @produces = @agent.produces.order('produces.position').page(params[:page])
     when @manifestation
       @produces = @manifestation.produces.order('produces.position').page(params[:page])
     else
@@ -39,16 +39,16 @@ class ProducesController < ApplicationController
 
   # GET /produces/new
   def new
-    if @patron and @manifestation.blank?
-      redirect_to patron_manifestations_url(@patron)
+    if @agent and @manifestation.blank?
+      redirect_to agent_manifestations_url(@agent)
       return
-    elsif @manifestation and @patron.blank?
-      redirect_to manifestation_patrons_url(@manifestation)
+    elsif @manifestation and @agent.blank?
+      redirect_to manifestation_agents_url(@manifestation)
       return
     else
       @produce = Produce.new
       @produce.manifestation = @manifestation
-      @produce.patron = @patron
+      @produce.agent = @agent
     end
   end
 
@@ -103,10 +103,10 @@ class ProducesController < ApplicationController
       format.html {
         flash[:notice] = t('controller.successfully_deleted', :model => t('activerecord.models.produce'))
         case
-        when @patron
-          redirect_to patron_manifestations_url(@patron)
+        when @agent
+          redirect_to agent_manifestations_url(@agent)
         when @manifestation
-          redirect_to manifestation_patrons_url(@manifestation)
+          redirect_to manifestation_agents_url(@manifestation)
         else
           redirect_to produces_url
         end

data/app/controllers/realizes_controller.rb

@@ -1,6 +1,6 @@
 class RealizesController < ApplicationController
   load_and_authorize_resource
-  before_filter :get_patron, :get_expression
+  before_filter :get_agent, :get_expression
   before_filter :prepare_options, :only => [:new, :edit]
   after_filter :solr_commit, :only => [:create, :update, :destroy]
   cache_sweeper :page_sweeper, :only => [:create, :update, :destroy]
@@ -9,8 +9,8 @@ class RealizesController < ApplicationController
   # GET /realizes.json
   def index
     case
-    when @patron
-      @realizes = @patron.realizes.order('realizes.position').page(params[:page])
+    when @agent
+      @realizes = @agent.realizes.order('realizes.position').page(params[:page])
     when @expression
       @realizes = @expression.realizes.order('realizes.position').page(params[:page])
     else
@@ -34,16 +34,16 @@ class RealizesController < ApplicationController
 
   # GET /realizes/new
   def new
-    if @expression and @patron.blank?
-      redirect_to expression_patrons_url(@expression)
+    if @expression and @agent.blank?
+      redirect_to expression_agents_url(@expression)
       return
-    elsif @patron and @expression.blank?
-      redirect_to patron_expressions_url(@patron)
+    elsif @agent and @expression.blank?
+      redirect_to agent_expressions_url(@agent)
       return
     else
       @realize = Realize.new
       @realize.expression = @expression
-      @realize.patron = @patron
+      @realize.agent = @agent
     end
   end
 
@@ -100,9 +100,9 @@ class RealizesController < ApplicationController
         flash[:notice] = t('controller.successfully_deleted', :model => t('activerecord.models.realize'))
         case
         when @expression
-          redirect_to expression_patrons_url(@expression)
-        when @patron
-          redirect_to patron_expressions_url(@patron)
+          redirect_to expression_agents_url(@expression)
+        when @agent
+          redirect_to agent_expressions_url(@agent)
         else
           redirect_to realizes_url
         end

data/app/helpers/{patrons_helper.rb → agents_helper.rb}

@@ -1,13 +1,13 @@
-module PatronsHelper
+module AgentsHelper
   include PictureFilesHelper
-  def patron_custom_book_jacket(patron)
+  def agent_custom_book_jacket(agent)
     link = ''
-    patron.picture_files.each_with_index do |picture_file, i|
+    agent.picture_files.each_with_index do |picture_file, i|
       if i == 0
-        link += link_to(show_image(picture_file, :size => :thumb), picture_file_path(picture_file, :format => :download), :rel => "patron_#{patron.id}")
+        link += link_to(show_image(picture_file, :size => :thumb), picture_file_path(picture_file, :format => :download), :rel => "agent_#{agent.id}")
       else
         link += content_tag :span, :style => "display: none" do
-          link_to(show_image(picture_file, :size => :thumb), picture_file_path(picture_file, :format => :download), :rel => "patron_#{patron.id}")
+          link_to(show_image(picture_file, :size => :thumb), picture_file_path(picture_file, :format => :download), :rel => "agent_#{agent.id}")
         end
       end
     end

data/app/models/{patron.rb → agent.rb}

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-class Patron < ActiveRecord::Base
+class Agent < ActiveRecord::Base
   enju_export if defined?(EnjuExport)
   attr_accessible :last_name, :middle_name, :first_name,
     :last_name_transcription, :middle_name_transcription,
     :first_name_transcription, :corporate_name, :corporate_name_transcription,
     :full_name, :full_name_transcription, :full_name_alternative,
     :other_designation, :language_id,
-    :country_id, :patron_type_id, :note, :required_role_id, :email, :url,
+    :country_id, :agent_type_id, :note, :required_role_id, :email, :url,
     :full_name_alternative_transcription, :title,
-    :patron_identifier
+    :agent_identifier
 
   scope :readable_by, lambda{|user| {:conditions => ['required_role_id <= ?', user.try(:user_has_role).try(:role_id) || Role.where(:name => 'Guest').select(:id).first.id]}}
   has_many :creates, :dependent => :destroy
@@ -17,28 +17,28 @@ class Patron < ActiveRecord::Base
   has_many :expressions, :through => :realizes
   has_many :produces, :dependent => :destroy
   has_many :manifestations, :through => :produces
-  has_many :children, :foreign_key => 'parent_id', :class_name => 'PatronRelationship', :dependent => :destroy
-  has_many :parents, :foreign_key => 'child_id', :class_name => 'PatronRelationship', :dependent => :destroy
-  has_many :derived_patrons, :through => :children, :source => :child
-  has_many :original_patrons, :through => :parents, :source => :parent
+  has_many :children, :foreign_key => 'parent_id', :class_name => 'AgentRelationship', :dependent => :destroy
+  has_many :parents, :foreign_key => 'child_id', :class_name => 'AgentRelationship', :dependent => :destroy
+  has_many :derived_agents, :through => :children, :source => :child
+  has_many :original_agents, :through => :parents, :source => :parent
   has_many :picture_files, :as => :picture_attachable, :dependent => :destroy
   has_many :donates
   has_many :donated_items, :through => :donates, :source => :item
   has_many :owns, :dependent => :destroy
   has_many :items, :through => :owns
   if defined?(EnjuResourceMerge)
-    has_many :patron_merges, :dependent => :destroy
-    has_many :patron_merge_lists, :through => :patron_merges
+    has_many :agent_merges, :dependent => :destroy
+    has_many :agent_merge_lists, :through => :agent_merges
   end
   #belongs_to :user
-  belongs_to :patron_type
+  belongs_to :agent_type
   belongs_to :required_role, :class_name => 'Role', :foreign_key => 'required_role_id', :validate => true
   belongs_to :language
   belongs_to :country
-  has_one :patron_import_result
+  has_one :agent_import_result
 
-  validates_presence_of :language, :patron_type, :country
-  validates_associated :language, :patron_type, :country
+  validates_presence_of :language, :agent_type, :country
+  validates_associated :language, :agent_type, :country
   validates :full_name, :presence => true, :length => {:maximum => 255}
   #validates :user_id, :uniqueness => true, :allow_nil => true
   validates :birth_date, :format => {:with => /\A\d+(-\d{0,2}){0,2}\z/}, :allow_blank => true
@@ -63,10 +63,10 @@ class Patron < ActiveRecord::Base
     integer :work_ids, :multiple => true
     integer :expression_ids, :multiple => true
     integer :manifestation_ids, :multiple => true
-    integer :patron_merge_list_ids, :multiple => true if defined?(EnjuResourceMerge)
-    integer :original_patron_ids, :multiple => true
+    integer :agent_merge_list_ids, :multiple => true if defined?(EnjuResourceMerge)
+    integer :original_agent_ids, :multiple => true
     integer :required_role_id
-    integer :patron_type_id
+    integer :agent_type_id
   end
 
   paginates_per 10
@@ -213,33 +213,33 @@ class Patron < ActiveRecord::Base
     owns.where(:item_id => item.id)
   end
 
-  def self.import_patrons(patron_lists)
-    patrons = []
-    patron_lists.each do |patron_list|
-      name_and_role = patron_list[:full_name].split('||')
-      if patron_list[:patron_identifier].present?
-        patron = Patron.where(:patron_identifier => patron_list[:patron_identifier]).first
+  def self.import_agents(agent_lists)
+    agents = []
+    agent_lists.each do |agent_list|
+      name_and_role = agent_list[:full_name].split('||')
+      if agent_list[:agent_identifier].present?
+        agent = Agent.where(:agent_identifier => agent_list[:agent_identifier]).first
       else
-        patron = Patron.where(:full_name => name_and_role[0]).first
+        agent = Agent.where(:full_name => name_and_role[0]).first
       end
       role_type = name_and_role[1].to_s.strip
-      unless patron
-        patron = Patron.new(
+      unless agent
+        agent = Agent.new(
           :full_name => name_and_role[0],
-          :full_name_transcription => patron_list[:full_name_transcription],
-          :patron_identifier => patron_list[:patron_identifier],
+          :full_name_transcription => agent_list[:full_name_transcription],
+          :agent_identifier => agent_list[:agent_identifier],
           :language_id => 1
         )
-        patron.required_role = Role.where(:name => 'Guest').first
-        patron.save
+        agent.required_role = Role.where(:name => 'Guest').first
+        agent.save
       end
-      patrons << patron
+      agents << agent
     end
-    patrons
+    agents
   end
 
-  def patrons
-    self.original_patrons + self.derived_patrons
+  def agents
+    self.original_agents + self.derived_agents
   end
 
   def user
@@ -249,7 +249,7 @@ end
 
 # == Schema Information
 #
-# Table name: patrons
+# Table name: agents
 #
 #  id                                  :integer          not null, primary key
 #  user_id                             :integer
@@ -287,7 +287,7 @@ end
 #  date_of_death                       :datetime
 #  language_id                         :integer          default(1), not null
 #  country_id                          :integer          default(1), not null
-#  patron_type_id                      :integer          default(1), not null
+#  agent_type_id                      :integer          default(1), not null
 #  lock_version                        :integer          default(0), not null
 #  note                                :text
 #  required_role_id                    :integer          default(1), not null
@@ -298,6 +298,6 @@ end
 #  full_name_alternative_transcription :text
 #  birth_date                          :string(255)
 #  death_date                          :string(255)
-#  patron_identifier                   :string(255)
+#  agent_identifier                   :string(255)
 #