ccls-ccls_engine 3.11.0

data/app/models/race.rb

@@ -0,0 +1,31 @@
+#	==	requires
+#	*	code ( unique )
+#	*	description ( unique and > 3 chars )
+class Race < ActiveRecordShared
+
+	acts_as_list
+	default_scope :order => :position
+
+	acts_like_a_hash
+
+	validates_presence_of   :code
+	validates_uniqueness_of :code
+	validates_length_of     :code, :maximum => 250, :allow_blank => true
+
+	#	Returns description
+	def to_s
+		description
+	end
+
+	#	Returns description
+	def name
+		description
+	end
+
+	#	Returns boolean of comparison
+	#	true only if key == 'other'
+	def is_other?
+		key == 'other'
+	end
+
+end

data/app/models/refusal_reason.rb

@@ -0,0 +1,23 @@
+#	==	requires
+#	*	description ( unique and > 3 chars )
+class RefusalReason < ActiveRecordShared
+
+	acts_as_list
+	default_scope :order => :position
+
+	acts_like_a_hash
+
+	has_many :enrollments
+
+	#	Returns description
+	def to_s
+		description
+	end
+
+	#	Returns boolean of comparison
+	#	true only if key == 'other'
+	def is_other?
+		key == 'other'
+	end
+
+end

data/app/models/sample.rb

@@ -0,0 +1,168 @@
+#	==	requires
+#	*	enrollment_id
+#	*	unit_id
+class Sample < ActiveRecordShared
+
+	belongs_to :aliquot_sample_format
+	belongs_to :sample_type
+	belongs_to :organization, :foreign_key => 'location_id'
+	belongs_to :unit
+	has_many :aliquots
+	belongs_to :project
+	belongs_to :study_subject
+	belongs_to :sample_temperature
+
+	attr_protected :study_subject_id, :study_subject
+
+	has_one :sample_kit
+	accepts_nested_attributes_for :sample_kit
+
+	named_scope :pending, :conditions => {
+		:received_by_ccls_at => nil }
+		
+	named_scope :collected, :conditions => [
+		'received_by_ccls_at IS NOT NULL' ]
+
+	validates_presence_of :sample_type_id
+	validates_presence_of :sample_type, :if => :sample_type_id
+	validates_presence_of :study_subject_id
+	validates_presence_of :study_subject, :if => :study_subject_id
+	validates_presence_of :project_id
+	validates_presence_of :project, :if => :project_id
+
+	validates_presence_of :sent_to_subject_on,  :if => :collected_at
+	validates_presence_of :collected_at,        :if => :received_by_ccls_at
+	validates_presence_of :location_id,         :if => :sent_to_lab_on
+	validates_presence_of :received_by_ccls_at, :if => :sent_to_lab_on
+	validates_presence_of :sent_to_lab_on,      :if => :received_by_lab_on
+	validates_presence_of :received_by_lab_on,  :if => :aliquotted_on
+
+	#	NOTE I'm not sure how this validation will work for datetimes.
+	validates_complete_date_for :sent_to_subject_on,   :allow_nil => true
+#	validates_complete_date_for :collected_at,         :allow_nil => true
+#	validates_complete_date_for :received_by_ccls_at,  :allow_nil => true
+	validates_complete_date_for :sent_to_lab_on,       :allow_nil => true
+	validates_complete_date_for :received_by_lab_on,   :allow_nil => true
+	validates_complete_date_for :aliquotted_on,        :allow_nil => true
+	validates_complete_date_for :receipt_confirmed_on, :allow_nil => true
+
+	validates_past_date_for :sent_to_subject_on
+	validates_past_date_for :collected_at
+	validates_past_date_for :received_by_ccls_at
+	validates_past_date_for :sent_to_lab_on
+	validates_past_date_for :received_by_lab_on
+	validates_past_date_for :aliquotted_on
+	validates_past_date_for :receipt_confirmed_on
+
+	validate :date_chronology
+
+	#	Returns the parent of this sample type
+	def sample_type_parent
+		sample_type.parent
+	end
+
+	before_save :update_sample_outcome
+
+protected
+
+	def date_chronology
+		errors.add(:collected_at,        "must be after sent_to_subject_on"
+			) if collected_at_is_before_sent_to_subject_on?
+		errors.add(:received_by_ccls_at, "must be after collected_at"
+			) if received_by_ccls_at_is_before_collected_at?
+		errors.add(:sent_to_lab_on,      "must be after received_by_ccls_at"
+			) if sent_to_lab_on_is_before_received_by_ccls_at?
+		errors.add(:received_by_lab_on,  "must be after sent_to_lab_on"
+			) if received_by_lab_on_is_before_sent_to_lab_on?
+		errors.add(:aliquotted_on,       "must be after received_by_lab_on"
+			) if aliquotted_on_is_before_received_by_lab_on?
+	end
+
+#ArgumentError: comparison of Date with ActiveSupport::TimeWithZone failed
+#    app/models/sample.rb:77:in `>'
+#    app/models/sample.rb:77:in `collected_at_is_before_sent_to_subject_on?'
+	def collected_at_is_before_sent_to_subject_on?
+		(( sent_to_subject_on && collected_at ) &&
+			( sent_to_subject_on >  collected_at.to_date ))
+#			( sent_to_subject_on >  collected_at ))
+	end
+
+	def received_by_ccls_at_is_before_collected_at?
+		(( collected_at && received_by_ccls_at ) &&
+			( collected_at >  received_by_ccls_at ))
+	end
+
+	def sent_to_lab_on_is_before_received_by_ccls_at?
+		(( received_by_ccls_at && sent_to_lab_on ) &&
+			( received_by_ccls_at >  sent_to_lab_on ))
+	end
+
+	def received_by_lab_on_is_before_sent_to_lab_on?
+		(( sent_to_lab_on && received_by_lab_on ) &&
+			( sent_to_lab_on >  received_by_lab_on ))
+	end
+
+	def aliquotted_on_is_before_received_by_lab_on?
+		(( received_by_lab_on && aliquotted_on ) &&
+			( received_by_lab_on >  aliquotted_on ))
+	end
+
+	def update_sample_outcome
+
+
+		if study_subject.enrollments.find_by_project_id(Project['HomeExposures'].id)
+#		if enrollment.project_id == Project['HomeExposures'].id
+#			study_subject = enrollment.study_subject
+
+
+			ho = study_subject.homex_outcome || study_subject.create_homex_outcome
+			so,date = if sent_to_lab_on_changed? && !sent_to_lab_on.nil?
+				[SampleOutcome['lab'], sent_to_lab_on ]
+			elsif received_by_ccls_at_changed? && !received_by_ccls_at.nil?
+				[SampleOutcome['received'], received_by_ccls_at ]
+			elsif sent_to_subject_on_changed? && !sent_to_subject_on.nil?
+				[SampleOutcome['sent'], sent_to_subject_on ]
+			end
+			ho.update_attributes({
+				:sample_outcome => so,
+				:sample_outcome_on => date }) if so
+		end
+	end
+
+end
+__END__
+
+
+It appears that the "newer" classes know how to compare with the "older" ones, but not vice versa, which makes sense.
+
+My comparisons in Sample should just have the "newer" class, the *_at field, first and compare it to the "older" *_on field.  OR convert the DateTime to a date.  Comparison of a Date to a DateTime will be confusing as it doesn't just compare the date, it takes the time zone into account which isn't 100% obvious.  I think that it converts it to UTC before comparing.  This could effectively make the comparison incorrect.
+
+YES.  Add a "to_date" to the _at fields.
+
+
+>> Time.now
+=> Tue Mar 06 20:00:06 -0800 2012
+>> Time.now.class
+=> Time
+
+>> Time.zone.now
+=> Wed, 07 Mar 2012 03:54:31 UTC +00:00
+>> Time.zone.now.class
+=> ActiveSupport::TimeWithZone
+
+>> Time.zone.now > Date.today
+=> true
+
+>> Date.today < Time.zone.now
+ArgumentError: comparison of Date with ActiveSupport::TimeWithZone failed
+	from (irb):49:in `<'
+	from (irb):49
+
+>> Date.today < Time.now
+ArgumentError: comparison of Date with Time failed
+	from (irb):50:in `<'
+	from (irb):50
+
+
+Also, even if the *_at field is given a Date value, it will be typecast to ActiveSupport::TimeWithZone so there is no terrible need to update all of the tests.
+

data/app/models/sample_kit.rb

@@ -0,0 +1,14 @@
+# A kit is 2 packages used for retrieving samples.
+class SampleKit < ActiveRecordShared
+
+#	add tracking numbers to kit?
+#	used to be in packages
+#	20120213 - Removing FedEx API, Packages and Tracks.
+
+	belongs_to :sample
+
+	delegate :study_subject, :to => :sample
+
+	validates_uniqueness_of :sample_id, :allow_nil => true
+
+end

data/app/models/sample_outcome.rb

@@ -0,0 +1,16 @@
+# don't know exactly
+class SampleOutcome < ActiveRecordShared
+
+	acts_as_list
+	default_scope :order => :position
+
+	acts_like_a_hash
+
+	has_many :homex_outcomes
+
+	#	Returns description
+	def to_s
+		description
+	end
+
+end

data/app/models/sample_temperature.rb

@@ -0,0 +1,14 @@
+class SampleTemperature < ActiveRecordShared
+
+	acts_as_list
+	default_scope :order => :position
+
+	acts_like_a_hash
+
+	has_many :samples
+
+	def to_s
+		description
+	end
+
+end

data/app/models/sample_type.rb

@@ -0,0 +1,37 @@
+#	==	requires
+#	*	description ( unique and > 3 chars )
+class SampleType < ActiveRecordShared
+
+	acts_as_list :scope => :parent_id
+#	default_scope :order => :position
+	default_scope :order => 'parent_id, position, description ASC'
+
+	acts_like_a_hash
+
+	has_many :samples
+
+	belongs_to :parent, :class_name => 'SampleType'
+	has_many :children, 
+		:class_name => 'SampleType',
+		:foreign_key => 'parent_id',
+		:dependent => :nullify
+	
+	named_scope :roots, :conditions => { :parent_id => nil }
+
+	named_scope :not_roots, :conditions => [
+		'sample_types.parent_id IS NOT NULL' ]
+
+	#	Returns description
+	def to_s
+		description
+	end
+
+	def is_root?
+		parent_id.blank?
+	end
+
+	def is_child?
+		!is_root?
+	end
+
+end

data/app/models/search.rb

@@ -0,0 +1,195 @@
+#
+#	Originally from http://railscasts.com/episodes/111-advanced-search-form
+#	however, I have modified it heavily and made it quite abstract.
+#	Its still a bit muddy, but I'd like to replace it with rsolr.
+#
+class Search
+
+	class << self
+		def valid_orders
+			@valid_orders
+		end
+		def valid_orders=(more_orders)
+			@valid_orders = more_orders
+		end
+		def searchable_attributes
+			@searchable_attributes
+		end
+		def searchable_attributes=(more_attributes)
+			@searchable_attributes = more_attributes
+		end
+		def attr_accessors
+			@attr_accessors
+		end
+		def attr_accessors=(more_accessors)	#	extend with += [ :something ] NOT << :something
+			@attr_accessors = more_accessors
+			attr_accessor *@attr_accessors
+		end
+	end
+	self.valid_orders = HashWithIndifferentAccess.new
+	self.searchable_attributes = []
+	self.attr_accessors = [ :order, :dir, :includes, :paginate, :per_page, :page ]
+
+	def valid_orders
+		self.class.valid_orders
+	end
+
+	def searchable_attributes
+		self.class.searchable_attributes
+	end
+
+	def attr_accessors
+		self.class.attr_accessors
+	end
+
+	def search_order
+		if valid_orders.has_key?(@order)
+			order_string = if valid_orders[@order].blank?
+				@order
+			else
+				valid_orders[@order]
+			end
+			dir = case @dir.try(:downcase)
+				when 'desc' then 'desc'
+				else 'asc'
+			end
+			[order_string,dir].join(' ')
+		else
+			nil
+		end
+	end
+
+private
+
+	def paginate?
+		(@paginate.nil?) ? true : @paginate
+	end
+
+	def initialize(options={})
+		self.class.send('attr_accessor', *searchable_attributes)
+		options.each do |attr,value|
+			if attr_accessors.include?(attr.to_sym) ||
+				searchable_attributes.include?(attr.to_sym)
+				self.send("#{attr}=",value)
+			end
+		end
+	end
+
+	def self.inherited(subclass)
+		#	USE DUP! Without it, the two will share the same object_id
+		#	resulting is cross contamination
+		subclass.searchable_attributes = searchable_attributes.dup
+		subclass.attr_accessors = attr_accessors.dup
+		subclass.valid_orders = valid_orders.dup
+		#	Create 'shortcut'
+		#	StudySubjectSearch(options) -> StudySubjectSearch.new(options)
+		Object.class_eval do
+			define_method subclass.to_s do |*args|
+				subclass.send(:new,*args)
+			end
+		end
+	end
+
+	#	This may work for the simple stuff, but I suspect
+	#	that once things get complicated, it will unravel.
+
+	def conditions
+		[conditions_clauses.join(' AND '), *conditions_options]
+	end
+
+	def conditions_clauses
+		conditions_parts.map { |condition| condition.first }
+	end
+
+	def conditions_options
+		#	conditions_parts.map { |condition| condition[1..-1] }.flatten
+		#
+		#	the above flatten breaks the "IN (?)" style search
+		#
+		#	conditions_parts.map { |condition| condition[1..-1] }
+		#	This fixes it, but is kinda bulky
+#		opts = []
+#		conditions_parts.each do |condition|
+#			condition[1..-1].each{|cp| opts << cp}
+#		end
+#		opts 
+		#	That's better!
+		parts = conditions_parts.map { |condition| condition[1..-1] }.flatten(1)
+
+#	The "parts" contain the variables inserted in the query.
+#	Apparently, we can't mix the ? style with the :var_name style, 
+#	but we can only have 1 trailing hash so we need to merge all
+#	of the trailing hashes.
+
+#		symbol_options = HashWithIndifferentAccess.new
+#		while( !( h = parts.extract_options! ).empty? ) do
+#			symbol_options.merge!(h)
+#		end
+
+#		parts.push(symbol_options)
+
+#		caller is expecting an array
+		[parts.inject(:merge)]
+	end
+
+	def conditions_parts
+		private_methods(false).grep(/_conditions$/).map { |m| send(m) }.compact
+	end
+
+	#	Join order can be important if joining on other joins
+	#	so added a sort.  Added a "a_" to those joins which must go first.
+	#	Crude solution, but a solution nonetheless.
+	def joins
+		private_methods(false).grep(/_joins$/).sort.map { |m| send(m) }.compact
+	end
+
+	def select
+		#	:select - By default, this is "*" as in "SELECT * FROM", 
+		#		but can be changed if you, for example, want to do a join 
+		#		but not include the joined columns. Takes a string with the 
+		#		SELECT SQL fragment (e.g. "id, name").
+		selects = private_methods(false).grep(/_selects$/).sort.map { |m| send(m) }.compact
+		#	select CANNOT be ''
+		#	ActiveRecord::StatementInvalid: Mysql::Error: You have an error in your SQL syntax; 
+		#		check the manual that corresponds to your MySQL server version for the right 
+		#		syntax to use near 'FROM `study_subjects`   LIMIT 0, 25' at line 1: 
+		#		SELECT  FROM `study_subjects`   LIMIT 0, 25
+		#	nil will cause default use of '*', which could also be passed
+		( selects.empty? ) ? nil : selects.join(',')
+	end
+
+	def group
+		#	:group - An attribute name by which the result should be grouped. 
+		#		Uses the GROUP BY SQL-clause
+		groups = private_methods(false).grep(/_groups$/).sort.map { |m| send(m) }.compact
+		#	ActiveRecord::StatementInvalid: Mysql::Error: You have an error in your SQL syntax; 
+		#		check the manual that corresponds to your MySQL server version for the right 
+		#		syntax to use near '' at line 1: SELECT * FROM `study_subjects`  GROUP BY
+		#	nil will cause group by to not be used
+		( groups.empty? ) ? nil : groups.join(',')
+	end
+
+	def having
+		#	:having - Combined with :group this can be used to filter the records 
+		#		that a GROUP BY returns. Uses the HAVING SQL-clause.
+		#	this is very similar to :conditions/WHERE so may have to add all of the
+		#	conditions_* methods to handle
+		[having_clauses.join(' AND '), *having_options]
+	end
+
+	def having_clauses
+		having_parts.map { |condition| condition.first }
+	end
+
+	def having_options
+		parts = having_parts.map { |condition| condition[1..-1] }.flatten(1)
+#	just like conditions, these parts need to be hashes of symbol names
+#	for use in the sql command.  Not ?.
+		[parts.inject(:merge)]
+	end
+
+	def having_parts
+		private_methods(false).grep(/_havings$/).map { |m| send(m) }.compact
+	end
+
+end