kete_trackable_items 0.0.1

data/app/controllers/trackable_item_shelf_locations_controller.rb

@@ -0,0 +1,64 @@
+class TrackableItemShelfLocationsController < ApplicationController
+  # Prevents the following error from showing up, common in Rails engines
+  # A copy of ApplicationController has been removed from the module tree but is still active!
+  unloadable
+
+  def new
+    if params[:trackable_item].present?
+      @trackable_item = params[:trackable_item][:type].constantize.find(params[:trackable_item][:id])
+    end
+
+    @repositories = appropriate_repositories_for_basket
+
+    @trackable_item_shelf_location = @trackable_item ? @trackable_item.trackable_item_shelf_locations.build : TrackableItemShelfLocation.new
+  end
+  
+  def create
+    repository_id = params[:trackable_item_shelf_location].delete(:repository_id)
+    code = params[:trackable_item_shelf_location].delete(:code)
+
+    if repository_id.present?
+      @repository = Repository.find(repository_id)
+      @repositories = [@repository]
+    end
+
+    if @repository.present? && code.present?
+      @shelf_location = @repository.shelf_locations.find_by_code(code)
+      params[:trackable_item_shelf_location][:shelf_location_id] = @shelf_location ? @shelf_location.id : nil
+    end
+
+    @trackable_item_shelf_location = TrackableItemShelfLocation.new(params[:trackable_item_shelf_location])
+    @trackable_item = @trackable_item_shelf_location.trackable_item
+
+    if @trackable_item_shelf_location.save
+      redirect_to url_for_dc_identifier(@trackable_item)
+    else
+      render :action => 'new'
+    end
+  end
+
+  def update
+    @trackable_item_shelf_location = TrackableItemShelfLocation.find(params[:id])
+
+    if params[:event]
+      original_state = @trackable_item_shelf_location.current_state
+      event_method = params[:event] + '!'
+      @trackable_item_shelf_location.send(event_method)
+      @successful = @trackable_item_shelf_location.current_state != original_state
+      @state_change_failed = @succesful
+    else
+      @successful = @trackable_item_shelf_location.update_attributes(params[:shelf_location])
+    end
+    
+    if @successful || @state_change_failed
+      flash[:notice] = t('shelf_locations.update.state_change_failed', :event_transition => params[:event].humanize) if @state_change_failed
+
+      url = repository_shelf_location_url(:id => @trackable_item_shelf_location.shelf_location,
+                                          :repository_id => @trackable_item_shelf_location.shelf_location.repository)
+      redirect_to url
+    else
+      render :action => 'edit'
+    end
+  end
+  
+end

data/app/controllers/tracked_items_controller.rb

@@ -0,0 +1,44 @@
+class TrackedItemsController < ApplicationController
+  # Prevents the following error from showing up, common in Rails engines
+  # A copy of ApplicationController has been removed from the module tree but is still active!
+  unloadable
+  
+  before_filter :get_tracked_item, :except => [:create]
+  before_filter :get_trackable_item
+  before_filter :get_tracking_list
+  
+  def create
+    tracked_item = @trackable_item.tracked_items.build(@tracking_list)
+
+    if tracked_item.save
+      redirect_to tracking_list_url(:id => @tracking_list)
+    end
+  end
+
+  def destroy
+    tracked_item = @trackable_item.tracked_items.find(@tracked_item)
+    tracked_item.destroy unless tracked_item.nil?
+
+    # TODO: this redirect may need to redirect a different place in some contexts
+    redirect_to repository_tracking_list_url(:id => @tracking_list, :repository_id => @tracking_list.repository)
+  end
+
+  private
+  
+  def get_tracked_item
+    @tracked_item = TrackedItem.find(params[:id])
+  end
+
+  def get_trackable_item
+    if @tracked_item
+      @trackable_item = @tracked_item.trackable_item
+    else
+      type = params[:tracked_item_type]
+      @trackable_item ||= type.classify.constantize.find(params[:tracked_item_id])
+    end
+  end
+  
+  def get_tracking_list
+    @tracking_list ||= TrackingList.find(params[:tracking_list_id])
+  end
+end

data/app/controllers/tracking_lists_controller.rb

@@ -0,0 +1,88 @@
+class TrackingListsController < ApplicationController
+  # Prevents the following error from showing up, common in Rails engines
+  # A copy of ApplicationController has been removed from the module tree but is still active!
+  unloadable
+
+  include KeteTrackableItems::MatchingTrackableItemsControllerHelpers
+
+  before_filter :set_repository
+  before_filter :set_tracking_list, :except => [:index, :create]
+
+  def index
+    @tracking_lists = TrackingList.all
+  end
+
+  def show
+    unless params[:format] == 'xls'
+      @possible_events = @tracking_list.current_state.events.keys.collect(&:to_s).sort
+    end
+
+    # xls support as outlined in http://www.arydjmal.com/blog/export-to-excel-in-rails-2
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xls { render :layout => false } if params[:format] == 'xls' # blog post noted that otherwise always interpretted as xls
+    end
+  end
+
+  # unused at this point
+  def new
+    set_matching_trackable_items
+
+    build_items_for_matching_trackable_items_for(@tracking_list, :tracked_items)
+  end
+
+  def create
+    @tracking_list = @repository.tracking_lists.build(params[:tracking_list])
+
+    if @tracking_list.save
+      redirect_to repository_tracking_list_url(:id => @tracking_list,
+                                               :repository_id => @repository)
+    end
+  end
+
+  def edit
+    set_matching_trackable_items
+
+    build_items_for_matching_trackable_items_for(@tracking_list, :tracked_items)
+  end
+
+  # update tracked_items (i.e. add them based on a search)
+  # or run state change
+  def update
+    if params[:event]
+      original_state = @tracking_list.current_state
+      event_method = params[:event] + '!'
+      @tracking_list.send(event_method)
+      @successful = @tracking_list.current_state != original_state
+      @state_change_failed = @succesful
+    else
+      @successful = @tracking_list.update_attributes(params[:tracking_list])
+    end
+    
+    if @successful || @state_change_failed
+      flash[:notice] = t('tracking_lists.update.state_change_failed', :event_transition => params[:event].humanize) if @state_change_failed
+
+      redirect_to repository_tracking_list_url(:id => @tracking_list,
+                                               :repository_id => @repository)
+    else
+      render :action => 'edit'
+    end
+  end
+
+  def destroy
+    @tracking_list.destroy
+
+    # TODO: may need to redirect a different place in some contexts
+    redirect_to repository_tracking_lists_url(:repository_id => @repository)
+  end
+
+  private
+
+  def set_repository
+    @repository = Repository.find(params[:repository_id])
+  end
+
+  def set_tracking_list
+    @tracking_list = @repository.tracking_lists.find(params[:id])
+  end
+end

data/app/helpers/trackable_item_shelf_locations_helper.rb

@@ -0,0 +1,17 @@
+module TrackableItemShelfLocationsHelper
+  def javascript_repository_id_observer_and_adjust_code_autocomplete(urlified_name)
+      javascript_tag("jQuery(document).ready(function(){
+      jQuery(\"#trackable_item_shelf_location_repository_id\").change(
+        function() {
+          jQuery(\"#trackable_item_shelf_location_code\").val('');
+          
+          var repository_id = jQuery(\"#trackable_item_shelf_location_repository_id\").val();
+          var new_shelf_locations_url = \"/#{urlified_name}/repositories/\" + repository_id + \"/shelf_locations.json\";
+          
+          trackable_item_shelf_location_code_auto_completer.url = new_shelf_locations_url;
+
+        });
+
+      });")
+  end
+end

data/app/helpers/trackable_items_helper.rb

@@ -0,0 +1,52 @@
+module TrackableItemsHelper
+  # wrapped in a div to allow for styling the form to be inline
+  def button_to_place_in_shelf_location(trackable_item, additional = false)
+    # whether we should redirect to site basket or not
+    # if no repositories are associated with this basket, specify site
+
+    options = { :trackable_item => { :id => trackable_item.id,
+        :type => trackable_item.class.name } }
+
+    options[:urlified_name] = @site_basket.urlified_name if @current_basket.repositories.count < 1
+
+    button_text = if additional
+                    button_text = t('trackable_items_helper.add_to_additional_shelf_location')
+                  else
+                    button_text = t('trackable_items_helper.add_to_shelf_location')
+                  end
+    "<div class=\"add-to-shelf-location\">" +
+      button_to(button_text,
+                new_trackable_item_shelf_location_url(options)) +
+      "</div>"
+  end
+
+  def shelf_locations_or_appropriate_action(trackable_item)
+    html = String.new
+
+    additional = false
+    if trackable_item.has_shelf_locations?
+      additional = true
+
+      html += '<ul class="shelf-locations">'
+      shelf_locations_count = 1
+      trackable_item.shelf_locations.each do |shelf_location|
+        html += '<li'
+        html += ' class="first"'if shelf_locations_count == 1
+        html += '>'
+
+        html += link_to(shelf_location.code, repository_shelf_location_url(:repository_id => shelf_location.repository_id,
+                                                                           :id => shelf_location,
+                                                                           :urlified_name => shelf_location.repository.basket.urlified_name))
+        html += '</li>'
+        shelf_locations_count += 1
+      end
+
+      html += '</ul>'
+    end
+
+    html += button_to_place_in_shelf_location(trackable_item, additional)
+
+    html
+  end
+
+end

data/app/models/on_loan_organization.rb

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+# name
+# address, contact details?
+# used in Item when current_location is on_loan
+
+# quote from spec: When archives are tracked to “On Loan” additional information is required i.e. to what organization / office they will be loaned to.  This is a list that will need to be maintained by Staff as it could be continually added to. This list may need to be separate for each Archives Repository as to prevent clutter for the other councils.
+class OnLoanOrganization < ActiveRecord::Base
+end

data/app/models/repository.rb

@@ -0,0 +1,11 @@
+# name Archives Central, PNCC, WDC
+# other contact details?
+class Repository < ActiveRecord::Base
+  # we inherit security from our basket
+  # site basket == can see all repositories
+  # otherwise must be associated to the basket we are within
+  belongs_to :basket
+
+  has_many :shelf_locations, :dependent => :destroy
+  has_many :tracking_lists, :dependent => :destroy
+end

data/app/models/shelf_location.rb

@@ -0,0 +1,69 @@
+class ShelfLocation < ActiveRecord::Base
+  include KeteTrackableItems::WorkflowUtilities
+
+  belongs_to :repository
+  has_many :trackable_item_shelf_locations, :dependent => :destroy
+
+  validates_uniqueness_of :code, :case_sensitive => false, :scope => :repository_id
+
+  workflow do
+    state :available do
+      event :allocate, :transitions_to => :allocated
+      event :deactivate, :transitions_to => :deactivated
+    end
+   
+    state :allocated do
+      # probably want to create an instance method for clear_out
+      # that deactivates all trackable_item_shelf_locations
+      event :clear_out, :transitions_to => :available
+      event :deallocate, :transitions_to => :available
+    end
+
+    state :deactivated do
+      event :reactivate, :transitions_to => :available
+    end
+  end
+
+  set_up_workflow_named_scopes.call
+
+  # returns a hash with trackable_item_type as key
+  # and array of ids for that type as value
+  def trackable_items_types_and_ids
+    @trackable_items_types_and_ids = trackable_item_shelf_locations.with_state_active.inject(Hash.new) do |result, mapping_object|
+      type_key = mapping_object.trackable_item_type
+      item_id = mapping_object.trackable_item_id
+
+      values = result[type_key] || Array.new
+      values << item_id
+
+      result[type_key] = values
+      result
+    end
+  end
+
+  # good enough for our purposes
+  # WARNING: this is not a full association, but a hacked together collection
+  def trackable_items
+    @trackable_items = Array.new
+
+    trackable_items_types_and_ids.each do |k,v|
+      @trackable_items += k.constantize.find(v)
+    end
+
+    @trackable_items
+  end
+
+  def new_allocation
+    allocate!
+  end
+
+  def mapping_deactivated_or_destroyed
+    deallocate! if allocated? && trackable_items.size == 0
+  end
+
+  def clear_out
+    trackable_item_shelf_locations.each do |mapping|
+      mapping.make_deactivated
+    end
+  end
+end

data/app/models/trackable_item_shelf_location.rb

@@ -0,0 +1,58 @@
+class TrackableItemShelfLocation < ActiveRecord::Base
+  include KeteTrackableItems::WorkflowUtilities
+
+  after_create :update_state_of_shelf_location_and_trackable_item
+
+  # after destroy, change state of trackable_item and shelf_location
+  after_destroy :send_deactivated_to_associations
+
+  belongs_to :shelf_location
+  belongs_to :trackable_item, :polymorphic => true
+
+  validates_presence_of :shelf_location, :message => lambda { I18n.t('trackable_item_shelf_location.shelf_location_blank_or_does_not_match') }
+  validates_presence_of :trackable_item, :message => lambda { I18n.t('trackable_item_shelf_location.trackable_item_blank_or_does_not_match') }
+
+  # needs to be unique to shelf_location to trackable_item
+  validates_uniqueness_of :shelf_location_id, :scope => [:trackable_item_type, :trackable_item_id], :message => lambda { I18n.t('trackable_item_shelf_location.previously_allocated_reactivate_instead') }
+
+  delegate :repository, :to => :shelf_location, :allow_nil => true
+  delegate :repository_id, :to => :shelf_location, :allow_nil => true
+  delegate :code, :to => :shelf_location, :allow_nil => true
+  delegate :description_for_tracked_item, :to => :trackable_item, :allow_nil => true
+
+  workflow do
+    state :active do
+      event :deactivate, :transitions_to => :deactivated
+    end
+   
+    state :deactivated do
+      event :reactivate, :transitions_to => :active
+    end
+  end
+
+  set_up_workflow_named_scopes.call
+
+  def tell_associations_deactivated_or_destroyed
+    shelf_location.mapping_deactivated_or_destroyed
+    trackable_item.mapping_deactivated_or_destroyed
+  end
+
+  def deactivate
+    tell_associations_deactivated_or_destroyed
+  end
+
+  def make_deactivated
+    deactivate!
+  end
+
+  private
+  
+  def update_state_of_shelf_location_and_trackable_item
+    shelf_location.new_allocation
+    trackable_item.new_allocation
+  end
+
+  def send_deactivated_to_associations
+    tell_associations_deactivated_or_destroyed
+  end
+end

data/app/models/tracked_item.rb

@@ -0,0 +1,18 @@
+class TrackedItem < ActiveRecord::Base
+  belongs_to :tracking_list
+  belongs_to :trackable_item, :polymorphic => true
+  
+  delegate :description_for_tracked_item, :to => :trackable_item
+
+  validates_presence_of :tracking_list, :message => lambda { I18n.t('tracked_item.tracking_list_blank_or_does_not_match') }
+  validates_presence_of :trackable_item, :message => lambda { I18n.t('tracked_item.trackable_item_blank_or_does_not_match') }
+
+  # needs to be unique to tracking_list
+  validates_uniqueness_of :tracking_list_id, :scope => [:trackable_item_type, :trackable_item_id]
+
+  private
+
+  def validate
+    errors.add(:tracking_list, I18n.t('tracked_item.already_in_tracking_list')) if tracking_list.tracked_items.include?(self)
+  end
+end

data/app/models/tracking_list.rb

@@ -0,0 +1,50 @@
+class TrackingList < ActiveRecord::Base
+  include Workflow
+  include KeteTrackableItems::WorkflowUtilities
+
+  belongs_to :repository
+
+  has_many :tracked_items, :dependent => :destroy
+  accepts_nested_attributes_for :tracked_items, :allow_destroy => true
+
+  # set up workflow states, some are shared with trackable_items
+  shared_code_as_string = shared_tracking_workflow_specs_as_string
+  
+  specification = Proc.new {
+    state :new do
+      event :display, :transitions_to => :displayed
+      event :hold_out, :transitions_to => :held_out
+      event :loan, :transitions_to => :on_loan_to_organization
+      event :queue_for_refiling, :transitions_to => :to_be_refiled
+      event :cancel, :transitions_to => :cancelled
+    end
+    
+    eval(shared_code_as_string)
+
+    # we replace to_be_refiled transitions with complete event only
+    state :to_be_refiled do
+      event :refile, :transitions_to => :completed
+    end
+
+    state :cancelled
+    state :completed
+  }
+  
+  workflow(&specification)
+
+  set_up_workflow_named_scopes.call
+
+  # send workflow event, except cancel, to tracked_items
+  # upon event being called on tracking_list
+  workflow_event_names.each do |event_name|
+    unless event_name == 'cancel'
+      code = Proc.new {
+        tracked_items.each do |tracked_item|
+          tracked_item.trackable_item.send("#{event_name}!")
+        end
+      }
+
+      define_method(event_name, &code)
+    end
+  end
+end