Test Model C0 Coverage Information - RCov

 require 'util/persistence'

 require 'util/money'

 require 'util/today'

 require 'model/slentry'

 require 'model/ean13'

 require 'model/feedback_observer'

 require 'model/part'

 module ODDB

 	class PackageCommon

 		include Persistence

     @@ddd_galforms = /tabletten?/iu

 		class << self

 			def price_internal(price, type=nil)

         unless(price.is_a?(Util::Money))

           price = Util::Money.new(price, type, 'CH')

         price

 			def registration_data(*names)

 				names.each { |name|

 					define_method(name) { 

 						if(@sequence && (reg = @sequence.registration))

 							reg.send(name)

 			end

 			def sequence_data(*names)

 				names.each { |name|

 					define_method(name) { 

 						@sequence && @sequence.send(name)

 			end

 		attr_reader :ikscd,  :sl_entry, :narcotics, :parts, :pharmacode

 		attr_accessor :sequence, :ikscat, :generic_group, :sl_generic_type,

 		alias :pointer_descr :ikscd

 		registration_data :comarketing_with, :complementary_type, :expiration_date,

     sequence_data :atc_class, :basename, :company, :composition_text, :ddds,

 		def initialize(ikscd)

 			super()

 			@ikscd = sprintf('%03d', ikscd.to_i)

 			@narcotics = []

       @parts = []

 		def active?

                     || @market_date <= @@today)

 		end

     def active_agents

       @parts.inject([]) { |acts, part| acts.concat part.active_agents }

     end

 		def add_narcotic(narc)

 		def barcode

 			if(key = ikskey)

 				Ean13.new_unchecked('7680'+key).to_s

 		end

 		def checkout

 			checkout_helper([@generic_group], :remove_package)

 				narc.remove_package(self)

 			} if @narcotics

       @parts.dup.each { |part|

         part.checkout

         part.odba_delete

       @parts.odba_delete

 			if(@sl_entry.respond_to?(:checkout))

 				@sl_entry.checkout 

 				@sl_entry.odba_delete

     def commercial_forms

       @parts.collect { |part| part.commercial_form }

     end

 		def company_name

 			(cmp = company) && cmp.name

 		end

     def compositions

       @parts.inject([]) { |comps, part| comps.push part.composition }.compact

     end

     def comparable?(bottom, top, pack)

       begin

           && (other = pack.comparable_size) \

           && bottom < other \

           && top > other \

           && !pack.basename.nil?

     end

     def comparables

       cs = comparable_size

       bottom = cs * 0.75

       top = cs * 1.25

       comparables = generic_group_comparables

       @sequence.comparables.each { |seq|

         comparables.concat seq.public_packages.select { |pack|

           comparable?(bottom, top, pack)

       comparables.concat @sequence.public_packages.select { |pack|

         comparable?(bottom, top, pack)

       comparables.uniq

     def comparable_size

       @parts.collect { |part| part.comparable_size }.inject{ |a, b| a + b } or raise RuntimeError

       @parts.inject(Dose.new(0)) { |comp, part|

         ODDB::Dose.new(comp.qty + part.comparable_size.qty)

       } rescue nil

     end

     def create_part

       part = Part.new

       part.package = self

       @parts.push part

       part

 		def create_sl_entry

 			@sl_entry = SlEntry.new

 		end

     def ddd

       if (atc = atc_class) && atc.has_ddd?

         atc.ddds['O']

     end

 		def ddd_price

 			if(!@disable_ddd_price && (ddd = self.ddd) \

 				&& (grp = galenic_group) && grp.match(@@ddd_galforms) \

 				&& (price = price_public) && (ddose = ddd.dose) && (mdose = dose) \

         && size = comparable_size)

         factor = (longevity || 1).to_f

         if(mdose > (ddose * factor))

           (price / size.to_f) \

             * (ddose.to_f * factor / mdose.want(ddose.unit).to_f) / factor

 		end

     def delete_part(oid)

       @parts.delete_if { |comp| comp.oid == oid }

     end

 		def delete_sl_entry

 			@sl_entry = nil

       @deductible = nil

       @sl_generic_type = nil

       reg = @sequence.registration

       unless reg.nil? || reg.packages.any? do |pac| pac.sl_entry end

 			self.odba_isolated_store

 			nil

     def dose

       @ddd_dose || (@sequence.dose if @sequence)

     end

     def fix_pointers

       @pointer = @sequence.pointer + [:package, @ikscd]

       if(sl = @sl_entry)

         sl.pointer = @pointer + [:sl_entry]

         sl.odba_store

       @parts.each { |part|

         part.fix_pointers

       odba_store

     def generic_group_comparables(filters=[])

         && !((go = data_origins['generic_group']) && filters.include?(go))

         @generic_group.packages - [self]

         []

     end

 		def good_result?(query)

 			query = query.to_s.downcase

 			basename.to_s.downcase[0,query.length] == query

     def has_generic?

       @generic_type == :original && !comparables.empty?

     end

     def ikscd=(ikscd)

       if(/^[0-9]{3}$/u.match(ikscd))

         pacs = @sequence.packages

         pacs.delete(@ikscd)

         pacs.store(ikscd, self)

         pacs.odba_store

         @out_of_trade = false

         @ikscd = ikscd

         fix_pointers

     end

 		def localized_name(language)

 			@sequence.localized_name(language)

 		end

 		def ikskey

 			if(nr = iksnr)

 				nr + @ikscd

 		end

 		def limitation

 			@sl_entry.limitation unless @sl_entry.nil?

 		end

 		def limitation_text

 			@sl_entry.limitation_text unless @sl_entry.nil?

 		end

 		def most_precise_dose

 			@pretty_dose || dose

 		end

     def name_with_size

       [name_base, size].join(', ')

     end

 		def narcotic?

 			@narcotics.any? { |narc| narc.category == 'a' }

 		end

     def part(oid)

       @parts.find { |part| part.oid == oid }

     end

     def pharmacode= pcode

       @pharmacode = pcode ? pcode.to_i.to_s : nil

     end

     def preview?

       @preview_with_market_date && @market_date && @market_date > @@today

     end

 		def public?

       active? && (@refdata_override || !@out_of_trade \

                   || registration.active?)

 		end

 		def remove_narcotic(narc)

 			if(res = @narcotics.delete(narc))

 				@narcotics.odba_isolated_store

 				narc.remove_package(self)

 			res

     def size

       @parts.collect { |part| part.size }.compact.join(' + ')

     end

 		def substances

 			active_agents.collect { |active| active.substance }.compact

 		end

 		def <=>(other)

 			[self.basename, self.dose.to_f, self.comparable_size.to_f] <=> \

 				[other.basename, other.dose.to_f, other.comparable_size.to_f]

 		end

 		private

 		def adjust_types(values, app=nil)

 			values = values.dup

 			values.each { |key, value|

 				when :generic_group

 					values[key] = value.resolve(app)

 				when :price_public, :price_exfactory

 					values[key] = Package.price_internal(value, key)

 				when :pretty_dose, :ddd_dose

 					values[key] = if(value.is_a? Dose)

 						value

 					elsif(value.is_a?(Array))

 						Dose.new(*value)

 				end unless(value.nil?)

 			values

 	class Package < PackageCommon

     ODBA_SERIALIZABLE = [ '@prices', '@ancestors', '@swissmedic_source' ]

     include ODBA::Persistable ## include directly to get odba_index

     odba_index :pharmacode

     odba_index :name_with_size

 		attr_accessor :medwin_ikscd, :ancestors

 		include FeedbackObserver

 		def initialize(ikscd)

 			super

 			@feedbacks = []

 		def checkout

 			super

 			if(@feedbacks)

 				@feedbacks.dup.each { |fb| fb.item = nil; fb.odba_store }

 				@feedbacks.odba_delete

 		def generic_group=(generic_group)

 			unless(@generic_group.nil?)

 				@generic_group.remove_package(self)

 			unless(generic_group.nil?)

 				generic_group.add_package(self)

 			@generic_group = generic_group

     def has_price?

       prices.any? do |key, values| !values.empty? end

     end

     def has_price_history?

       prices.any? do |key, values| values.size > 1 end

     end

     def price(type, ord_or_time=0)

       candidates = (prices[type] ||= [])

       if(ord_or_time.is_a?(Time))

         candidates.find { |price| price.valid_from < ord_or_time }

         candidates[ord_or_time.to_i]

     def price_exfactory(ord_or_time=0)

       price(:exfactory, ord_or_time)

     end

     def price_exfactory=(price)

       return price_exfactory if(price == price_exfactory)

       (prices[:exfactory] ||= []).unshift(price)

       price

     def price_public(ord_or_time=0)

       price(:public, ord_or_time)

     end

     def price_public=(price)

       return price_public if(price == price_public)

       (prices[:public] ||= []).unshift(price)

       price

     def prices

       @prices ||= {}

     end