enju_circulation 0.1.0.pre36 → 0.1.0.pre37

data/app/models/reserve.rb

@@ -1,46 +1,46 @@
 # -*- encoding: utf-8 -*-
 class Reserve < ActiveRecord::Base
+  include Statesman::Adapters::ActiveRecordModel
   attr_accessible :manifestation_id, :user_number, :expired_at
-  attr_accessible :expired_at, :as => :user_update
+  attr_accessible :expired_at, as: :user_update
   attr_accessible :manifestation_id, :item_identifier, :user_number,
     :expired_at, :request_status_type, :canceled_at, :checked_out_at,
     :expiration_notice_to_patron, :expiration_notice_to_library, :item_id,
     :retained_at, :postponed_at, :force_retaining,
-    :as => :admin
+    as: :admin
   scope :hold, where('item_id IS NOT NULL')
-  scope :not_hold, where(:item_id => nil)
-  scope :waiting, where('canceled_at IS NULL AND expired_at > ? AND state != ?', Time.zone.now, 'completed').order('reserves.id DESC')
-  scope :retained, where('retained_at IS NOT NULL AND state = ?', 'retained')
-  scope :completed, where('checked_out_at IS NOT NULL AND state = ?', 'completed')
-  scope :canceled, where('canceled_at IS NOT NULL AND state = ?', 'canceled')
-  scope :postponed, where('postponed_at IS NOT NULL AND state = ?', 'postponed')
-  scope :will_expire_retained, lambda {|datetime| {:conditions => ['checked_out_at IS NULL AND canceled_at IS NULL AND expired_at <= ? AND state = ?', datetime, 'retained'], :order => 'expired_at'}}
-  scope :will_expire_pending, lambda {|datetime| {:conditions => ['checked_out_at IS NULL AND canceled_at IS NULL AND expired_at <= ? AND state = ?', datetime, 'pending'], :order => 'expired_at'}}
-  scope :created, lambda {|start_date, end_date| {:conditions => ['created_at >= ? AND created_at < ?', start_date, end_date]}}
-  scope :not_sent_expiration_notice_to_patron, where(:state => 'expired', :expiration_notice_to_patron => false)
-  scope :not_sent_expiration_notice_to_library, where(:state => 'expired', :expiration_notice_to_library => false)
-  scope :sent_expiration_notice_to_patron, where(:state => 'expired', :expiration_notice_to_patron => true)
-  scope :sent_expiration_notice_to_library, where(:state => 'expired', :expiration_notice_to_library => true)
-  scope :not_sent_cancel_notice_to_agent, where(:state => 'canceled', :expiration_notice_to_patron => false)
-  scope :not_sent_cancel_notice_to_library, where(:state => 'canceled', :expiration_notice_to_library => false)
-
-  belongs_to :user #, :validate => true
-  belongs_to :manifestation #, :validate => true
-  belongs_to :librarian, :class_name => 'User' #, :validate => true
-  belongs_to :item #, :validate => true
+  scope :not_hold, where(item_id: nil)
+  scope :waiting, -> {not_in_state(:completed, :expired).where('canceled_at IS NULL AND expired_at > ?', Time.zone.now).order('reserves.id DESC')}
+  scope :retained, -> {in_state(:retained).where('retained_at IS NOT NULL')}
+  scope :completed, -> {in_state(:completed).where('checked_out_at IS NOT NULL')}
+  scope :canceled, -> {in_state(:canceled).where('canceled_at IS NOT NULL')}
+  scope :postponed, -> {in_state(:postponed).where('postponed_at IS NOT NULL')}
+  scope :will_expire_retained, lambda {|datetime| in_state(:retained).where('checked_out_at IS NULL AND canceled_at IS NULL AND expired_at <= ?', datetime).order('expired_at')}
+  scope :will_expire_pending, lambda {|datetime| in_state(:pending).where('checked_out_at IS NULL AND canceled_at IS NULL AND expired_at <= ?', datetime).order('expired_at')}
+  scope :created, lambda {|start_date, end_date| {conditions: ['created_at >= ? AND created_at < ?', start_date, end_date]}}
+  scope :not_sent_expiration_notice_to_patron, -> {in_state(:expired).where(:expiration_notice_to_patron => false)}
+  scope :not_sent_expiration_notice_to_library, -> {in_state(:expired).where(:expiration_notice_to_library => false)}
+  scope :sent_expiration_notice_to_patron, -> {in_state(:expired).where(:expiration_notice_to_patron => true)}
+  scope :sent_expiration_notice_to_library, -> {in_state(:expired).where(:expiration_notice_to_library => true)}
+  scope :not_sent_cancel_notice_to_patron, -> {in_state(:canceled).where(:expiration_notice_to_patron => false)}
+  scope :not_sent_cancel_notice_to_library, -> {in_state(:canceled).where(:expiration_notice_to_library => false)}
+  belongs_to :user
+  belongs_to :manifestation, touch: true
+  belongs_to :librarian, class_name: 'User'
+  belongs_to :item, touch: true
   belongs_to :request_status_type
 
   validates_associated :user, :librarian, :request_status_type
-  validates :manifestation, :associated => true #, :on => :create
+  validates :manifestation, :associated => true #, on: :create
   validates_presence_of :user, :request_status_type
-  validates :manifestation, :presence => true, :unless => Proc.new{|reserve|
+  validates :manifestation, presence: true, :unless => Proc.new{|reserve|
     reserve.completed?
   }
-  #validates_uniqueness_of :manifestation_id, :scope => :user_id
-  validates_date :expired_at, :allow_blank => true
+  #validates_uniqueness_of :manifestation_id, scope: :user_id
+  validates_date :expired_at, allow_blank: true
   validate :manifestation_must_include_item
-  validate :available_for_reservation?, :on => :create
-  validates :item_id, :presence => true, :if => Proc.new{|reserve|
+  validate :available_for_reservation?, on: :create
+  validates :item_id, presence: true, :if => Proc.new{|reserve|
     if item_id_changed?
       if reserve.completed? or reserve.retained?
         unless item_id_change[0]
@@ -59,63 +59,25 @@ class Reserve < ActiveRecord::Base
       end
     end
   }
-  validates :item_id, :uniqueness => {:scope => :state, :allow_blank => true},
-    :if => Proc.new{|reserve|
-      return false unless reserve.state_changed?
-      return true if reserve.completed? or reserve.retained?
-    }
   validate :valid_item?
   validate :retained_by_other_user?
-  before_validation :set_manifestation, :on => :create
+  before_validation :set_manifestation, on: :create
   before_validation :set_item, :set_expired_at
-  before_validation :set_user, :on => :update
-  before_validation :set_request_status, :on => :create
+  before_validation :set_user, on: :update
+  before_validation :set_request_status, on: :create
 
   attr_accessor :user_number, :item_identifier, :force_retaining
 
-  state_machine :initial => :pending do
-    before_transition [:pending, :postponed] => :requested, :do => :do_request
-    before_transition :retained => :postponed, :do => :postpone
-    before_transition [:pending, :requested, :retained, :postponed] => :retained, :do => :retain
-    before_transition [:pending ,:requested, :retained, :postponed] => :canceled, :do => :cancel
-    before_transition [:pending, :requested, :retained, :postponed] => :expired, :do => :expire
-    before_transition :retained => :completed, :do => :checkout
-    after_transition any => any do |reserve, transition|
-      if Rails.env == 'production'
-        ExpireFragmentCache.expire_fragment_cache(reserve.manifestation)
-      end
-    end
-
-    after_transition any => [:requested, :canceled, :retained, :postponed] do |reserve, transition|
-      reserve.send_message
-    end
-
-    event :sm_request do
-      transition [:pending, :requested] => :requested
-    end
-
-    event :sm_retain do
-      transition [:pending, :requested, :retained, :postponed] => :retained
-    end
-
-    event :sm_cancel do
-      transition [:pending, :requested, :retained, :postponed] => :canceled
-    end
-
-    event :sm_expire do
-      transition [:pending, :requested, :retained, :postponed] => :expired
-    end
-
-    event :sm_postpone do
-      transition :retained => :postponed
-    end
+  paginates_per 10
 
-    event :sm_complete do
-      transition [:pending, :requested, :retained] => :completed
-    end
+  def state_machine
+    ReserveStateMachine.new(self, transition_class: ReserveTransition)
   end
 
-  paginates_per 10
+  has_many :reserve_transitions
+
+  delegate :can_transition_to?, :transition_to!, :transition_to, :current_state,
+    to: :state_machine
 
   searchable do
     text :username do
@@ -125,7 +87,7 @@ class Reserve < ActiveRecord::Base
       user.try(:username)
     end
     string :user_number do
-      user.try(:user_number)
+      user.profile.try(:user_number)
     end
     time :created_at
     text :item_identifier do
@@ -137,7 +99,9 @@ class Reserve < ActiveRecord::Base
     boolean :hold do |reserve|
       self.hold.include?(reserve)
     end
-    string :state
+    string :state do
+      current_state
+    end
     string :title_transcription do
       manifestation.try(:title_transcription)
     end
@@ -150,7 +114,7 @@ class Reserve < ActiveRecord::Base
   def set_item
     identifier = item_identifier.to_s.strip
     if identifier.present?
-      item = Item.where(:item_identifier => identifier).first
+      item = Item.where(item_identifier: identifier).first
       self.item = item
     end
   end
@@ -158,14 +122,13 @@ class Reserve < ActiveRecord::Base
   def set_user
     number = user_number.to_s.strip
     if number.present?
-      user = User.where(:user_number => number).first
-      self.user = user
+      self.user = Profile.where(user_number: number).first.try(:user)
     end
   end
 
   def valid_item?
     if item_identifier.present?
-      item = Item.where(:item_identifier => item_identifier).first
+      item = Item.where(item_identifier: item_identifier).first
       errors[:base] << I18n.t('reserve.invalid_item') unless item
     end
   end
@@ -173,24 +136,24 @@ class Reserve < ActiveRecord::Base
   def retained_by_other_user?
     return nil if force_retaining == '1'
     if item and !retained?
-      if Reserve.retained.where(:item_id => item.item_identifier).count > 0
+      if Reserve.retained.where(item_id: item.item_identifier).count > 0
         errors[:base] << I18n.t('reserve.attempt_to_update_retained_reservation')
       end
     end
   end
 
   def set_request_status
-    self.request_status_type = RequestStatusType.where(:name => 'In Process').first
+    self.request_status_type = RequestStatusType.where(name: 'In Process').first
   end
 
   def set_expired_at
-    if self.user and self.manifestation
-      if self.canceled_at.blank?
-        if self.expired_at.blank?
-          expired_period = self.manifestation.reservation_expired_period(self.user)
+    if user and manifestation
+      if canceled_at.blank?
+        if expired_at.blank?
+          expired_period = manifestation.reservation_expired_period(user)
           self.expired_at = (expired_period + 1).days.from_now.beginning_of_day
         elsif !completed?
-          if self.expired_at.beginning_of_day < Time.zone.now
+          if expired_at.beginning_of_day < Time.zone.now
             errors[:base] << I18n.t('reserve.invalid_date')
           end
         end
@@ -200,70 +163,71 @@ class Reserve < ActiveRecord::Base
 
   def next_reservation
     if item
-      Reserve.waiting.where(:manifestation_id => item.manifestation.id).first
+      Reserve.waiting.where(:manifestation_id => item.manifestation.id).readonly(false).first
     end
   end
 
   def send_message(sender = nil)
     sender = User.find(1) unless sender # TODO: システムからのメッセージの発信者
     Reserve.transaction do
-      case state
+      case current_state
       when 'requested'
-        message_template_to_agent = MessageTemplate.localized_template('reservation_accepted_for_patron', user.locale)
+        message_template_to_agent = MessageTemplate.localized_template('reservation_accepted_for_patron', user.profile.locale)
         request = MessageRequest.new
-        request.assign_attributes({:sender => sender, :receiver => user, :message_template => message_template_to_agent}, :as => :admin)
-        request.save_message_body(:manifestations => Array[manifestation], :user => user)
-        request.sm_send_message! # 受付時は即時送信
-        message_template_to_library = MessageTemplate.localized_template('reservation_accepted_for_library', user.locale)
+        request.assign_attributes({sender: sender, receiver: user, message_template: message_template_to_agent}, as: :admin)
+        request.save_message_body(manifestations: Array[manifestation], user: user)
+        request.transition_to!(:sent) # 受付時は即時送信
+        message_template_to_library = MessageTemplate.localized_template('reservation_accepted_for_library', user.profile.locale)
         request = MessageRequest.new
-        request.assign_attributes({:sender => sender, :receiver => sender, :message_template => message_template_to_library}, :as => :admin)
-        request.save_message_body(:manifestations => Array[manifestation], :user => user)
-        request.sm_send_message! # 受付時は即時送信
+        request.assign_attributes({sender: sender, receiver: sender, message_template: message_template_to_library}, as: :admin)
+        request.save_message_body(manifestations: Array[manifestation], user: user)
+        request.transition_to!(:sent) # 受付時は即時送信
       when 'canceled'
-        message_template_to_agent = MessageTemplate.localized_template('reservation_canceled_for_patron', user.locale)
+        message_template_to_agent = MessageTemplate.localized_template('reservation_canceled_for_patron', user.profile.locale)
         request = MessageRequest.new
-        request.assign_attributes({:sender => sender, :receiver => user, :message_template => message_template_to_agent}, :as => :admin)
-        request.save_message_body(:manifestations => Array[manifestation], :user => user)
-        request.sm_send_message! # キャンセル時は即時送信
-        message_template_to_library = MessageTemplate.localized_template('reservation_canceled_for_library', user.locale)
+        request.assign_attributes({sender: sender, receiver: user, message_template: message_template_to_agent}, as: :admin)
+        request.save_message_body(manifestations: Array[manifestation], user: user)
+        request.transition_to!(:sent) # キャンセル時は即時送信
+        message_template_to_library = MessageTemplate.localized_template('reservation_canceled_for_library', user.profile.locale)
         request = MessageRequest.new
-        request.assign_attributes({:sender => sender, :receiver => sender, :message_template => message_template_to_library}, :as => :admin)
-        request.save_message_body(:manifestations => Array[manifestation], :user => user)
-        request.sm_send_message! # キャンセル時は即時送信
+        request.assign_attributes({sender: sender, receiver: sender, message_template: message_template_to_library}, as: :admin)
+        request.save_message_body(manifestations: Array[manifestation], user: user)
+        request.transition_to!(:sent) # キャンセル時は即時送信
       when 'expired'
-        message_template_to_agent = MessageTemplate.localized_template('reservation_expired_for_patron', user.locale)
+        message_template_to_agent = MessageTemplate.localized_template('reservation_expired_for_patron', user.profile.locale)
         request = MessageRequest.new
-        request.assign_attributes({:sender => sender, :receiver => user, :message_template => message_template_to_agent}, :as => :admin)
-        request.save_message_body(:manifestations => Array[manifestation], :user => user)
-        request.sm_send_message!
+        request.assign_attributes({sender: sender, receiver: user, message_template: message_template_to_agent}, as: :admin)
+        request.save_message_body(manifestations: Array[manifestation], user: user)
+        request.transition_to!(:sent)
+        reload
         self.update_attribute(:expiration_notice_to_patron, true)
-        message_template_to_library = MessageTemplate.localized_template('reservation_expired_for_library', sender.locale)
+        message_template_to_library = MessageTemplate.localized_template('reservation_expired_for_library', sender.profile.locale)
         request = MessageRequest.new
-        request.assign_attributes({:sender => sender, :receiver => sender, :message_template => message_template_to_library}, :as => :admin)
-        request.save_message_body(:manifestations => Array[manifestation], :user => sender)
-        request.sm_send_message!
+        request.assign_attributes({sender: sender, receiver: sender, message_template: message_template_to_library}, as: :admin)
+        request.save_message_body(manifestations: Array[manifestation], user: sender)
+        request.transition_to!(:sent)
       when 'retained'
-        message_template_for_patron = MessageTemplate.localized_template('item_received_for_patron', user.locale)
+        message_template_for_patron = MessageTemplate.localized_template('item_received_for_patron', user.profile.locale)
         request = MessageRequest.new
-        request.assign_attributes({:sender => sender, :receiver => user, :message_template => message_template_for_patron}, :as => :admin)
-        request.save_message_body(:manifestations => Array[item.manifestation], :user => user)
-        request.sm_send_message!
-        message_template_for_library = MessageTemplate.localized_template('item_received_for_library', user.locale)
+        request.assign_attributes({sender: sender, receiver: user, message_template: message_template_for_patron}, as: :admin)
+        request.save_message_body(manifestations: Array[item.manifestation], user: user)
+        request.transition_to!(:sent)
+        message_template_for_library = MessageTemplate.localized_template('item_received_for_library', user.profile.locale)
         request = MessageRequest.new
-        request.assign_attributes({:sender => sender, :receiver => sender, :message_template => message_template_for_library}, :as => :admin)
-        request.save_message_body(:manifestations => Array[item.manifestation], :user => user)
-        request.sm_send_message!
+        request.assign_attributes({sender: sender, receiver: sender, message_template: message_template_for_library}, as: :admin)
+        request.save_message_body(manifestations: Array[item.manifestation], user: user)
+        request.transition_to!(:sent)
       when 'postponed'
-        message_template_for_patron = MessageTemplate.localized_template('reservation_postponed_for_patron', user.locale)
+        message_template_for_patron = MessageTemplate.localized_template('reservation_postponed_for_patron', user.profile.locale)
         request = MessageRequest.new
-        request.assign_attributes({:sender => sender, :receiver => user, :message_template => message_template_for_patron}, :as => :admin)
-        request.save_message_body(:manifestations => Array[manifestation], :user => user)
-        request.sm_send_message!
-        message_template_for_library = MessageTemplate.localized_template('reservation_postponed_for_library', user.locale)
+        request.assign_attributes({sender: sender, receiver: user, message_template: message_template_for_patron}, as: :admin)
+        request.save_message_body(manifestations: Array[manifestation], user: user)
+        request.transition_to!(:sent)
+        message_template_for_library = MessageTemplate.localized_template('reservation_postponed_for_library', user.profile.locale)
         request = MessageRequest.new
-        request.assign_attributes({:sender => sender, :receiver => sender, :message_template => message_template_for_library}, :as => :admin)
-        request.save_message_body(:manifestations => Array[manifestation], :user => user)
-        request.sm_send_message!
+        request.assign_attributes({sender: sender, receiver: sender, message_template: message_template_for_library}, as: :admin)
+        request.save_message_body(manifestations: Array[manifestation], user: user)
+        request.transition_to!(:sent)
       else
         raise 'status not defined'
       end
@@ -274,19 +238,19 @@ class Reserve < ActiveRecord::Base
     sender = User.find(1) # TODO: システムからのメッセージの発信者
     case status
     when 'expired'
-      message_template_to_library = MessageTemplate.localized_template('reservation_expired_for_library', sender.locale)
+      message_template_to_library = MessageTemplate.localized_template('reservation_expired_for_library', sender.profile.locale)
       request = MessageRequest.new
-      request.assign_attributes({:sender => sender, :receiver => sender, :message_template => message_template_to_library}, :as => :admin)
-      request.save_message_body(:manifestations => options[:manifestations])
-      self.not_sent_expiration_notice_to_library.each do |reserve|
+      request.assign_attributes({sender: sender, receiver: sender, message_template: message_template_to_library}, as: :admin)
+      request.save_message_body(manifestations: options[:manifestations])
+      self.not_sent_expiration_notice_to_library.readonly(false).each do |reserve|
         reserve.expiration_notice_to_library = true
-        reserve.save(:validate => false)
+        reserve.save(validate: false)
       end
     #when 'canceled'
     #  message_template_to_library = MessageTemplate.localized_template('reservation_canceled_for_library', sender.locale)
     #  request = MessageRequest.new
-    #  request.assign_attributes({:sender => sender, :receiver => sender, :message_template => message_template_to_library}, :as => :admin)
-    #  request.save_message_body(:manifestations => self.not_sent_expiration_notice_to_library.collect(&:manifestation))
+    #  request.assign_attributes({sender: sender, receiver: sender, message_template: message_template_to_library}, as: :admin)
+    #  request.save_message_body(manifestations: self.not_sent_expiration_notice_to_library.collect(&:manifestation))
     #  self.not_sent_cancel_notice_to_library.each do |reserve|
     #    reserve.update_attribute(:expiration_notice_to_library, true)
     #  end
@@ -297,19 +261,19 @@ class Reserve < ActiveRecord::Base
 
   def self.expire
     Reserve.transaction do
-      self.will_expire_retained(Time.zone.now.beginning_of_day).map{|r| r.sm_expire!}
-      self.will_expire_pending(Time.zone.now.beginning_of_day).map{|r| r.sm_expire!}
+      self.will_expire_retained(Time.zone.now.beginning_of_day).readonly(false).map{|r| r.transition_to!(:expired)}
+      self.will_expire_pending(Time.zone.now.beginning_of_day).readonly(false).map{|r| r.transition_to!(:expired)}
 
       # キューに登録した時点では本文は作られないので
       # 予約の連絡をすませたかどうかを識別できるようにしなければならない
       # reserve.send_message('expired')
       User.find_each do |user|
         unless user.reserves.not_sent_expiration_notice_to_patron.empty?
-          user.send_message('reservation_expired_for_patron', :manifestations => user.reserves.not_sent_expiration_notice_to_patron.collect(&:manifestation))
+          user.send_message('reservation_expired_for_patron', manifestations: user.reserves.not_sent_expiration_notice_to_patron.collect(&:manifestation))
         end
       end
       unless Reserve.not_sent_expiration_notice_to_library.empty?
-        Reserve.send_message_to_library('expired', :manifestations => Reserve.not_sent_expiration_notice_to_library.collect(&:manifestation))
+        Reserve.send_message_to_library('expired', manifestations: Reserve.not_sent_expiration_notice_to_library.collect(&:manifestation))
       end
     end
   #rescue
@@ -343,27 +307,27 @@ class Reserve < ActiveRecord::Base
   end
 
   def completed?
-    ['canceled', 'expired', 'completed'].include?(state)
+    ['canceled', 'expired', 'completed'].include?(current_state)
   end
 
   def retained?
-    return true if state == 'retained'
+    return true if current_state == 'retained'
     false
   end
 
   private
   def do_request
-    self.assign_attributes({:request_status_type => RequestStatusType.where(:name => 'In Process').first, :item_id => nil, :retained_at => nil}, :as => :admin)
+    self.assign_attributes({:request_status_type => RequestStatusType.where(name: 'In Process').first, item_id: nil, :retained_at => nil}, as: :admin)
     save!
   end
 
   def retain
     # TODO: 「取り置き中」の状態を正しく表す
-    self.assign_attributes({:request_status_type => RequestStatusType.where(:name => 'In Process').first, :retained_at => Time.zone.now}, :as => :admin)
+    self.assign_attributes({:request_status_type => RequestStatusType.where(name: 'In Process').first, :retained_at => Time.zone.now}, as: :admin)
     Reserve.transaction do
       if item.try(:next_reservation)
         reservation = item.next_reservation
-        reservation.sm_postpone!
+        reservation.transition_to!(:postponed)
       end
       save!
     end
@@ -371,13 +335,13 @@ class Reserve < ActiveRecord::Base
 
   def expire
     Reserve.transaction do
-      self.assign_attributes({:request_status_type => RequestStatusType.where(:name => 'Expired').first, :canceled_at => Time.zone.now}, :as => :admin)
+      self.assign_attributes({:request_status_type => RequestStatusType.where(name: 'Expired').first, :canceled_at => Time.zone.now}, as: :admin)
       reserve = next_reservation
       if reserve
         reserve.item = item
         self.item = nil
         save!
-        reserve.sm_retain!
+        reserve.transition_to!(:retained)
       end
     end
     logger.info "#{Time.zone.now} reserve_id #{self.id} expired!"
@@ -385,30 +349,30 @@ class Reserve < ActiveRecord::Base
 
   def cancel
     Reserve.transaction do
-      self.assign_attributes({:request_status_type => RequestStatusType.where(:name => 'Cannot Fulfill Request').first, :canceled_at => Time.zone.now}, :as => :admin)
+      self.assign_attributes({:request_status_type => RequestStatusType.where(name: 'Cannot Fulfill Request').first, :canceled_at => Time.zone.now}, as: :admin)
       save!
       reserve = next_reservation
       if reserve
         reserve.item = item
         self.item = nil
         save!
-        reserve.sm_retain!
+        reserve.transition_to!(:retained)
       end
     end
   end
 
   def checkout
-    self.assign_attributes({:request_status_type => RequestStatusType.where(:name => 'Available For Pickup').first, :checked_out_at => Time.zone.now}, :as => :admin)
+    self.assign_attributes({:request_status_type => RequestStatusType.where(name: 'Available For Pickup').first, :checked_out_at => Time.zone.now}, as: :admin)
     save!
   end
 
   def postpone
     self.assign_attributes({
-      :request_status_type => RequestStatusType.where(:name => 'In Process').first,
-      :item_id => nil,
+      :request_status_type => RequestStatusType.where(name: 'In Process').first,
+      item_id: nil,
       :retained_at => nil,
       :postponed_at => Time.zone.now
-    }, :as => :admin)
+    }, as: :admin)
     save!
   end
 
@@ -421,6 +385,10 @@ class Reserve < ActiveRecord::Base
   if defined?(EnjuInterLibraryLoan)
     has_one :inter_library_loan
   end
+
+  def self.transition_class
+    ReserveTransition
+  end
 end
 
 # == Schema Information
@@ -438,11 +406,9 @@ end
 #  canceled_at                  :datetime
 #  expired_at                   :datetime
 #  deleted_at                   :datetime
-#  state                        :string(255)
 #  expiration_notice_to_patron  :boolean          default(FALSE)
 #  expiration_notice_to_library :boolean          default(FALSE)
 #  retained_at                  :datetime
 #  postponed_at                 :datetime
 #  lock_version                 :integer          default(0), not null
 #
-

data/app/models/reserve_stat_has_manifestation.rb

@@ -1,11 +1,11 @@
 class ReserveStatHasManifestation < ActiveRecord::Base
   attr_accessible
   attr_accessible :manifestation_reserve_stat_id, :manifestation_id,
-    :as => :admin
+    as: :admin
   belongs_to :manifestation_reserve_stat
   belongs_to :manifestation
 
-  validates_uniqueness_of :manifestation_id, :scope => :manifestation_reserve_stat_id
+  validates_uniqueness_of :manifestation_id, scope: :manifestation_reserve_stat_id
   validates_presence_of :manifestation_reserve_stat_id, :manifestation_id
 
   paginates_per 10

data/app/models/reserve_stat_has_user.rb

@@ -1,11 +1,11 @@
 class ReserveStatHasUser < ActiveRecord::Base
   attr_accessible
   attr_accessible :user_reserve_stat_id, :user_id,
-    :as => :admin
+    as: :admin
   belongs_to :user_reserve_stat
   belongs_to :user
 
-  validates_uniqueness_of :user_id, :scope => :user_reserve_stat_id
+  validates_uniqueness_of :user_id, scope: :user_reserve_stat_id
   validates_presence_of :user_reserve_stat_id, :user_id
 
   paginates_per 10

data/app/models/reserve_state_machine.rb

@@ -0,0 +1,93 @@
+class ReserveStateMachine
+  include Statesman::Machine
+  state :pending, initial: true
+  state :postponed
+  state :requested
+  state :retained
+  state :canceled
+  state :expired
+  state :completed
+
+  transition from: :pending, to: [:requested]
+  transition from: :postponed, to: [:requested, :retained, :canceled, :expired]
+  transition from: :retained, to: [:postponed, :canceled, :expired, :completed]
+  transition from: :requested, to: [:retained, :canceled, :expired, :completed]
+
+  after_transition(to: :requested) do |reserve|
+    reserve.update_attributes({request_status_type: RequestStatusType.where(name: 'In Process').first, item_id: nil, retained_at: nil}, as: :admin)
+  end
+
+  after_transition(to: :retained) do |reserve|
+    # TODO: 「取り置き中」の状態を正しく表す
+    reserve.update_attributes({request_status_type: RequestStatusType.where(name: 'In Process').first, retained_at: Time.zone.now}, as: :admin)
+    Reserve.transaction do
+      if reserve.item and reserve.next_reservation
+        reserve.item.reserves.waiting.readonly(false).map{|r|
+          if r != reserve
+            r.transition_to!(:postponed)
+            r.item = nil
+            r.save!
+          end
+        }
+      end
+    end
+  end
+
+  after_transition(to: :canceled) do |reserve|
+    Reserve.transaction do
+      reserve.update_attributes({request_status_type: RequestStatusType.where(name: 'Cannot Fulfill Request').first, canceled_at: Time.zone.now}, as: :admin)
+      next_reserve = reserve.next_reservation
+      if next_reserve
+        next_reserve.item = reserve.item
+        reserve.item = nil
+        reserve.save!
+        next_reserve.transition_to!(:retained)
+      end
+    end
+  end
+
+  after_transition(to: :expired) do |reserve|
+    Reserve.transaction do
+      reserve.update_attributes({request_status_type: RequestStatusType.where(name: 'Expired').first, canceled_at: Time.zone.now}, as: :admin)
+      next_reserve = reserve.next_reservation
+      if next_reserve
+        next_reserve.item = reserve.item
+        next_reserve.transition_to!(:retained)
+        reserve.item = nil
+        reserve.save!
+      end
+    end
+    Rails.logger.info "#{Time.zone.now} reserve_id #{reserve.id} expired!"
+  end
+
+  after_transition(to: :postponed) do |reserve|
+    reserve.update_attributes(item_id: nil, retained_at: nil, postponed_at: Time.zone.now, force_retaining: "1", as: :admin)
+  end
+
+  after_transition(to: :completed) do |reserve|
+    reserve.update_attributes(
+      request_status_type: RequestStatusType.where(name: 'Available For Pickup').first,
+      checked_out_at: Time.zone.now,
+      as: :admin)
+  end
+
+  after_transition(to: :requested) do |reserve|
+    reserve.send_message
+  end
+
+  after_transition(to: :expired) do |reserve|
+    reserve.send_message
+  end
+
+  after_transition(to: :postponed) do |reserve|
+    reserve.send_message
+  end
+
+  after_transition(to: :canceled) do |reserve|
+    reserve.send_message
+  end
+
+  after_transition(to: :retained) do |reserve|
+    reserve.send_message
+  end
+end

data/app/models/reserve_transition.rb

@@ -0,0 +1,20 @@
+class ReserveTransition < ActiveRecord::Base
+  include Statesman::Adapters::ActiveRecordTransition
+
+  
+  belongs_to :reserve, inverse_of: :reserve_transitions
+  attr_accessible :to_state, :sort_key, :metadata
+end
+
+# == Schema Information
+#
+# Table name: reserve_transitions
+#
+#  id         :integer          not null, primary key
+#  to_state   :string(255)
+#  metadata   :text             default("{}")
+#  sort_key   :integer
+#  reserve_id :integer
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#