de.oddb 2.0.0

data/lib/oddb/currency.rb

@@ -0,0 +1,6 @@
+require 'drb'
+require 'oddb/config'
+
+module ODDB
+  Currency = DRb::DRbObject.new nil, @config.currency_rates
+end

data/lib/oddb/drugs.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# Drugs -- de.oddb.org -- 21.11.2006 -- hwyss@ywesee.com
+
+require "oddb/drugs/active_agent"
+require "oddb/drugs/atc"
+require "oddb/drugs/composition"
+require "oddb/drugs/ddd"
+require "oddb/drugs/dose"
+require "oddb/drugs/galenic_form"
+require "oddb/drugs/package"
+require "oddb/drugs/part"
+require "oddb/drugs/product"
+require "oddb/drugs/sequence"
+require "oddb/drugs/substance"
+require "oddb/drugs/substance_group"
+require "oddb/drugs/unit"

data/lib/oddb/drugs/active_agent.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+# Drugs::ActiveAgent -- de.oddb.org -- 07.11.2006 -- hwyss@ywesee.com
+
+require 'oddb/model'
+require 'oddb/drugs/dose'
+
+module ODDB
+  module Drugs
+    class ActiveAgent < Model
+      include Comparable
+      belongs_to :substance
+      belongs_to :composition, delegates(:packages)
+      attr_accessor :dose, :chemical_equivalence
+      def initialize(substance, dose, unit="mg")
+        @substance = substance
+        if(dose.is_a?(Dose))
+          @dose = dose
+        else
+          @dose = Dose.new(dose, unit)
+        end
+      end
+      def to_s(language=:de)
+        [@substance.name.send(language), @dose].join(' ')
+      end
+      def <=>(other)
+        [@substance, @dose] <=> [other.substance, other.dose]
+      end
+      def ==(other)
+        other.is_a?(ActiveAgent) \
+          && ([@substance, @dose] == [other.substance, other.dose] \
+              || @chemical_equivalence == other \
+              || ((other = other.chemical_equivalence) && self == other)) \
+          || false
+      end
+    end
+  end
+end

data/lib/oddb/drugs/atc.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# Drugs::Atc -- de.oddb.org -- 17.11.2006 -- hwyss@ywesee.com
+
+require 'oddb/model'
+
+module ODDB
+  module Drugs
+    class Atc < Model
+      has_many :ddds, on_delete(:cascade)
+      has_many :sequences, delegates(:packages)
+      attr_reader :code
+      multilingual :name
+      multilingual :guidelines
+      multilingual :ddd_guidelines
+      def initialize(code)
+        @code = code
+      end
+      def interesting?
+        !(ddds.empty? && guidelines.empty? && ddd_guidelines.empty?)
+      end
+      def level
+        case len = @code.length
+        when 7
+          5
+        when 1
+          len
+        else
+          len - 1
+        end
+      end
+      def parent
+        Atc.find_by_code(parent_code)
+      end
+      def parent_code
+        case level
+        when 2
+          @code[0,1]
+        when 3..5
+          @code[0,level]
+        end
+      end
+      def products
+        sequences.collect { |sequence| sequence.product }.compact.uniq
+      end
+      def to_s
+        @code.to_s
+      end
+      def <=>(other)
+        @code <=> other.code
+      end
+    end
+  end
+end

data/lib/oddb/drugs/composition.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# Drugs::Composition -- de.oddb.org -- 01.09.2006 -- hwyss@ywesee.com
+
+require 'oddb/model'
+require 'oddb/drugs/dose'
+
+module ODDB
+  module Drugs
+    class Composition < Model
+      attr_accessor :galenic_form, :equivalence_factor
+      belongs_to :sequence, delegates(:packages)
+      has_many :active_agents, on_delete(:cascade)
+      has_many :parts
+      def active_agent(substance)
+        active_agents.find { |agent| agent.substance == substance }
+      end
+      def doses
+        active_agents.collect { |agent| agent.dose }
+      end
+      def include?(substance, dose, unit=nil)
+        unless(dose.is_a?(Drugs::Dose))
+          dose = Drugs::Dose.new(dose, unit)
+        end
+        active_agents.any? { |act|
+          act.substance == substance && act.dose == dose
+        }
+      end
+      def substances
+        active_agents.collect { |agent| agent.substance }
+      end
+      def to_s(language=:de)
+        active_agents.collect { |agent| agent.to_s(language) }.join(', ')
+      end
+      def ==(other)
+        other.is_a?(Composition) \
+          && @galenic_form == other.galenic_form \
+          && active_agents.sort == other.active_agents.sort
+      end
+    end
+  end
+end

data/lib/oddb/drugs/ddd.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# Drugs::Ddd -- de.oddb.org -- 20.11.2006 -- hwyss@ywesee.com
+
+require 'oddb/model'
+
+module ODDB
+  module Drugs
+    class Ddd < Model
+      attr_reader :administration
+      attr_accessor :dose, :comment
+      belongs_to :atc
+      def initialize(administration)
+        @administration = administration
+      end
+      def to_s
+        if(@comment)
+          sprintf("%s: %s (%s)", @administration, @dose, @comment)
+        else
+          sprintf("%s: %s", @administration, @dose)
+        end
+      end
+    end
+  end
+end

data/lib/oddb/drugs/dose.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+# Drugs::Dose -- de.oddb.org -- 07.11.2006 -- hwyss@ywesee.com
+
+require 'oddb/util/quanty'
+
+module ODDB
+  module Drugs
+    class Dose < Quanty
+      include Comparable
+      alias :qty :val 
+      np = '-?[0-9]+(?:[.,][0-9]+)?' ## numerical pattern
+      @@range_ptrn = %r{(#{np})\s*-\s*(#{np})}
+      @@cnc_ptrn = %r{([^/]*)/\s*(#{np})\s*(.*)}
+      def Dose.from_quanty(other)
+        Dose.new(other.val, other.unit)
+      end
+      def initialize(qty, unit=nil)
+        qty_str = ''
+        if(match = @@range_ptrn.match(qty.to_s))
+          qty = round(match[1].to_f)..round(match[2].to_f)
+        end
+        if(qty.is_a?(Range))
+          qty_str = "#{qty.first}-#{qty.last}"
+          qty = (qty.first + qty.last) / 2.0
+          @not_normalized = [qty_str, unit].compact.join(' ')
+        end
+        if(match = @@cnc_ptrn.match(unit.to_s))
+          qty_str = round(qty).to_s
+          div = round(match[2])
+          @not_normalized = [
+            qty_str, 
+            [match[1].strip, div].join(' / '), 
+            match[3],
+          ].join
+          qty = qty.to_f/div.to_f
+          unit = [match[1].strip,match[3].strip].join('/')
+        end
+        qty = round(qty)
+        unit = unit.to_s.tr('L', 'l')
+        fuzzy_retry = true
+        strict_retry = true
+        begin
+          super(qty, unit)
+        rescue StandardError => e
+          if(fuzzy_retry)
+            unit = unit[0,2]
+            fuzzy_retry = false
+            retry
+          elsif(strict_retry)
+            unit = ''
+            strict_retry = false
+            retry
+          end
+        end
+      end
+      def to_f
+        begin
+          super
+        rescue StandardError
+          @val * @fact.factor
+        end
+      end
+      def to_i
+        @val.to_i
+      end
+      def to_s
+        @not_normalized or 
+        begin
+          val = if(@val.is_a? Float)
+            sprintf('%.3f', @val).gsub(/0+$/, '')
+          else
+            @val
+          end
+          [val, @unit].join(' ')
+        end
+      end
+      def * (other)
+        Dose.from_quanty(super)
+      end
+      def + (other)
+        Dose.from_quanty(super)
+      end
+      def / (other)
+        Dose.from_quanty(super)
+      end
+      def - (other)
+        Dose.from_quanty(super)
+      end
+      def <=>(other)
+        begin
+          (@val * 1000).round <=> (adjust(other) * 1000).round
+        rescue StandardError
+          @unit <=> other.unit
+        end
+      end
+      private
+      def round(qty)
+        qty = qty.to_s.gsub(/'/, '').gsub(',', '.')
+        if(qty.to_f == qty.to_i)
+          qty.to_i
+        else
+          qty.to_f
+        end
+      end
+    end
+  end
+end

data/lib/oddb/drugs/galenic_form.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# Drugs::GalenicForm -- de.oddb.org -- 11.09.2006 -- hwyss@ywesee.com
+
+require 'oddb/model'
+require 'oddb/drugs/galenic_group'
+
+module ODDB
+  module Drugs
+    class GalenicForm < Model
+      is_coded
+      multilingual :description
+      alias :name :description
+      belongs_to :group
+      def ==(other)
+        super || (!@group.nil? && @group == other.group)
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/oddb/drugs/galenic_group.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# Drugs::GalenicGroup -- de.oddb.org -- 21.02.2007 -- hwyss@ywesee.com
+
+require 'oddb/model'
+
+module ODDB
+  module Drugs
+    class GalenicGroup < Model
+      multilingual :name
+      has_many :galenic_forms
+      attr_accessor :administration
+      def initialize(groupname, language='de')
+        name.send("%s=" % language, groupname)
+      end
+    end
+  end
+end

data/lib/oddb/drugs/package.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+# Drugs::Package -- de.oddb.org -- 14.11.2006 -- hwyss@ywesee.com
+
+require 'oddb/model'
+
+module ODDB
+  module Drugs
+    class Package < Model
+      belongs_to :sequence, 
+        delegates(:active_agents, :atc, :company, :compositions, :ddds, :doses,
+                  :fachinfo_url, :fachinfo, :galenic_forms, :patinfo,
+                  :patinfo_url, :product, :registration, :substances)
+      has_many :feedbacks, on_delete(:cascade)
+      has_many :parts, on_delete(:cascade), delegates(:comparable_size)
+      has_many :prices
+      is_coded
+      multilingual :name
+      def cascading_name(language)
+        str = name.send language
+        if str.to_s.empty? && sequence
+          str = sequence.cascading_name language
+        end
+        str
+      end
+      def comparable?(other)
+        return false unless(other.is_a?(Package))
+        csizes = comparable_size.collect { |psize|
+          (psize*0.75)..(psize*1.25)
+        }
+        osizes = other.comparable_size
+        idx = -1
+        osizes.length == csizes.length && csizes.all? { |range|
+          idx += 1
+          range.include?(osizes.at(idx))
+        }
+      end
+      def comparables
+        @sequence.comparables.inject([]) { |memo, sequence|
+          memo.concat sequence.packages.select { |package|
+            (package != self) && comparable?(package)
+          }
+        }
+      end
+      def dose_price(dose)
+        if(price = price(:public))
+          pdose = doses.first.want(dose.unit)
+          Util::Money.new((dose / pdose).to_f * (price.to_f / size))
+        end
+      rescue StandardError
+      end
+      def price(type, country='DE')
+        case type.to_s
+        when 'zuzahlung'
+          price_zuzahlung(country)
+        else
+          prices.find { |money| money.is_for?(type, country) }
+        end
+      end
+      def price_exfactory(country='DE')
+        price(:exfactory, country)
+      end
+      def _price_exfactory(country='DE')
+        if((price = price(:public, country)) \
+           && (code = code(:prescription)) && code.value)
+          c = ODDB.config
+          efp = (price - c.pharmacy_premium) * 100 /
+            (100.0 + c.vat + c.pharmacy_percentage) 
+          efp.type = :exfactory
+          efp.country = country
+          efp
+        end
+      end
+      def price_zuzahlung(country='DE')
+        unless((code = code(:zuzahlungsbefreit)) && code.value)
+          _price_zuzahlung country
+        end
+      end
+      def _price_zuzahlung(country='DE')
+        if(pp = price(:public, country))
+          if pp <= 50
+            Util::Money.five
+          elsif pp <= 100
+            pp * 0.1
+          else
+            Util::Money.ten
+          end
+        end
+      end
+      unless(instance_methods.include?("__sequence_writer__"))
+        alias :__sequence_writer__ :sequence=
+      end
+      def sequence=(seq)
+        old = @sequence
+        __sequence_writer__(seq)
+        if(seq)
+          comps = seq.compositions
+          parts.each_with_index { |part, idx|
+            part.composition = comps.at(idx)
+            part.save
+          }
+        else
+          parts.each { |part| part.composition = nil }
+        end
+        seq
+      end
+      def size
+        parts.inject(0) { |memo, part| memo + part.comparable_size.qty }
+      end
+    end
+  end
+end

data/lib/oddb/drugs/part.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+# Drugs::Part -- de.oddb.org -- 14.11.2006 -- hwyss@ywesee.com
+
+require 'oddb/model'
+require 'oddb/drugs/dose'
+
+module ODDB
+  module Drugs
+    class Part < Model
+      belongs_to :package, delegates(:sequence)
+      belongs_to :composition, delegates(:active_agents)
+      ## A partial package can be described as e.g. 
+      #  10 x 5 Ampoules of 20 ml 
+      #   ^----------------------- :multi    - Numeric
+      #       ^------------------- :size     - Numeric
+      #              ^------------ :unit     - Unit (a multilingual)
+      #                      ^---- :quantity - Dose 
+      attr_accessor :unit, :quantity, :multi
+      attr_reader :size
+      def initialize
+        super
+        @size = 1
+      end
+      def comparable_size
+        (@quantity || Dose.new(1)) * (@size || 1) * (@multi || 1)
+      end
+      def size=(size)
+        size ||= 1
+        if(size.to_f == size.to_i.to_f)
+          @size = size.to_i
+        else
+          @size = size.to_f
+        end
+      end
+      def to_s(language=:de)
+        parts = []
+        multi = @multi.to_i
+        if(multi > 1)
+          parts.push multi, 'x'
+        end
+        size = @size.to_i
+        if(size > 1)
+          parts.push(size)
+        end
+        if(unit = @unit)
+          parts.push(unit.name.send(language))
+        end
+        if(quantity = @quantity)
+          parts.push 'à', quantity
+        end
+        parts.join(' ')
+      end
+    end
+  end
+end