enju_standalone_interface 0.0.1

data/spec/dummy/app/models/item_has_use_restriction.rb

@@ -0,0 +1,23 @@
+class ItemHasUseRestriction < ActiveRecord::Base
+  belongs_to :item, :validate => true
+  belongs_to :use_restriction, :validate => true
+
+  def self.per_page
+    10
+  end
+
+  validates_associated :item, :use_restriction
+  validates_presence_of :item, :use_restriction
+end
+
+# == Schema Information
+#
+# Table name: item_has_use_restrictions
+#
+#  id                 :integer         not null, primary key
+#  item_id            :integer         not null
+#  use_restriction_id :integer         not null
+#  created_at         :datetime
+#  updated_at         :datetime
+#
+

data/spec/dummy/app/models/lending_policy.rb

@@ -0,0 +1,32 @@
+class LendingPolicy < ActiveRecord::Base
+  default_scope :order => 'position'
+  belongs_to :item
+  belongs_to :user_group
+
+  validates_presence_of :item, :user_group
+  validates_uniqueness_of :user_group_id, :scope => :item_id
+
+  def self.per_page
+    10
+  end
+
+  acts_as_list :scope => :item_id
+end
+
+# == Schema Information
+#
+# Table name: lending_policies
+#
+#  id             :integer         not null, primary key
+#  item_id        :integer         not null
+#  user_group_id  :integer         not null
+#  loan_period    :integer         default(0), not null
+#  fixed_due_date :datetime
+#  renewal        :integer         default(0), not null
+#  fine           :decimal(, )     default(0.0), not null
+#  note           :text
+#  position       :integer
+#  created_at     :datetime
+#  updated_at     :datetime
+#
+

data/spec/dummy/app/models/library.rb

@@ -0,0 +1,105 @@
+# -*- encoding: utf-8 -*-
+class Library < ActiveRecord::Base
+  include MasterModel
+  default_scope :order => 'libraries.position'
+  scope :real, where('id != 1')
+  has_many :shelves, :order => 'shelves.position'
+  belongs_to :library_group, :validate => true
+  has_many :events, :include => :event_category
+  #belongs_to :holding_patron, :polymorphic => true, :validate => true
+  belongs_to :patron #, :validate => true
+  has_many :inter_library_loans, :foreign_key => 'borrowing_library_id'
+  has_many :users
+  belongs_to :country
+
+  validates_presence_of :short_display_name, :library_group, :patron
+  validates_uniqueness_of :short_display_name, :case_sensitive => false
+  validates :display_name, :uniqueness => true
+  validates :name, :format => {:with => /^[a-z][0-9a-z]{2,254}$/}
+
+  def self.all_cache
+    if Rails.env == 'production'
+      Rails.cache.fetch('library_all'){Library.all}
+    else
+      Library.all
+    end
+  end
+
+  def clear_all_cache
+    Rails.cache.delete('library_all')
+  end
+
+  def set_patron
+    self.patron = Patron.new(
+      :full_name => self.name
+    )
+  end
+
+  def create_shelf
+    Shelf.create!(:name => "#{self.name}_default", :library => self)
+  end
+
+  def closed?(date)
+    events.closing_days.collect{|c| c.start_at.beginning_of_day}.include?(date.beginning_of_day)
+  end
+
+  def web?
+    return true if self.id == 1
+    false
+  end
+
+  def self.web
+    Library.find(1)
+  end
+
+  def address(locale = I18n.locale)
+    case locale.to_sym
+    when :ja
+      "#{self.region.to_s.localize(locale)}#{self.locality.to_s.localize(locale)}#{self.street.to_s.localize(locale)}"
+    else
+      "#{self.street.to_s.localize(locale)} #{self.locality.to_s.localize(locale)} #{self.region.to_s.localize(locale)}"
+    end
+  rescue
+    nil
+  end
+
+  def address_changed?
+    return true if region_changed? or locality_changed? or street_changed?
+    false
+  end
+end
+
+# == Schema Information
+#
+# Table name: libraries
+#
+#  id                          :integer         not null, primary key
+#  patron_id                   :integer
+#  patron_type                 :string(255)
+#  name                        :string(255)     not null
+#  display_name                :text
+#  short_display_name          :string(255)     not null
+#  zip_code                    :string(255)
+#  street                      :text
+#  locality                    :text
+#  region                      :text
+#  telephone_number_1          :string(255)
+#  telephone_number_2          :string(255)
+#  fax_number                  :string(255)
+#  note                        :text
+#  call_number_rows            :integer         default(1), not null
+#  call_number_delimiter       :string(255)     default("|"), not null
+#  library_group_id            :integer         default(1), not null
+#  users_count                 :integer         default(0), not null
+#  position                    :integer
+#  country_id                  :integer
+#  created_at                  :datetime
+#  updated_at                  :datetime
+#  deleted_at                  :datetime
+#  opening_hour                :text
+#  latitude                    :float
+#  longitude                   :float
+#  calil_systemid              :string(255)
+#  calil_neighborhood_systemid :text
+#
+

data/spec/dummy/app/models/library_group.rb

@@ -0,0 +1,88 @@
+# -*- encoding: utf-8 -*-
+class LibraryGroup < ActiveRecord::Base
+  #include Singleton
+  #include Configurator
+  include MasterModel
+
+  has_many :libraries
+  has_many :search_engines
+  #has_many :news_feeds
+  belongs_to :country
+
+  validates :email, :format => {:with => /\A([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})\z/i}, :presence => true
+  validates :url, :presence => true, :url => true
+  after_save :clear_site_config_cache
+
+  def clear_site_config_cache
+    Rails.cache.delete('library_site_config')
+  end
+
+  def self.site_config
+    #if Rails.env == 'production'
+    #  Rails.cache.fetch('library_site_config'){LibraryGroup.find(1)}
+    #else
+      LibraryGroup.find(1)
+    #end
+  rescue
+    nil
+  end
+
+  def self.system_name(locale = I18n.locale)
+    LibraryGroup.site_config.display_name.localize(locale)
+  end
+
+  def config?
+    true if self == LibraryGroup.site_config
+  end
+
+  def real_libraries
+    # 物理的な図書館 = IDが1以外
+    libraries.where('id != 1').all
+  end
+
+  def network_access_allowed?(ip_address, options = {})
+    options = {:network_type => 'lan'}.merge(options)
+    client_ip = IPAddr.new(ip_address)
+    case options[:network_type]
+    when 'admin'
+      allowed_networks = self.admin_networks.to_s.split
+    else
+      allowed_networks = self.my_networks.to_s.split
+    end
+    allowed_networks.each do |allowed_network|
+      begin
+        network = IPAddr.new(allowed_network)
+        return true if network.include?(client_ip)
+      rescue ArgumentError
+        nil
+      end
+    end
+    return false
+  end
+
+end
+
+# == Schema Information
+#
+# Table name: library_groups
+#
+#  id                          :integer         not null, primary key
+#  name                        :string(255)     not null
+#  display_name                :text
+#  short_name                  :string(255)     not null
+#  email                       :string(255)
+#  my_networks                 :text
+#  use_dsbl                    :boolean         default(FALSE), not null
+#  dsbl_list                   :text
+#  login_banner                :text
+#  note                        :text
+#  post_to_union_catalog       :boolean         default(FALSE), not null
+#  country_id                  :integer
+#  created_at                  :datetime
+#  updated_at                  :datetime
+#  admin_networks              :text
+#  allow_bookmark_external_url :boolean         default(FALSE), not null
+#  position                    :integer
+#  url                         :string(255)     default("http://localhost:3000/")
+#
+

data/spec/dummy/app/models/manifestation.rb

@@ -0,0 +1,698 @@
+class Manifestation < ActiveRecord::Base
+  scope :periodical_master, where(:periodical_master => true)
+  scope :periodical_children, where(:periodical_master => false)
+  has_many :creates, :dependent => :destroy, :foreign_key => 'work_id'
+  has_many :creators, :through => :creates, :source => :patron
+  has_many :realizes, :dependent => :destroy, :foreign_key => 'expression_id'
+  has_many :contributors, :through => :realizes, :source => :patron
+  has_many :produces, :dependent => :destroy, :foreign_key => 'manifestation_id'
+  has_many :publishers, :through => :produces, :source => :patron
+  has_many :exemplifies, :foreign_key => 'manifestation_id'
+  has_many :items, :through => :exemplifies #, :foreign_key => 'manifestation_id'
+  has_many :children, :foreign_key => 'parent_id', :class_name => 'ManifestationRelationship', :dependent => :destroy
+  has_many :parents, :foreign_key => 'child_id', :class_name => 'ManifestationRelationship', :dependent => :destroy
+  has_many :derived_manifestations, :through => :children, :source => :child
+  has_many :original_manifestations, :through => :parents, :source => :parent
+  has_many :work_has_subjects, :foreign_key => 'work_id', :dependent => :destroy
+  has_many :subjects, :through => :work_has_subjects
+  has_many :bookmarks, :include => :tags, :dependent => :destroy, :foreign_key => :manifestation_id
+  has_many :users, :through => :bookmarks
+  has_many :reserves, :foreign_key => :manifestation_id, :order => :position
+  has_many :picture_files, :as => :picture_attachable, :dependent => :destroy
+  #belongs_to :language
+  belongs_to :carrier_type
+  belongs_to :content_type
+  has_one :series_has_manifestation
+  has_one :series_statement, :through => :series_has_manifestation
+  belongs_to :manifestation_relationship_type
+  belongs_to :frequency
+  belongs_to :required_role, :class_name => 'Role', :foreign_key => 'required_role_id', :validate => true
+  has_one :resource_import_result
+  has_many :purchase_requests
+  has_many :table_of_contents
+
+  def parent_of_series
+    original_manifestations
+  end
+
+  def next_reservation
+    self.reserves.not_retained.order('reserves.position ASC').first
+  end
+
+  def next_reserve
+    self.reserves.not_retained.order('reserves.position ASC').first
+  end
+
+  def serial?
+    if series_statement.try(:periodical) and !periodical_master
+      return true unless  series_statement.initial_manifestation == self
+    end
+    false
+  end
+
+  def number_of_pages
+    if self.start_page and self.end_page
+      page = self.end_page.to_i - self.start_page.to_i + 1
+    end
+  end
+
+  def tags
+    if self.bookmarks.first
+      self.bookmarks.tag_counts
+    else
+      []
+    end
+  end
+
+  def titles
+    title = []
+    title << original_title.to_s.strip
+    title << title_transcription.to_s.strip
+    title << title_alternative.to_s.strip
+    #title << original_title.wakati
+    #title << title_transcription.wakati rescue nil
+    #title << title_alternative.wakati rescue nil
+    title
+  end
+
+  def url
+    #access_address
+    "#{LibraryGroup.site_config.url}#{self.class.to_s.tableize}/#{self.id}"
+  end
+
+  def available_checkout_types(user)
+    if user
+      user.user_group.user_group_has_checkout_types.available_for_carrier_type(self.carrier_type)
+    end
+  end
+
+  def new_serial?
+    return false unless self.serial?    
+    unless self.serial_number.blank?
+      return true if self == self.series_statement.last_issue
+    else
+      return true if self == self.series_statement.last_issue_with_issue_number
+    end
+  end
+
+  def checkout_period(user)
+    if available_checkout_types(user)
+      available_checkout_types(user).collect(&:checkout_period).max || 0
+    end
+  end
+
+  def reservation_expired_period(user)
+    if available_checkout_types(user)
+      available_checkout_types(user).collect(&:reservation_expired_period).max || 0
+    end
+  end
+
+  def patrons
+    (creators + contributors + publishers).flatten
+  end
+
+  def bookmarked?(user)
+    self.users.include?(user)
+  end
+
+  def set_serial_number
+    if m = series_statement.try(:last_issue)
+      self.original_title = m.original_title
+      self.title_transcription = m.title_transcription
+      self.title_alternative = m.title_alternative
+      self.issn = m.issn
+      unless m.serial_number_string.blank?
+        self.serial_number_string = m.serial_number_string.to_i + 1
+        unless m.issue_number.blank?
+#          self.issue_number = m.issue_number.split.last.to_i + 1
+          self.issue_number = m.issue_number.last.to_i + 1
+        else
+          self.issue_number = m.issue_number
+        end
+        self.volume_number = m.volume_number
+      else
+        unless m.issue_number.blank?
+#          self.issue_number = m.issue_number.split.last.to_i + 1
+          self.issue_number = m.issue_number.last.to_i + 1
+          self.volume_number = m.volume_number_string
+        else
+          unless m.volume_number.blank?
+#            self.volume_number = m.volume_number.split.last.to_i + 1
+            self.volume_number = m.volume_number.last.to_i + 1
+          end
+        end
+      end
+    end
+    self
+  end
+
+  def set_new_serial_number
+    self.serial_number = self.serial_number_string.gsub(/\D/, "").to_i if self.serial_number_string rescue nil
+  end
+
+  def set_volume_issue_number
+    self.volume_number = self.volume_number_string.gsub(/\D/, "").to_i if self.volume_number_string rescue nil
+    self.issue_number = self.issue_number_string.gsub(/\D/, "").to_i if self.issue_number_string rescue nil     
+  end
+
+  def reservable_with_item?(user = nil)
+    if SystemConfiguration.get("reserve.not_reserve_on_loan").nil?
+      return true
+    end
+    if SystemConfiguration.get("reserve.not_reserve_on_loan")
+      if user.try(:has_role?, 'Librarian')
+        return true
+      end
+      if items.index {|item| item.available_for_reserve_with_config? }
+        return true
+      else
+        return false
+      end
+    end
+    return true
+  end
+
+  def reservable?
+    unless SystemConfiguration.get("reserves.able_for_not_item")
+      return false if items.for_checkout.empty? 
+    end
+    return false if self.periodical_master?
+    true
+  end
+
+  def is_reserved_by(user = nil)
+    if user
+      Reserve.waiting.where(:user_id => user.id, :manifestation_id => self.id).first
+    else
+      false
+    end
+  end
+
+  def is_reserved?
+    if self.reserves.present?
+      true
+    else
+      false
+    end
+  end
+
+  def checkouts(start_date, end_date)
+    Checkout.completed(start_date, end_date).where(:item_id => self.items.collect(&:id))
+  end
+
+  def creator
+    creators.collect(&:name).flatten
+  end
+
+  def contributor
+    contributors.collect(&:name).flatten
+  end
+
+  def publisher
+    publishers.collect(&:name).flatten
+  end
+
+  def title
+    titles
+  end
+
+  def hyphenated_isbn
+    ISBN_Tools.hyphenate(isbn)
+  end
+
+  # TODO: よりよい推薦方法
+  def self.pickup(keyword = nil)
+    return nil if self.cached_numdocs < 5
+    manifestation = nil
+    # TODO: ヒット件数が0件のキーワードがあるときに指摘する
+    response = Manifestation.search(:include => [:creators, :contributors, :publishers, :subjects, :items]) do
+      fulltext keyword if keyword
+      order_by(:random)
+      paginate :page => 1, :per_page => 1
+    end
+    manifestation = response.results.first
+  end
+
+  def set_digest(options = {:type => 'sha1'})
+    if attachment.queued_for_write[:original]
+      if File.exists?(attachment.queued_for_write[:original])
+        self.file_hash = Digest::SHA1.hexdigest(File.open(attachment.queued_for_write[:original].path, 'rb').read)
+      end
+    end
+  end
+
+  def extract_text
+    return nil unless attachment.path
+    # TODO: S3 support
+    response = `curl "#{Sunspot.config.solr.url}/update/extract?&extractOnly=true&wt=ruby" --data-binary @#{attachment.path} -H "Content-type:text/html"`
+    self.fulltext = eval(response)[""]
+    save(:validate => false)
+  end
+
+  def created(patron)
+    creates.where(:patron_id => patron.id).first
+  end
+
+  def realized(patron)
+    realizes.where(:patron_id => patron.id).first
+  end
+
+  def produced(patron)
+    produces.where(:patron_id => patron.id).first
+  end
+
+  def sort_title
+    NKF.nkf('-w --katakana', title_transcription) if title_transcription
+  end
+
+  def classifications
+    subjects.collect(&:classifications).flatten
+  end
+
+  def volume_number
+    volume_number_string.gsub(/\D/, ' ').split(" ") if volume_number_string
+  end
+
+  def issue_number
+    issue_number_string.gsub(/\D/, ' ').split(" ") if issue_number_string
+  end
+
+  def serial_number
+    serial_number_string.gsub(/\D/, ' ').split(" ") if serial_number_string
+  end
+
+  def questions(options = {})
+    id = self.id
+    options = {:page => 1, :per_page => Question.per_page}.merge(options)
+    page = options[:page]
+    per_page = options[:per_page]
+    user = options[:user]
+    Question.search do
+      with(:manifestation_id).equal_to id
+      any_of do
+        unless user.try(:has_role?, 'Librarian')
+          with(:shared).equal_to true
+        #  with(:username).equal_to user.try(:username)
+        end
+      end
+      paginate :page => page, :per_page => per_page
+    end.results
+  end
+
+  def web_item
+    items.where(:shelf_id => Shelf.web.id).first
+  end
+
+  def self.find_by_isbn(isbn)
+    if ISBN_Tools.is_valid?(isbn)
+      ISBN_Tools.cleanup!(isbn)
+      if isbn.size == 10
+        Manifestation.where(:isbn => ISBN_Tools.isbn10_to_isbn13(isbn)).first || Manifestation.where(:isbn => isbn).first
+      else
+        Manifestation.where(:isbn => isbn).first || Manifestation.where(:isbn => ISBN_Tools.isbn13_to_isbn10(isbn)).first
+      end
+    end
+  end
+
+  def index_series_statement
+    series_statement.try(:index)
+  end
+
+  def acquired_at
+    items.order(:acquired_at).first.try(:acquired_at)
+  end
+
+  def set_series_statement
+    if self.series_statement_id
+      series_statement = SeriesStatement.find(self.series_statement_id)
+      self.series_statement = series_statement unless series_statement.blank?   
+    end
+  end 
+
+  def delete_attachment
+    @delete_attachment ||= "0"
+  end
+  
+  def delete_attachment=(value)
+    @delete_attachment = value
+  end
+
+  def last_checkout_datetime
+    Manifestation.find(:last, :include => [:items, :items => :checkouts], :conditions => {:manifestations => {:id => self.id}}, :order => 'items.created_at DESC').items.first.checkouts.first.created_at rescue nil
+  end
+
+  def reserve_count(type)
+    sum = 0
+    case type
+    when nil
+    when :all
+      sum = Reserve.where(:manifestation_id=>self.id).count
+    when :previous_term
+      term = Term.previous_term
+      if term
+        sum = Reserve.where("manifestation_id = ? AND created_at >= ? AND created_at <= ?", self.id, term.start_at, term.end_at).count 
+      end
+    when :current_term
+      term = Term.current_term
+      if term
+        sum = Reserve.where("manifestation_id = ? AND created_at >= ? AND created_at <= ?", self.id, term.start_at, term.end_at).count 
+      end
+    end
+    return sum
+  end
+
+ def checkout_count(type)
+    sum = 0
+    case type
+    when nil
+    when :all
+      self.items.all.each {|item| sum += Checkout.where(:item_id=>item.id).count} 
+    when :previous_term
+      term = Term.previous_term
+      if term
+        self.items.all.each {|item| sum += Checkout.where("item_id = ? AND created_at >= ? AND created_at <= ?", item.id, term.start_at, term.end_at).count }
+      end
+    when :current_term
+      term = Term.current_term
+      if term
+        self.items.all.each {|item| sum += Checkout.where("item_id = ? AND created_at >= ? AND created_at <= ?", item.id, term.start_at, term.end_at).count } 
+      end
+    end
+    return sum
+  end
+
+  def next_item_for_retain(lib)
+    items = self.items_ordered_for_retain(lib)
+    items.each do |item|
+      return item if item.available_for_checkout? && item.circulation_status != CirculationStatus.find(:first, :conditions => ["name = ?", 'Available For Pickup'])
+    end
+    return nil
+  end
+
+  def items_ordered_for_retain(lib = nil)
+    if lib.nil?
+      items = self.items
+    else
+      items = self.items.for_retain_from_own(lib).concat(self.items.for_retain_from_others(lib)).flatten
+    end
+  end
+ 
+  def ordered?
+    self.purchase_requests.each do |p|
+      return true if p.state == "ordered"
+    end
+    return false
+  end
+
+private
+  def delete_attachment?
+    self.attachment.clear if @delete_attachment == "1"
+  end
+
+  def self.get_manifestation_list_pdf(manifestations, current_user)
+    report = ThinReports::Report.new :layout => File.join(Rails.root, 'report', 'searchlist.tlf')
+
+    # set page_num
+    report.events.on :page_create do |e|
+      e.page.item(:page).value(e.page.no)
+    end
+    report.events.on :generate do |e|
+      e.pages.each do |page|
+        page.item(:total).value(e.report.page_count)
+      end
+    end
+
+    report.start_new_page do |page|
+      page.item(:date).value(Time.now)
+      manifestations.each do |manifestation|
+        page.list(:list).add_row do |row|
+          # modified data format
+          item_identifiers = manifestation.items.map{|item| item.item_identifier}
+          creator = manifestation.creators.readable_by(current_user).map{|patron| patron.full_name}
+          contributor = manifestation.contributors.readable_by(current_user).map{|patron| patron.full_name}
+          publisher = manifestation.publishers.readable_by(current_user).map{|patron| patron.full_name}
+          # set list
+          row.item(:title).value(manifestation.original_title)
+          row.item(:item_identifier).value(item_identifiers.join(','))
+          row.item(:creator).value(creator.join(','))
+          row.item(:contributor).value(contributor.join(','))
+          row.item(:publisher).value(publisher.join(','))
+          row.item(:pub_date).value(manifestation.pub_date)
+          row.item(:reserves_num).value(Reserve.waiting.where(:manifestation_id => manifestation.id, :checked_out_at => nil).count)
+        end
+      end
+    end
+    return report
+  end
+
+  def self.get_manifestation_list_tsv(manifestations, current_user)
+    data = String.new
+    data << "\xEF\xBB\xBF".force_encoding("UTF-8") + "\n"
+
+    columns = [
+      [:title, 'activerecord.attributes.manifestation.original_title'],
+      [:item_identifier, 'activerecord.attributes.item.item_identifier'],
+      [:creator, 'patron.creator'],
+      [:contributor, 'patron.contributor'],
+      [:publisher, 'patron.publisher'],
+      [:pub_date, 'activerecord.attributes.manifestation.pub_date'],
+      [:reserves_num, 'activerecord.attributes.manifestation.reserves_number']
+    ]
+
+    # title column
+    row = columns.map{|column| I18n.t(column[1])}
+    data << '"' + row.join("\"\t\"") +"\"\n"
+
+    manifestations.each do |manifestation|
+      row = []
+      columns.each do |column|
+        case column[0]
+        when :title 
+          row << manifestation.original_title 
+        when :item_identifier
+          item_identifiers = manifestation.items.map{|item| item.item_identifier}
+          row << item_identifiers.join(',')
+        when :creator
+          creator = manifestation.creators.readable_by(current_user).map{|patron| patron.full_name}
+          row << creator.join(',')
+        when :contributor
+          contributor = manifestation.contributors.readable_by(current_user).map{|patron| patron.full_name}
+          row << contributor.join(',')
+        when :publisher
+          publisher = manifestation.publishers.readable_by(current_user).map{|patron| patron.full_name}
+          row << publisher.join(',')
+        when :pub_date
+          row << manifestation.pub_date
+        when :reserves_num
+          row << Reserve.waiting.where(:manifestation_id => manifestation.id, :checked_out_at => nil).count
+        end
+      end
+      data << '"' + row.join("\"\t\"") +"\"\n"
+    end
+    return data
+  end
+
+  def self.get_manifestation_locate(manifestation, current_user)
+    report = ThinReports::Report.new :layout => File.join(Rails.root, 'report', 'manifestation.tlf')
+   
+    # footer
+    report.layout.config.list(:list) do
+      use_stores :total => 0
+      events.on :footer_insert do |e|
+        e.section.item(:date).value(Time.now.strftime('%Y/%m/%d %H:%M'))
+      end
+    end
+    # main
+    report.start_new_page do |page|
+      # set manifestation_information
+      7.times { |i|
+        label, data = "", ""
+        page.list(:list).add_row do |row|
+          case i
+          when 0
+            label = I18n.t('activerecord.attributes.manifestation.original_title')
+            data  = manifestation.original_title
+          when 1
+            label = I18n.t('patron.creator')
+            data  = manifestation.creators.readable_by(current_user).map{|patron| patron.full_name}
+            data  = data.join(",")
+          when 2
+            label = I18n.t('patron.publisher')
+            data  = manifestation.publishers.readable_by(current_user).map{|patron| patron.full_name}
+            data  = data.join(",")
+          when 3
+            label = I18n.t('activerecord.attributes.manifestation.price')
+            data  = manifestation.price
+          when 4
+            label = I18n.t('activerecord.attributes.manifestation.page')
+            data  = manifestation.number_of_pages.to_s + 'p' if manifestation.number_of_pages
+          when 5
+            label = I18n.t('activerecord.attributes.manifestation.size')
+            data  = manifestation.height.to_s + 'cm' if manifestation.height
+          when 6
+            label = I18n.t('activerecord.attributes.series_statement.original_title')
+            data  = manifestation.series_statement.original_title if manifestation.series_statement
+          when 7
+            label = I18n.t('activerecord.attributes.manifestation.isbn')
+            data  = manifestation.isbn
+          end
+          row.item(:label).show
+          row.item(:data).show
+          row.item(:dot_line).hide
+          row.item(:description).hide
+          row.item(:label).value(label.to_s + ":")
+          row.item(:data).value(data)
+        end
+      }
+
+      # set description
+      if manifestation.description
+        # make space
+        page.list(:list).add_row do |row|
+          row.item(:label).hide
+          row.item(:data).hide
+          row.item(:dot_line).hide
+          row.item(:description).hide
+        end
+        # set
+        max_column = 20
+        cnt, str_num = 0.0, 0
+        str = manifestation.description
+        while str.length > max_column
+          str.length.times do |i|
+            cnt += 0.5 if str[i] =~ /^[\s0-9A-Za-z]+$/
+            cnt += 1 unless str[i] =~ /^[\s0-9A-Za-z]+$/
+            if cnt.to_f >= max_column or str[i+1].nil? or str[i] =~ /^[\n]+$/
+              str_num = i + 1 if cnt.to_f == max_column or str[i+1].nil? or str[i] =~ /^[\n]+$/
+              str_num = i if cnt.to_f > max_column
+              page.list(:list).add_row do |row|
+                row.item(:label).hide
+                row.item(:data).hide
+                row.item(:dot_line).hide
+                row.item(:description).show
+                row.item(:description).value(str[0...str_num].chomp)
+              end
+              str = str[str_num...str.length]
+              cnt, str_num = 0.0, 0
+              break
+            end
+          end
+        end
+        page.list(:list).add_row do |row|
+          row.item(:label).hide
+          row.item(:data).hide
+          row.item(:dot_line).hide
+          row.item(:description).show
+          row.item(:description).value(str)
+        end
+      end
+
+      # set item_information
+      manifestation.items.each do |item|
+        6.times { |i|
+          label, data = "", ""
+          page.list(:list).add_row do |row|
+            row.item(:label).show
+            row.item(:data).show
+            row.item(:dot_line).hide
+            row.item(:description).hide
+            case i
+            when 0
+              row.item(:label).hide
+              row.item(:data).hide
+              row.item(:dot_line).show
+            when 1
+              label = I18n.t('activerecord.models.library')
+              data  = item.shelf.library.display_name.localize
+            when 2
+              label = I18n.t('activerecord.models.shelf')
+              data  = item.shelf.display_name.localize
+            when 3
+              label = I18n.t('activerecord.attributes.item.call_number')
+              data  = item.call_number
+            when 4
+              label = I18n.t('activerecord.attributes.item.item_identifier')
+              data  = item.item_identifier
+            when 5
+              label = I18n.t('activerecord.models.circulation_status')
+              data  = item.circulation_status.display_name.localize
+            end
+            row.item(:label).value(label.to_s + ":")
+            row.item(:data).value(data)
+          end
+        }
+      end
+    end
+    return report 
+  end
+end
+
+# == Schema Information
+#
+# Table name: manifestations
+#
+#  id                              :integer         not null, primary key
+#  original_title                  :text            not null
+#  title_alternative               :text
+#  title_transcription             :text
+#  classification_number           :string(255)
+#  identifier                      :string(255)
+#  date_of_publication             :datetime
+#  date_copyrighted                :datetime
+#  created_at                      :datetime
+#  updated_at                      :datetime
+#  deleted_at                      :datetime
+#  access_address                  :string(255)
+#  language_id                     :integer         default(1), not null
+#  carrier_type_id                 :integer         default(1), not null
+#  extent_id                       :integer         default(1), not null
+#  start_page                      :integer
+#  end_page                        :integer
+#  height                          :decimal(, )
+#  width                           :decimal(, )
+#  depth                           :decimal(, )
+#  isbn                            :string(255)
+#  isbn10                          :string(255)
+#  wrong_isbn                      :string(255)
+#  nbn                             :string(255)
+#  lccn                            :string(255)
+#  oclc_number                     :string(255)
+#  issn                            :string(255)
+#  price                           :integer
+#  fulltext                        :text
+#  volume_number_string              :string(255)
+#  issue_number_string               :string(255)
+#  serial_number_string              :string(255)
+#  edition                         :integer
+#  note                            :text
+#  produces_count                  :integer         default(0), not null
+#  exemplifies_count               :integer         default(0), not null
+#  embodies_count                  :integer         default(0), not null
+#  work_has_subjects_count         :integer         default(0), not null
+#  repository_content              :boolean         default(FALSE), not null
+#  lock_version                    :integer         default(0), not null
+#  required_role_id                :integer         default(1), not null
+#  state                           :string(255)
+#  required_score                  :integer         default(0), not null
+#  frequency_id                    :integer         default(1), not null
+#  subscription_master             :boolean         default(FALSE), not null
+#  ipaper_id                       :integer
+#  ipaper_access_key               :string(255)
+#  attachment_file_name            :string(255)
+#  attachment_content_type         :string(255)
+#  attachment_file_size            :integer
+#  attachment_updated_at           :datetime
+#  nii_type_id                     :integer
+#  title_alternative_transcription :text
+#  description                     :text
+#  abstract                        :text
+#  available_at                    :datetime
+#  valid_until                     :datetime
+#  date_submitted                  :datetime
+#  date_accepted                   :datetime
+#  date_caputured                  :datetime
+#  file_hash                       :string(255)
+#  pub_date                        :string(255)
+#  periodical_master               :boolean         default(FALSE), not null
+#
+