Test Util C0 Coverage Information - RCov

 require 'odba'

 require 'odba/index_definition'

 require 'odba/drbwrapper'

 require 'odba/18_19_loading_compatibility'

 require 'custom/lookandfeelbase'

 require 'util/currency'

 require 'util/failsafe'

 require 'util/ipn'

 require 'util/oddbconfig'

 require 'util/searchterms'

 require 'util/session'

 require 'util/updater'

 require 'util/exporter'

 require 'util/validator'

 require 'util/loggroup'

 require 'util/soundex'

 require 'util/iso-latin1'

 require 'util/notification_logger'

 require 'util/ngram_similarity'

 require 'util/today'

 require 'models'

 require 'commands'

 require 'paypal'

 require 'sbsm/drbserver'

 require 'sbsm/index'

 require 'util/config'

 require 'fileutils'

 require 'yaml'

 require 'yus/session'

 require 'model/migel/group'

 require 'model/analysis/group'

 class OddbPrevalence

 	include ODDB::Failsafe

 	include ODBA::Persistable

   RESULT_SIZE_LIMIT = 250

 	ODBA_EXCLUDE_VARS = [

 	ODBA_SERIALIZABLE = [ '@currency_rates', '@rss_updates' ]

 	attr_reader :address_suggestions, :atc_chooser, :atc_classes, :analysis_groups,

 	def initialize

 		init

 		@last_medication_update ||= Time.now()

 	def init

 		create_unknown_galenic_group()

 		@accepted_orphans ||= {}

 		@address_suggestions ||= {}

 		@analysis_groups ||= {}

 		@atc_classes ||= {}

 		@commercial_forms ||= {}

 		@companies ||= {}

 		@currency_rates ||= {}

 		@cyp450s ||= {}

 		@doctors ||= {}

 		@fachinfos ||= {}

     @feedbacks ||= {}

 		@galenic_forms ||= []

 		@galenic_groups ||= []

 		@generic_groups ||= {}

 		@hospitals ||= {}

 		@indications ||= {}

     @indices_therapeutici ||= {}

 		@invoices ||= {}

 		@log_groups ||= {}

 		@migel_groups ||= {}

     @minifis ||= {}

 		@narcotics ||= {}

 		@notification_logger ||= ODDB::NotificationLogger.new

 		@orphaned_fachinfos ||= {}

 		@orphaned_patinfos ||= {}

 		@patinfos ||= {}

 		@patinfos_deprived_sequences ||= []

 		@registrations ||= {}

     @rss_updates ||= {}

 		@slates ||= {}

 		@sponsors ||= {}

 		@substances ||= {}

 		rebuild_atc_chooser()

 	def create(pointer)

 		@last_update = Time.now()

 		failsafe {

 			if(item = pointer.issue_create(self))

 				updated(item)

 				item

 	def delete(pointer)

 		@last_update = Time.now()

 		failsafe(ODDB::Persistence::UninitializedPathError) {

 			if(item = pointer.resolve(self))

 				updated(item)

 			pointer.issue_delete(self)

 	def update(pointer, values, origin=nil)

 		@last_update = Time.now()

 		item = nil

 		failsafe(ODDB::Persistence::UninitializedPathError, nil) {

 			item = pointer.issue_update(self, values, origin)

 			updated(item) unless(item.nil?)

 		item

 	def clean_odba_stubs

 		_clean_odba_stubs_hash(@substances)

 		@substances.each_value { |sub| _clean_odba_stubs_array(sub.sequences) }

 		_clean_odba_stubs_hash(@atc_classes)

 		@atc_classes.each_value { |atc| _clean_odba_stubs_array(atc.sequences) }

 		_clean_odba_stubs_hash(@registrations)

 		@registrations.each_value { |reg|

 			_clean_odba_stubs_hash(reg.sequences)

 			reg.sequences.each_value { |seq|

 				_clean_odba_stubs_hash(seq.packages)

 				_clean_odba_stubs_array(seq.active_agents)

 	def _clean_odba_stubs_hash(hash)

 		if(hash.values.any? { |val| val.odba_instance.nil? })

 			hash.delete_if { |key, val| val.odba_instance.nil? }

 			hash.odba_store

 	end

 	def _clean_odba_stubs_array(array)

 		if(array.any? { |val| val.odba_instance.nil? })

 			array.delete_if { |val| val.odba_instance.nil? }

 			array.odba_store

 	end

 	def admin(oid)

 		@users[oid.to_i]

 	end

 	def admin_subsystem

 		ODBA.cache.fetch_named('admin', self) {

 			ODDB::Admin::Subsystem.new

 	end

   def active_fachinfos

     active = {}

     @registrations.each_value { |reg|

       if(reg.active? && reg.fachinfo)

         active.store(reg.pointer, 1)

     active

 	def active_pdf_patinfos

 		active = {}

 		each_sequence { |seq|

 			if(str = seq.active_patinfo)

 				active.store(str, 1)

 		active

 	def address_suggestion(oid)

 		@address_suggestions[oid.to_i]

 	end

 	def analysis_group(grpcd)

 		@analysis_groups[grpcd]

 	end

 	def analysis_positions

 		@analysis_groups.values.inject([]) { |memo, group| 

 			memo.concat(group.positions.values)

 	end

 	def atcless_sequences

 		ODBA.cache.retrieve_from_index('atcless', 'true')

 	end

 	def atc_class(code)

 		@atc_classes[code]

 	end

 	def atc_ddd_count

 		@atc_ddd_count ||= count_atc_ddd()

 	end

 	def clean_invoices

 		@invoices.delete_if { |oid, invoice| invoice.odba_instance.nil? }

 		deletables = @invoices.values.select { |invoice|

 			invoice.deletable?

 		unless(deletables.empty?)

 			deletables.each { |invoice|

 				delete(invoice.pointer)

 			@invoices.odba_isolated_store

   def commercial_form(oid)

     @commercial_forms[oid.to_i]

   end

   def commercial_form_by_name(name)

     ODDB::CommercialForm.find_by_name(name)

   end

 	def company(oid)

 		@companies[oid.to_i]

 	end

   def company_by_name(name, ngram_cutoff=nil)

     _company_by_name(name, ngram_cutoff) \

       || _company_by_name(name, ngram_cutoff, /\s*(ag|gmbh|sa)\b/i)

   end

   def _company_by_name(name, ngram_cutoff=nil, filter=nil)

     namedown = name.to_s.downcase

     if filter

       namedown.gsub! filter, ''

     @companies.each_value { |company|

       name = company.name.to_s.downcase

       if filter

         name.gsub! filter, ''

             && ODDB::Util::NGramSimilarity.compare(name, namedown) > ngram_cutoff)

         return company

     nil

 	def company_count

 		@company_count ||= @companies.size

 	end

 	def config(*args)

 		if(@config.nil?)

 			@config = ODDB::Config.new

 			@config.pointer = ODDB::Persistence::Pointer.new(:config)

 			self.odba_store

 		hook = @config

 		args.each { |arg|

 			conf = hook.send(arg)

 			if(conf.nil?)

 				conf = hook.send("create_#{arg}")

 				conf.pointer = hook.pointer + arg

 				hook.odba_store

 			hook = conf

 		hook

 	def count_atc_ddd

 		@atc_classes.values.inject(0) { |inj, atc|

 			inj += 1 if(atc.has_ddd?)

 			inj

 	end

 	def count_limitation_texts

 		@registrations.values.inject(0) { |inj,reg|			

 			inj + reg.limitation_text_count

 	end

 	def count_packages

 		@registrations.values.inject(0) { |inj, reg|

 			inj + reg.active_package_count

 	end

 	def count_patinfos

 		@patinfos.size + active_pdf_patinfos.size

 	end

 	def count_recent_registrations

 		if((grp = log_group(:swissmedic) || log_group(:swissmedic_journal)) \

 			 && (log = grp.latest))

 			log.change_flags.select { |ptr, flags|

 				flags.include?(:new)

 			0

 	end

 	def count_vaccines

 		@registrations.values.inject(0) { |inj, reg|

 			if(reg.vaccine)

 				inj += reg.active_package_count

 			inj

 	end

 	def cyp450(id)

 		@cyp450s[id]

 	end

 	def cyp450s

 		@cyp450s.values

 	end

 	def create_analysis_group(groupcd)

 		group = ODDB::Analysis::Group.new(groupcd)

 		@analysis_groups.store(groupcd, group)

 	def create_atc_class(atc_class)

 		atc = ODDB::AtcClass.new(atc_class)

 		@atc_chooser.add_offspring(ODDB::AtcNode.new(atc))

 		@atc_classes.store(atc_class, atc)

 	def create_commercial_form

 		form = ODDB::CommercialForm.new

 		@commercial_forms.store(form.oid, form)

 	def create_company

 		company = ODDB::Company.new

 		@companies.store(company.oid, company)

 	def create_doctor

 		doctor = ODDB::Doctor.new

 		@doctors ||= {}

 		@doctors.store(doctor.oid, doctor)

 	def create_hospital(ean13)

 		hospital = ODDB::Hospital.new(ean13)

 		@hospitals.store(ean13, hospital)

 	def create_cyp450(cyp_id)

 		cyp450 = ODDB::CyP450.new(cyp_id)

 		@cyp450s.store(cyp_id, cyp450)

 	def create_fachinfo

 		fachinfo = ODDB::Fachinfo.new

 		@fachinfos.store(fachinfo.oid, fachinfo)

   def create_feedback

     feedback = ODDB::Feedback.new

     @feedbacks.store(feedback.oid, feedback) 

 	def create_galenic_group

 		galenic_group = ODDB::GalenicGroup.new

 		@galenic_groups.store(galenic_group.oid, galenic_group)

 	def create_generic_group(package_pointer)

 		@generic_groups.store(package_pointer, ODDB::GenericGroup.new)

 	end

   def create_index_therapeuticus(code)

     code = code.to_s

     it = ODDB::IndexTherapeuticus.new(code)

     @indices_therapeutici.store(code, it)

 	def create_indication

 		indication = ODDB::Indication.new

 		@indications.store(indication.oid, indication)

 	def create_invoice

 		invoice = ODDB::Invoice.new

 		@invoices.store(invoice.oid, invoice)

 	def create_address_suggestion

 		address = ODDB::AddressSuggestion.new

 		@address_suggestions.store(address.oid, address) 

 	def create_log_group(key)

 		@log_groups[key] ||= ODDB::LogGroup.new(key)

 	end

   def create_minifi

     minifi = ODDB::MiniFi.new

     @minifis.store(minifi.oid, minifi)

 	def create_narcotic

 		narc = ODDB::Narcotic.new

 		@narcotics.store(narc.oid, narc)

 	def create_orphaned_fachinfo

 		@orphaned_fachinfos ||= {}

 		orphan = ODDB::OrphanedTextInfo.new

 	  @orphaned_fachinfos.store(orphan.oid, orphan)

 	def create_orphaned_patinfo

 		orphan = ODDB::OrphanedTextInfo.new

 	  @orphaned_patinfos.store(orphan.oid, orphan)

 	def create_patinfo

 		patinfo = ODDB::Patinfo.new

 		@patinfos.store(patinfo.oid, patinfo)

 	def create_poweruser

 		user = ODDB::PowerUser.new

 		@users.store(user.oid, user)

 	def create_registration(iksnr)

 		unless @registrations.include?(iksnr)

 			reg = ODDB::Registration.new(iksnr)

 			@registrations.store(iksnr, reg)

 			reg

 	end

 	def create_slate(name)

 		slate = ODDB::Slate.new(name)

 		@slates.store(name, slate)

 	def create_sponsor(flavor)

 		sponsor = ODDB::Sponsor.new

 		@sponsors.store(flavor, sponsor)

 	def create_substance(key=nil)

 		if(!key.nil? && (subs = substance(key)))

 			subs = ODDB::Substance.new

 			unless(key.nil?)

 				values = {

 				diff = subs.diff(values, self)

 				subs.update_values(diff)

 			@substances.store(subs.oid, subs)

 	end

 	def create_user

 		@users ||= {}

 		user = ODDB::CompanyUser.new

 		@users.store(user.oid, user)

 	def currencies

 		@currency_rates.keys.sort

 	end

 	def create_migel_group(groupcd)

 		migel = ODDB::Migel::Group.new(groupcd)

 		@migel_groups.store(groupcd, migel)

 	def analysis_count

 		@analysis_count ||= analysis_positions.size

 	end

 	def delete_address_suggestion(oid)

 		if(sug = @address_suggestions.delete(oid))

 			@address_suggestions.odba_isolated_store

 			sug

 	end

 	def delete_atc_class(atccode)

 		atc = @atc_classes[atccode]

 		@atc_chooser.delete(atccode)

 		if(@atc_classes.delete(atccode))

 			@atc_classes.odba_isolated_store

 		atc

 	def delete_cyp450(cyp_id)

 		if(cyp = @cyp450s.delete(cyp_id))

 			@cyp450s.odba_isolated_store

 			cyp

 	end

 	def delete_commercial_form(oid)

 		if(form = @commercial_forms.delete(oid))

 			@commercial_forms.odba_isolated_store

 			form

 	end

 	def delete_company(oid)

 		if(comp = @companies.delete(oid))

 			@companies.odba_isolated_store

 			comp

 	end

 	def delete_doctor(oid)

 		if(doc = @doctors.delete(oid.to_i))

 			@doctors.odba_isolated_store

 			doc

 	end

 	def delete_fachinfo(oid)

 		if(fi = @fachinfos.delete(oid))

 			@fachinfos.odba_isolated_store

 			fi

 	end

 	def delete_galenic_group(oid)

 		group = galenic_group(oid)

 		unless (group.nil? || group.empty?)

 			raise 'e_nonempty_galenic_group'

 		if(grp = @galenic_groups.delete(oid.to_i))

 			@galenic_groups.odba_isolated_store

 			grp

   def delete_index_therapeuticus(code)

     code = code.to_s

     if(it = @indices_therapeutici.delete(code))

       @indices_therapeutici.odba_isolated_store

       it

 	def delete_indication(oid)

 		if(ind = @indications.delete(oid))

 			@indications.odba_isolated_store

 			ind

 	end

 	def delete_invoice(oid)

 		if(inv = @invoices.delete(oid))

 			@invoices.odba_isolated_store

 			inv

 	end

 	def delete_migel_group(code)

 		if(grp = @migel_groups[code])

 			@migel_groups.odba_isolated_store

 			grp

 	end

   def delete_minifi(oid)

     if(minifi = @minifis.delete(oid.to_i))

       @minifis.odba_isolated_store

       minifi

   end

 	def delete_orphaned_fachinfo(oid)

 		if(fi = @orphaned_fachinfos.delete(oid.to_i))

 			@orphaned_fachinfos.odba_isolated_store

 			fi

 	end

 	def delete_orphaned_patinfo(oid)

 		if(pi = @orphaned_patinfos.delete(oid.to_i))

 			@orphaned_patinfos.odba_isolated_store

 			pi

 	end

 	def delete_patinfo(oid)

 		if(fi = @patinfos.delete(oid))

 			@patinfos.odba_isolated_store

 			fi

 	end

 	def delete_registration(iksnr)

 		if(reg = @registrations.delete(iksnr))

 			@registrations.odba_isolated_store

 			reg

 	end

 	def delete_substance(key)

 		substance = nil

 		if(key.to_i.to_s == key.to_s)

 			substance = @substances.delete(key.to_i)

 			substance = @substances.delete(key.to_s.downcase)

 		if(substance)

 			@substances.odba_isolated_store

 			substance

 	def doctor(oid)

 		@doctors[oid.to_i]

 	end

 	def hospital(ean13)

 		@hospitals[ean13]

 	end

 	def hospital_count

 		@hospitals.size

 	end

 	def doctor_count

 		@doctor_count ||= @doctors.size

 	end

 	def doctor_by_origin(origin_db, origin_id)

 		@doctors.values.each { |doctor|

 			if(doctor.record_match?(origin_db, origin_id))

 				return doctor

 		nil

 	def each_atc_class(&block)

 		@atc_classes.each_value(&block)

 	def each_galenic_form(&block)

 		@galenic_groups.each_value { |galgroup|

 			galgroup.each_galenic_form(&block)

   def each_migel_product(&block)

     @migel_groups.each_value { |group| 

       group.subgroups.each_value { |subgr|

         subgr.products.each_value(&block)

 	def each_package(&block)

 		@registrations.each_value { |reg|

 			reg.each_package(&block)

 	def each_sequence(&block)

 		@registrations.each_value { |reg|

 			reg.each_sequence(&block)

 	def execute_command(command)

 		command.execute(self)

 	end

 	def fachinfo(oid)

 		@fachinfos[oid.to_i]

 	end

 	def fachinfo_count

 		@fachinfos.size

 	end

 	def fachinfos_by_name(name, lang)

 		if(lang.to_s != "fr") 

 			lang = "de"

 		ODBA.cache.retrieve_from_index("fachinfo_name_#{lang}", 

   def feedback(id)

     @feedbacks[id.to_i]

   end

 	def galenic_form(name)

 		@galenic_groups.values.collect { |galenic_group|

 			galenic_group.get_galenic_form(name)

 	end

 	def galenic_group(oid)

 		@galenic_groups[oid.to_i]

 	end

 	def generic_group(package_pointer)

 		@generic_groups[package_pointer]

 	end

 	def get_currency_rate(symbol)

   def index_therapeuticus(code)

     @indices_therapeutici[code.to_s]

   end

 	def indication(oid)

 		@indications[oid.to_i]

 	end

 	def indication_by_text(text)

 		@indications.values.select { |indication|

 			indication.has_description?(text)

 	end

 	def indications

 	def invoice(oid)

 		@invoices ||= {}

 		@invoices[oid.to_i]

 	def limitation_text_count

 		@limitation_text_count ||= count_limitation_texts()

 	end

 	def log_group(key)

 		@log_groups[key]

 	end

 	def migel_count

 		@migel_count ||= migel_products.size	

 	end

 	def migel_group(groupcd)

 		@migel_groups[groupcd]

 	end

 	def migel_product(code)

 		parts = code.split('.', 3)

 		migel_group(parts[0]).subgroup(parts[1]).product(parts[2])

 		nil

 	end

 	def migel_products

 		products = []

 		@migel_groups.each_value { |group| 

 			group.subgroups.each_value { |subgr|

 				products.concat(subgr.products.values)

 		products

   def minifi(oid)

 	def narcotic(odba_id)

 		@narcotics[odba_id.to_i]

 	end

 	def narcotic_by_casrn(casrn)

 		unless(casrn.nil?)

       @narcotics.values.find do |narc| narc.casrn == casrn end

 	end

 	def narcotic_by_smcd(smcd)

 		unless(smcd.nil?)

       @narcotics.values.find do |narc| narc.swissmedic_codes.include?(smcd) end

 	end

 	def narcotics_count

 		@narcotics.size

 	end

 	def orphaned_fachinfo(oid)

 	end

 	def orphaned_patinfo(oid)

 		@orphaned_patinfos[oid.to_i]

 	end

   def package(pcode)

     ODDB::Package.find_by_pharmacode(pcode.to_s.gsub(/^0+/u, ''))

   end

   def package_by_ikskey(ikskey)

     ikskey = ikskey.to_s

     iksnr = "%05i" % ikskey[-8..-4].to_i

     ikscd = ikskey[-3..-1]

     if reg = registration(iksnr)

       reg.package ikscd

 	def package_count

 		@package_count ||= count_packages()

 	end

   def packages

 	def patinfo(oid)

 	end

 	def patinfo_count

 		@patinfo_count ||= count_patinfos()

 	end

 	def poweruser(oid)

 	def rebuild_atc_chooser

 		chooser = ODDB::AtcNode.new(nil)

 		@atc_classes.sort.each { |key, atc| 

 		@atc_chooser = chooser

 	def recent_registration_count

 		@recent_registration_count ||= count_recent_registrations()

 	end

 	def recount

     again = true

 		if(@bean_counter.is_a?(Thread) && @bean_counter.status)

 		@bean_counter = Thread.new {

       while(again)

         again = false

         @analysis_count = analysis_positions.size

         @atc_ddd_count = count_atc_ddd()

         @doctor_count = @doctors.size

         @company_count = @companies.size

         @substance_count = @substances.size

         @limitation_text_count = count_limitation_texts()

         @migel_count = migel_products.size

         @package_count = count_packages()

         @patinfo_count = count_patinfos()

         @recent_registration_count = count_recent_registrations()

         @vaccine_count = count_vaccines()

         self.odba_isolated_store

 	def registration(registration_id)

 		@registrations[registration_id]

 	end

 	def resolve(pointer)

 		pointer.resolve(self)

 	end

 	def refactor_addresses

 		puts "refactoring doctors"

 		$stdout.flush

 	  @doctors.each_value { |doc| 

 			doc.refactor_addresses 

 			doc.odba_store

 		puts "refactoring hospitals"

 		$stdout.flush

 	  @hospitals.each_value { |spi| 

 			spi.refactor_addresses 

 			spi.odba_store

 		puts "refactoring companies"

 		$stdout.flush

 	  @companies.each_value { |comp| 

 			comp.refactor_addresses 

 			comp.odba_store

 		puts "finished refactoring addresses"

 		$stdout.flush

 	def search_analysis(key, lang)

 		if(lang == 'en')

 			lang = 'de'

 		ODBA.cache.retrieve_from_index("analysis_index_#{lang}", key)

 	def search_analysis_alphabetical(query, lang)

 		if(lang == 'en')

 			lang = 'de'

 		index_name = "analysis_alphabetical_index_#{lang}"

 		ODBA.cache.retrieve_from_index(index_name, query)

   @@iks_or_ean = /(?:\d{4})?(\d{5})(?:\d{4})?/u

 	def search_oddb(query, lang)

 		result = ODDB::SearchResult.new

 		result.exact = true

 		result.search_query = query

 		if(query == 'atcless')

 			atc = ODDB::AtcClass.new('n.n.')

 			atc.sequences = atcless_sequences

 			atc.instance_eval {

 				alias :active_packages :packages

 			result.atc_classes = [atc]

 			result.search_type = :atcless

 			return result

 		if(match = @@iks_or_ean.match(query))

 			iksnr = match[1]

 			if(reg = registration(iksnr))

 				atc = ODDB::AtcClass.new('n.n.')

 				atc.sequences = reg.sequences.values

 				result.atc_classes = [atc]

 				result.search_type = :iksnr

 				return result

     if(match = /^\d{6,}$/u.match(query))

       if(pac = package(query))

 				atc = ODDB::AtcClass.new('n.n.')

         seq = ODDB::Sequence.new(pac.sequence.seqnr)

         seq.registration = pac.registration

         seq.packages.store pac.ikscd, pac

 				atc.sequences = [seq]

 				result.atc_classes = [atc]

 				result.search_type = :pharmacode

 				return result

 		key = query.to_s.downcase

 		atcs = search_by_atc(key)

 		result.search_type = :atc

     result.error_limit = RESULT_SIZE_LIMIT

 		if(atcs.empty?)

 			atcs = search_by_sequence(key, result)

 			result.search_type = :sequence

 		if(atcs.empty?)

 			atcs = search_by_company(key)

 			result.search_type = :company

 		if(atcs.empty?)

 			atcs = search_by_substance(key)

 			result.search_type = :substance

 		if(atcs.empty?)

 			atcs = search_by_indication(key, lang, result)

 			result.search_type = :indication

 		if(atcs.empty?)

 			atcs = search_by_sequence(key)

 			result.search_type = :sequence

 		result.atc_classes = atcs

 		if(atcs.empty?)

 			result = search_by_interaction(key, lang)

 		if(result.atc_classes.empty?)

 			result = search_by_unwanted_effect(key, lang)

 		result

 	def search_by_atc(key)

 		ODBA.cache.retrieve_from_index('atc_index', key.dup)

 	end

 	def search_by_company(key)

 		result = ODDB::SearchResult.new

     result.error_limit = RESULT_SIZE_LIMIT

 		atcs = ODBA.cache.retrieve_from_index('atc_index_company', key.dup, result)

 		filtered = atcs.collect { |atc|

 		filtered.flatten.compact.uniq

 	def search_by_indication(key, lang, result)

 		if(lang.to_s != "fr") 

 			lang = "de"

 		atcs = ODBA.cache.\

 		atcs += ODBA.cache.\

 			key.dup, result)

 		atcs.uniq

 	def search_by_sequence(key, result=nil)

 		ODBA.cache.retrieve_from_index('sequence_index_atc', key.dup, result)

 	end

 	def search_by_interaction(key, lang)

 		result = ODDB::SearchResult.new

     result.error_limit = RESULT_SIZE_LIMIT

 		if(lang.to_s != "fr") 

 			lang = "de"

 		sequences = ODBA.cache.retrieve_from_index("interactions_index_#{lang}", 

     key = key.downcase

     sequences.reject! { |seq| 

 		_search_exact_classified_result(sequences, :interaction, result)

 	def search_by_substance(key)

 		ODBA.cache.retrieve_from_index('substance_index_atc', key.dup)

 	end

 	def search_by_unwanted_effect(key, lang)

 		result = ODDB::SearchResult.new

 		if(lang.to_s != "fr") 

 			lang = "de"

 		sequences = ODBA.cache.retrieve_from_index("unwanted_effects_index_#{lang}", 

 		_search_exact_classified_result(sequences, :unwanted_effect, result)

 	def search_doctors(key)

 		ODBA.cache.retrieve_from_index("doctor_index", key)

 	end

 	def search_companies(key)

 		ODBA.cache.retrieve_from_index("company_index", key)

 	end

 	def search_exact_company(query)

 		result = ODDB::SearchResult.new

 		result.search_type = :company

 		result.atc_classes = search_by_company(query)

 		result

 	def search_exact_indication(query, lang)

 		result = ODDB::SearchResult.new

 		result.exact = true

 		result.search_type = :indication

 		result.atc_classes = search_by_indication(query, lang, result)

 		result

 	def search_migel_alphabetical(query, lang)

 		if(lang.to_s != "fr") 

 			lang = "de"

 		index_name = "migel_index_#{lang}"

 		ODBA.cache.retrieve_from_index(index_name, query)

 	def search_migel_products(query, lang)

 		if(lang.to_s != "fr") 

 			lang = "de"

 		index_name = "migel_fulltext_index_#{lang}"

 		ODBA.cache.retrieve_from_index(index_name, query)

 	def search_narcotics(query, lang)

 		if(lang.to_s != "fr") 

 			lang = "de"

 		index_name = "narcotics_#{lang}"

 		ODBA.cache.retrieve_from_index(index_name, query)

 	def search_patinfos(query)

 		ODBA.cache.retrieve_from_index('sequence_patinfos', query)

 	end

 	def search_vaccines(query)

 		ODBA.cache.retrieve_from_index('sequence_vaccine', query)

 	end

 	def search_exact_sequence(query)

 		sequences = search_sequences(query)

 		_search_exact_classified_result(sequences, :sequence)

 	def search_exact_substance(query)

 		sequences = ODBA.cache.\

 		_search_exact_classified_result(sequences, :substance)

 	def _search_exact_classified_result(sequences, type=:unknown, result=nil)

 		atc_classes = {}

 		sequences.each { |seq|

 			code = (atc = seq.atc_class) ? atc.code : 'n.n'

 			new_atc = atc_classes.fetch(code) { 

 				atc_class = ODDB::AtcClass.new(code)

 				atc_class.descriptions = atc.descriptions unless(atc.nil?)

 				atc_classes.store(code, atc_class)

 			new_atc.sequences.push(seq)

 		result ||= ODDB::SearchResult.new

 		result.search_type = type

 		result.atc_classes = atc_classes.values

 		result

 	def search_hospitals(key)

 		ODBA.cache.retrieve_from_index("hospital_index", key)

 	end

 	def search_indications(query)

 		ODBA.cache.retrieve_from_index("indication_index", query)

 	end

 	def search_interactions(query)

 		result = ODBA.cache.retrieve_from_index("sequence_index_substance", query)

 		if(subs = substance(query, false))

 		if(result.empty?)

 			result = soundex_substances(query)

 		result

 	def search_sequences(query, chk_all_words=true)

 		index = (chk_all_words) ? 'sequence_index' : 'sequence_index_exact'

 		ODBA.cache.retrieve_from_index(index, query)

 	def search_single_substance(key)

 		result = ODDB::SearchResult.new

 		result.exact = true

     key = ODDB.search_term(key)

 		ODBA.cache.retrieve_from_index("substance_index", key, result).find { |sub|

 	def search_substances(query)

 		if(subs = substance(query))

 			soundex_substances(query)

 	end

 	def sequences

 		@registrations.values.inject([]) { |seq, reg| 

 			seq.concat(reg.sequences.values)

 	end

 	def set_currency_rate(symbol, value)

 	def slate(name)

 		@slates[name]

 	end

 	def soundex_substances(name)

 		parts = ODDB::Text::Soundex.prepare(name).split(/\s+/u)

 		soundex = ODDB::Text::Soundex.soundex(parts)

 		key = soundex.join(' ')

 		ODBA.cache.retrieve_from_index("substance_soundex_index", key)

   def sorted_fachinfos

       fi.revision }.sort_by { |fi| fi.revision }.reverse

   end

   def sorted_feedbacks

     @sorted_feedbacks ||= @feedbacks.values.sort_by { |fb| fb.time }.reverse

   end

   def sorted_minifis

         -minifi.publication_date.month, minifi.name] }

   end

   def sorted_patented_registrations

     @registrations.values.select { |reg|

       (pat = reg.patent) && pat.expiry_date #_protected?

     }.sort_by { |reg| reg.patent.expiry_date }

   end

 	def sponsor(flavor)

 		@sponsors[flavor.to_s]

 	end

 	def substance(key, neurotic=false)

 		if(key.to_i.to_s == key.to_s)

 			@substances[key.to_i]

 		elsif(substance = search_single_substance(key))

     elsif neurotic

 	end

 	def substance_by_connection_key(connection_key)

 		@substances.values.select { |substance|

 			substance.has_connection_key?(connection_key)

 	end

 	def substance_by_smcd(smcd)

 		@substances.values.select { |sub|

 			sub.swissmedic_code == smcd

 	end

 	def substances

 	def substance_count

 		@substance_count ||= @substances.size

 	end

 	def updated(item)

 		case item

 		when ODDB::Registration, ODDB::Sequence, ODDB::Package, ODDB::AtcClass

 			@last_medication_update = @@today

 			odba_isolated_store

 		when ODDB::LimitationText, ODDB::AtcClass::DDD

 		when ODDB::Substance

 			@substances.each_value { |subs|

 				if(!subs.is_effective_form? && subs.effective_form == item)

     when ODDB::Fachinfo, ODDB::FachinfoDocument

     when ODDB::Feedback

     when ODDB::MiniFi

 	end

 	def user(oid)

 		@users[oid]

 	end

 	def user_by_email(email)

 		@users.values.find { |user| user.unique_email == email }

 	end

 	def unique_atc_class(substance)

 	 atc_array = search_by_substance(substance)

 	 if(atc_array.size == 1)

 		 atc_array.first

 	def vaccine_count

 		@vaccine_count ||= count_vaccines()

 	end

 	def rebuild_indices(name=nil, &block)

 		ODBA.cache.indices.size

 		begin

 			start = Time.now

 			path = File.expand_path("../../etc/index_definitions.yaml", 

 			FileUtils.mkdir_p(File.dirname(path))

 			file = File.open(path)

 			YAML.load_documents(file) { |index_definition|

         doit = if(name)

                elsif(block)

                  true

 				if(doit)

 					index_start = Time.now

 					begin

 						puts "dropping: #{index_definition.index_name}"

 						ODBA.cache.drop_index(index_definition.index_name)

 						puts e.message

 					puts "creating: #{index_definition.index_name}"

 					ODBA.cache.create_index(index_definition, ODDB)

 					begin 

 						puts "filling: #{index_definition.index_name}"

 						puts index_definition.init_source

 						source = instance_eval(index_definition.init_source)

 						puts "source.size: #{source.size}"

 						ODBA.cache.fill_index(index_definition.index_name, 

 						puts e.class

 						puts e.message

 						puts e.backtrace

 					puts "finished in #{(Time.now - index_start) / 60.0} min"

 			puts "all Indices Created in total: #{(Time.now - start) / 3600.0} h"

 			file.close

 	def generate_dictionary(language, locale)

 		ODBA.storage.remove_dictionary(language)

 		base = File.expand_path("../../ext/fulltext/data/dicts/#{language}", 

 		ODBA.storage.generate_dictionary(language, locale, base)

 	def generate_dictionaries

 		generate_french_dictionary

 		generate_german_dictionary

 	def generate_french_dictionary

 		generate_dictionary('french', 'fr_FR@euro')

 	end

 	def generate_german_dictionary

 		generate_dictionary('german', 'de_DE@euro')

 	end

 	private

 	def create_unknown_galenic_group

 		unless(@galenic_groups.is_a?(Hash) && @galenic_groups.size > 0)

 			@galenic_groups = {}

 			pointer = ODDB::Persistence::Pointer.new([:galenic_group])

 			group = create(pointer)

 			raise "Default GalenicGroup has illegal Object ID (#{group.oid})" unless group.oid == 1

 			update(group.pointer, {'de'=>'Unbekannt'})

 	end

 module ODDB

 	class App < SBSM::DRbServer

 		include Failsafe

 		AUTOSNAPSHOT = true

 		CLEANING_INTERVAL = 5*60

 		EXPORT_HOUR = 2

 		UPDATE_HOUR = 9

     MEMORY_LIMIT = 20480

 		RUN_CLEANER = true

 		RUN_UPDATER = true

 		SESSION = Session

 		UNKNOWN_USER = UnknownUser

 		UPDATE_INTERVAL = 24*60*60

 		VALIDATOR = Validator

     YUS_SERVER = DRb::DRbObject.new(nil, YUS_URI)

 		attr_reader :cleaner, :updater

 		def initialize opts={}

       @rss_mutex = Mutex.new

 			@admin_threads = ThreadGroup.new

       start = Time.now

 			@system = ODBA.cache.fetch_named('oddbapp', self){

 				OddbPrevalence.new

 			puts "init system"

 			@system.init

 			@system.odba_store

       puts "init system: #{Time.now - start}"

 			puts "setup drb-delegation"

 			super(@system)

       return if opts[:auxiliary]

 			puts "reset"

 			reset()

       puts "reset: #{Time.now - start}"

       log_size

 			puts "system initialized"

       puts "initialized: #{Time.now - start}"

 		def accept_orphaned(orphan, pointer, symbol, origin=nil)

 			command = AcceptOrphan.new(orphan, pointer,symbol, origin)

 			@system.execute_command(command)

 		def clean

 			super

 			@system.clean_invoices

 		def create(pointer)

 			@system.execute_command(CreateCommand.new(pointer))

 		end

     def create_commercial_forms

       @system.each_package { |pac| 

         if(comform = pac.comform)

           possibilities = [

           ].uniq.delete_if { |possibility| possibility.empty? }

           cform = nil

           possibilities.each { |possibility|

             if(cform = CommercialForm.find_by_name(possibility))

               break

           if(cform.nil?)

             args = { :de => possibilities.first, 

             possibilities.each { |possibility|

               if(form = @system.galenic_form(possibility))

             pointer = Persistence::Pointer.new(:commercial_form)

             cform = @system.update(pointer.creator, args)

           pac.commercial_form = cform

           pac.odba_store

     end

 		def delete(pointer)

 			@system.execute_command(DeleteCommand.new(pointer))

 		end

     def inject_poweruser(email, pass, days)

       user_pointer = Persistence::Pointer.new(:poweruser)

       user_data = {

       invoice_pointer = Persistence::Pointer.new(:invoice)

       time = Time.now

       expiry = InvoiceItem.expiry_time(days, time)

       invoice_data = { :currency => State::PayPal::Checkout::CURRENCY }

       item_data = {

         :total_netto  => State::Limit.price(days.to_i),

       user = @system.update(user_pointer.creator, user_data, :admin)

       invoice = @system.update(invoice_pointer.creator, invoice_data, :admin)

       item_pointer = invoice.pointer + [:item]

       @system.update(item_pointer.creator, item_data, :admin)

       user.add_invoice(invoice)

       invoice.payment_received!

       invoice.odba_isolated_store

 		def merge_commercial_forms(source, target)

 			command = MergeCommand.new(source.pointer, target.pointer)

 			@system.execute_command(command)

 		def merge_companies(source_pointer, target_pointer)

 			command = MergeCommand.new(source_pointer, target_pointer)

 			@system.execute_command(command)

 		def merge_galenic_forms(source, target)

 			command = MergeCommand.new(source.pointer, target.pointer)

 			@system.execute_command(command)

     def merge_indications(source, target)

       command = MergeCommand.new(source.pointer, target.pointer)

       @system.execute_command(command)

 		def merge_substances(source_pointer, target_pointer)

 			command = MergeCommand.new(source_pointer, target_pointer)

 			@system.execute_command(command)

 		def replace_fachinfo(iksnr, pointer)

 			@system.execute_command(ReplaceFachinfoCommand.new(iksnr, pointer))

 		end

 		def update(pointer, values, origin=nil)

 			@system.update(pointer, values, origin)

 		end

 		def _admin(src, result, priority=0)

 			t = Thread.new {

 				Thread.current.abort_on_exception = false

 				result << failsafe {

 					response = instance_eval(src)

 					str = response.to_s

 					if(str.length > 200)

 						response.class

 						str

 				}.to_s

 			t[:source] = src

 			t.priority = priority

 			@admin_threads.add(t)

 			t

 		def login(email, pass)

       YusUser.new(YUS_SERVER.login(email, pass, YUS_DOMAIN))

 		end

 		def login_token(email, token)

       YusUser.new(YUS_SERVER.login_token(email, token, YUS_DOMAIN))

 		end

     def logout(session)

       YUS_SERVER.logout(session)

     end

     def peer_cache cache

       ODBA.peer cache

     end

 		def reset

 			@random_updater.kill if(@random_updater.is_a? Thread)

       if RUN_UPDATER

 			@mutex.synchronize {

 				@sessions.clear

     def run_random_updater

       Thread.new {

         Thread.current.abort_on_exception = true

         update_hour = rand(24)

         update_min = rand(60)

         today = (update_hour > Time.now.hour) ? \

           @@today : @@today.next

         loop {

           next_run = Time.local(today.year, today.month, today.day,

           puts "next random update will take place at #{next_run}"

           $stdout.flush

           sleep(next_run - Time.now)

           Updater.new(self).run_random

           @system.recount

           GC.start

           today = @@today.next

           update_hour = rand(24)

           update_min = rand(60)

     end

     def unpeer_cache cache

       ODBA.unpeer cache

     end

     def update_feedback_rss_feed

       async {

         begin

         @rss_mutex.synchronize {

           values = @system.sorted_feedbacks

           plg = Plugin.new(self)

           plg.update_rss_feeds('feedback.rss', values, View::Rss::Feedback)

           puts e.message

           puts e.backtrace

     end

     def ipn(notification)

       Util::Ipn.process notification, self

       nil # don't return the invoice back across drb - it's not defined in yipn

     def grant_download(email, filename, price, expires=Time.now+2592000)

       ip = Persistence::Pointer.new(:invoice)

       inv = update ip.creator, :yus_name => email, :currency => 'EUR'

       itp = inv.pointer + :item

       update itp.creator, :text => filename, :price => price, :time => Time.now,

                           :duration => (Time.now - expires) / 86400,

       inv.payment_received!

       inv.odba_store

       "http://#{SERVER_NAME}/de/gcc/download/invoice/#{inv.oid}/email/#{email}/filename/#{filename}"

 		def assign_effective_forms(arg=nil)

       _assign_effective_forms(arg)

 		end

 		def _assign_effective_forms(arg=nil)

 			result = nil

 			last = nil

 			@system.substances.select { |subs| 

 				!subs.has_effective_form? && (arg.nil? || arg.to_s < subs.to_s)

 			}.sort_by { |subs| subs.name }.each { |subs|

 				puts "Looking for effective form of ->#{subs}<- (#{subs.sequences.size} Sequences)"

 				name = subs.to_s

 				parts = name.split(/\s/u)

 				suggest = if(parts.size == 1)

 					subs

 				last = result

 				result = nil

 				while(result.nil?)

 					possibles = [

 					if(suggest)

 						puts "Suggestion:                   ->#{suggest}<-"

 						possibles.unshift("s(uggestion)")

 					if(last)

 					print possibles.join(", ")

 					print " > "

 					$stdout.flush

 					answer = $stdin.readline.strip

 					puts "you typed:                    ->#{answer}<-"

 					case answer

 					when ''

 					when 'l'

 					when 's'

 						result = suggest

 					when 'S'

 						result = subs

 					when 'd'

 						subs.sequences.each { |seq| 

 							seq.delete_active_agent(subs) 

 							seq.active_agents.odba_isolated_store

 						subs.odba_delete

 						break

 					when 'n'

 						break

 					when 'q'

 						return

 					when /c .+/u

 						puts "creating:"

 						pointer = Persistence::Pointer.new(:substance)

 						puts "pointer: #{pointer}"

 						args = { :lt => answer.split(/\s+/u, 2).last.strip }

 						argstr = args.collect { |*pair| pair.join(' => ') }.join(', ')

 						puts "args: #{argstr}"

 						result = @system.update(pointer.creator, args)

 						result.effective_form = result

 						result.odba_store

 						puts "result: #{result}"

 						result = @system.substance(answer)

 				if(result)

 					subs.effective_form = result

 					subs.odba_store

 			nil

     def yus_allowed?(email, action, key=nil)

       YUS_SERVER.autosession(YUS_DOMAIN) { |session|

         session.entity_allowed?(email, action, key)

     end

     def yus_create_user(email, pass=nil)

       YUS_SERVER.autosession(YUS_DOMAIN) { |session|

         session.create_entity(email, pass)

       login(email, pass) if(pass)

     def yus_grant(name, key, item, expires=nil)

       YUS_SERVER.autosession(YUS_DOMAIN) { |session|

         session.grant(name, key, item, expires)

     end

     def yus_get_preference(name, key)

       YUS_SERVER.autosession(YUS_DOMAIN) { |session|

         session.get_entity_preference(name, key)

     end

     def yus_get_preferences(name, keys)

       YUS_SERVER.autosession(YUS_DOMAIN) { |session|

         session.get_entity_preferences(name, keys)

       {} # return an empty hash

     end

     def yus_model(name)

       if(odba_id = yus_get_preference(name, 'association'))

         ODBA.cache.fetch(odba_id, nil)

     end

     def yus_reset_password(name, token, password)

       YUS_SERVER.autosession(YUS_DOMAIN) { |session|

         session.reset_entity_password(name, token, password)

     end

     def yus_set_preference(name, key, value, domain=YUS_DOMAIN)

       YUS_SERVER.autosession(YUS_DOMAIN) { |session|

         session.set_entity_preference(name, key, value, domain)

     end

 		def multilinguify_analysis

 			@system.analysis_positions.each { |pos|

 				if(descr = pos.description)

 					pos.instance_variable_set('@description', nil)

 					@system.update(pos.pointer, {:de => descr})

 				if(fn = pos.footnote)

 					pos.instance_variable_set('@footnote', nil)

 					ptr = pos.pointer + :footnote

 					@system.update(ptr.creator, {:de => fn})

 				if(lt = pos.list_title)

 					pos.instance_variable_set('@list_title', nil)

 					ptr = pos.pointer + :list_title

 					@system.update(ptr.creator, {:de => lt})

 				if(tn = pos.taxnote)

 					pos.instance_variable_set('@taxnote', nil)

 					ptr = pos.pointer + :taxnote

 					@system.update(ptr.creator, {:de => tn})

 				if(perm = pos.permissions)

 					pos.instance_variable_set('@permissions', nil)

 					ptr = pos.pointer + :permissions

 					@system.update(ptr.creator, {:de => perm})

 				if(lim = pos.instance_variable_get('@limitation'))

 					pos.instance_variable_set('@limitation', nil)

 					ptr = pos.pointer + :limitation_text

 					@system.update(ptr.creator, {:de => lim})

 				pos.odba_store

 		end

     def migrate_feedbacks

     def _migrate_feedbacks(item)

     def utf8ify(object, opts={})

     def migrate_to_utf8

     def _migrate_to_utf8 queue, table, iconv, opts={}

     def _migrate_obj_to_utf8 obj, queue, table, iconv, opts={}

     def _migrate_child_to_utf8 child, queue, table, iconv, opts={}

     def log_size

       @size_logger = Thread.new {

         time = Time.now

         bytes = 0

         threads = 0

         sessions = 0

         format = "%s %s: sessions: %4i - threads: %4i - memory: %4iMB %s"

         loop {

           begin

             lasttime = time

             time = Time.now

             alarm = time - lasttime > 60 ? '*' : ' '

             lastthreads = threads

             threads = Thread.list.size

             lastbytes = bytes

             bytes = File.read("/proc/#{$$}/stat").split(' ').at(22).to_i

             mbytes = bytes / (2**20)

             if mbytes > MEMORY_LIMIT

             lastsessions = sessions

             sessions = @sessions.size

             gc = ''

             gc << 'S' if sessions < lastsessions

             gc << 'T' if threads < lastthreads

             gc << 'M' if bytes < lastbytes

             path = File.expand_path('../../doc/resources/downloads/status',

             lines = File.readlines(path)[0,100] rescue []

             lines.unshift sprintf(format, alarm, 

             File.open(path, 'w') { |fh|

               fh.puts lines

         sleep 5

     end

 begin 

 	require 'testenvironment'