enju_trunk_message 0.1.14.pre3

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,9 @@
+// This is a manifest file that'll be compiled into including all the files listed below.
+// Add new JavaScript/Coffee code in separate files in this directory and they'll automatically
+// be included in the compiled file accessible from http://example.com/assets/application.js
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,7 @@
+/*
+ * This is a manifest file that'll automatically include all the stylesheets available in this directory
+ * and any sub-directories. You're free to add application-wide styles to this file and they'll appear at
+ * the top of the compiled file, but it's generally better to create a new file per style scope.
+ *= require_self
+ *= require_tree . 
+*/

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,52 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+
+  rescue_from CanCan::AccessDenied, :with => :render_403
+  rescue_from ActiveRecord::RecordNotFound, :with => :render_404
+
+  private
+  def render_403
+    return if performed?
+    if user_signed_in?
+      respond_to do |format|
+        format.html {render :template => 'page/403', :status => 403}
+        format.mobile {render :template => 'page/403', :status => 403}
+        format.xml {render :template => 'page/403', :status => 403}
+        format.json
+      end
+    else
+      respond_to do |format|
+        format.html {redirect_to new_user_session_url}
+        format.mobile {redirect_to new_user_session_url}
+        format.xml {render :template => 'page/403', :status => 403}
+        format.json
+      end
+    end
+  end
+
+  def render_404
+    return if performed?
+    respond_to do |format|
+      format.html {render :template => 'page/404', :status => 404}
+      format.mobile {render :template => 'page/404', :status => 404}
+      format.xml {render :template => 'page/404', :status => 404}
+      format.json
+    end
+  end
+
+  def get_user
+    @user = User.where(:username => params[:user_id]).first if params[:user_id]
+  end
+
+  def solr_commit
+    Sunspot.commit
+  end
+
+  def move_position(resource, direction)
+    if ['higher', 'lower'].include?(direction)
+      resource.send("move_#{direction}")
+      redirect_to url_for(:controller => resource.class.to_s.pluralize.underscore)
+      return
+    end
+  end
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/dummy/app/mailers/notifier.rb

@@ -0,0 +1,30 @@
+class Notifier < ActionMailer::Base
+  include Resque::Mailer
+  if LibraryGroup.site_config.try(:url)
+    uri = Addressable::URI.parse(LibraryGroup.site_config.url)
+    default_url_options[:host] = uri.host
+    default_url_options[:port] = uri.port
+  else
+    default_url_options[:host] = 'library.example.jp'
+    default_url_options[:port] = 80
+  end
+
+  def message_notification(message_id)
+    message = Message.find(message_id)
+    I18n.locale = message.receiver.locale.try(:to_sym) || I18n.default_locale
+    from = "#{LibraryGroup.system_name(message.receiver.locale)} <#{LibraryGroup.site_config.email}>"
+    if message.subject
+      subject = message.subject
+    else
+      subject = I18n.t('message.new_message_from_library', :library => LibraryGroup.system_name(message.receiver.user.locale))
+    end
+    if message.sender
+      @sender_name = message.sender.full_name
+    else
+      @sender_name = LibraryGroup.system_name(message.receiver.locale)
+    end
+    @message = message
+    @locale = message.receiver.locale
+    mail(:from => from, :to => message.receiver.email, :subject => subject)
+  end
+end

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

@@ -0,0 +1,30 @@
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    case user.try(:role).try(:name)
+    when 'Administrator'
+      can :manage, Message
+      can [:read, :update, :destroy], MessageRequest
+      can [:read, :update], MessageTemplate
+    when 'Librarian'
+      can [:index, :create], Message
+      can [:update], Message do |message|
+        message.sender == user
+      end
+      can [:show, :destroy], Message do |message|
+        message.receiver == user
+      end
+      can [:read, :update, :destroy], MessageRequest
+      can :read, MessageTemplate
+    when 'User'
+      can [:read, :destroy], Message do |message|
+        message.receiver == user
+      end
+      can :index, Message
+      can :show, Message do |message|
+        message.receiver == user
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# -*- 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
+#  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/patron.rb

@@ -0,0 +1,167 @@
+# -*- encoding: utf-8 -*-
+class Patron < ActiveRecord::Base
+  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]}}
+  belongs_to :user
+  belongs_to :patron_type
+  belongs_to :required_role, :class_name => 'Role', :foreign_key => 'required_role_id', :validate => true
+
+  validates_presence_of :patron_type
+  validates_associated :patron_type
+  validates :full_name, :presence => true, :length => {:maximum => 255}
+  validates :user_id, :uniqueness => true, :allow_nil => true
+  validates :email, :format => {:with => /^([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})$/i}, :allow_blank => true
+  before_validation :set_role_and_name, :on => :create
+
+  #has_paper_trail
+  attr_accessor :user_username
+  #[:address_1, :address_2].each do |column|
+  #  encrypt_with_public_key column,
+  #    :key_pair => File.join(Rails.root.to_s,'config','keypair.pem'),
+  #    :base64 => true
+  #end
+
+  searchable do
+    text :name, :place, :address_1, :address_2, :other_designation, :note
+    string :zip_code_1
+    string :zip_code_2
+    string :username do
+      user.username if user
+    end
+    time :created_at
+    time :updated_at
+    string :user
+    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 :required_role_id
+    integer :patron_type_id
+  end
+
+  def self.per_page
+    10
+  end
+
+  def full_name_without_space
+    full_name.gsub(/\s/, "")
+  end
+
+  def set_role_and_name
+    self.required_role = Role.where(:name => 'Librarian').first if self.required_role_id.nil?
+    set_full_name
+  end
+
+  def set_full_name
+    if self.full_name.blank?
+      if self.last_name.to_s.strip and self.first_name.to_s.strip and Setting.family_name_first == true
+        self.full_name = [last_name, middle_name, first_name].compact.join(" ").to_s.strip
+      else
+        self.full_name = [first_name, last_name, middle_name].compact.join(" ").to_s.strip
+      end
+    end
+    if self.full_name_transcription.blank?
+      self.full_name_transcription = [last_name_transcription, middle_name_transcription, first_name_transcription].join(" ").to_s.strip
+    end
+    [self.full_name, self.full_name_transcription]
+  end
+
+  def full_name_without_space
+    full_name.gsub(/\s/, "")
+  #  # TODO: 日本人以外は？
+  #  name = []
+  #  name << self.last_name.to_s.strip
+  #  name << self.middle_name.to_s.strip
+  #  name << self.first_name.to_s.strip
+  #  name << self.corporate_name.to_s.strip
+  #  name.join("").strip
+  end
+
+  def full_name_transcription_without_space
+    full_name_transcription.to_s.gsub(/\s/, "")
+  end
+
+  def full_name_alternative_without_space
+    full_name_alternative.to_s.gsub(/\s/, "")
+  end
+
+  def name
+    name = []
+    name << full_name.to_s.strip
+    name << full_name_transcription.to_s.strip
+    name << full_name_alternative.to_s.strip
+    #name << full_name_without_space
+    #name << full_name_transcription_without_space
+    #name << full_name_alternative_without_space
+    #name << full_name.wakati rescue nil
+    #name << full_name_transcription.wakati rescue nil
+    #name << full_name_alternative.wakati rescue nil
+    name
+  end
+
+  def date
+    if date_of_birth
+      if date_of_death
+        "#{date_of_birth} - #{date_of_death}"
+      else
+        "#{date_of_birth} -"
+      end
+    end
+  end
+
+  def creator?(resource)
+    resource.creators.include?(self)
+  end
+
+  def publisher?(resource)
+    resource.publishers.include?(self)
+  end
+
+  def check_required_role(user)
+    return true if self.user.blank?
+    return true if self.user.required_role.name == 'Guest'
+    return true if user == self.user
+    return true if user.has_role?(self.user.required_role.name)
+    false
+  rescue NoMethodError
+    false
+  end
+
+  def created(work)
+    creates.where(:work_id => work.id).first
+  end
+
+  def realized(expression)
+    realizes.where(:expression_id => expression.id).first
+  end
+
+  def produced(manifestation)
+    produces.where(:manifestation_id => manifestation.id).first
+  end
+
+  def owned(item)
+    owns.where(:item_id => item.id)
+  end
+
+  def self.import_patrons(patron_lists)
+    list = []
+    patron_lists.each do |patron_list|
+      patron = Patron.where(:full_name => patron_list[:full_name]).first
+      unless patron
+        patron = Patron.new(
+          :full_name => patron_list[:full_name],
+          :full_name_transcription => patron_list[:full_name_transcription],
+          :language_id => 1
+        )
+        patron.required_role = Role.where(:name => 'Guest').first
+        patron.save
+      end
+      list << patron
+    end
+    list
+  end
+
+  def patrons
+    self.original_patrons + self.derived_patrons
+  end
+end

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

@@ -0,0 +1,19 @@
+class PatronType < ActiveRecord::Base
+  include MasterModel
+  default_scope :order => "patron_types.position"
+  has_many :patrons
+end
+
+# == Schema Information
+#
+# Table name: patron_types
+#
+#  id           :integer         not null, primary key
+#  name         :string(255)     not null
+#  display_name :text
+#  note         :text
+#  position     :integer
+#  created_at   :datetime
+#  updated_at   :datetime
+#
+

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

@@ -0,0 +1,8 @@
+class Role < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :name
+
+  def self.default_role
+    Role.find('Guest')
+  end
+end

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

@@ -0,0 +1,4 @@
+class Setting < Settingslogic
+  source "#{Rails.root}/config/application.yml"
+  namespace Rails.env
+end

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

@@ -0,0 +1,46 @@
+class User < ActiveRecord::Base
+  # Include default devise modules. Others available are:
+  # :token_authenticatable, :encryptable, :confirmable, :lockable, :timeoutable and :omniauthable
+  devise :database_authenticatable, :registerable,
+         :recoverable, :rememberable, :trackable, :validatable
+
+  # Setup accessible (or protected) attributes for your model
+  attr_accessible :email, :password, :password_confirmation, :remember_me
+
+  has_one :user_has_role
+  has_one :role, :through => :user_has_role
+  has_one :patron
+  belongs_to :user_group
+  belongs_to :required_role, :class_name => 'Role', :foreign_key => 'required_role_id'
+  before_create :set_role_and_patron
+
+  enju_message_user
+
+  extend FriendlyId
+  friendly_id :username
+
+  def set_role_and_patron
+    self.required_role = Role.where(:name => 'Librarian').first
+    self.locale = I18n.default_locale.to_s
+    unless self.patron
+      self.patron = Patron.create(:full_name => self.username) if self.username
+    end
+  end
+
+  def has_role?(role_in_question)
+    return false unless role
+    return true if role.name == role_in_question
+    case role.name
+    when 'Administrator'
+      return true
+    when 'Librarian'
+      return true if role_in_question == 'User'
+    else
+      false
+    end
+  end
+
+  def full_name
+    username
+  end
+end