ramaze.ch.oddb.org 1.0.0

data/lib/oddb/import/whocc.rb

@@ -0,0 +1,173 @@
+#!/usr/bin/env ruby
+# Import::Whocc -- de.oddb.org -- 17.11.2006 -- hwyss@ywesee.com
+
+require 'oddb/drugs/atc'
+require 'oddb/drugs/ddd'
+require 'oddb/drugs/dose'
+require 'oddb/import/xml'
+
+module ODDB
+  module Import
+    module Whocc
+class Atc < Xml
+  def import_document(doc)
+    REXML::XPath.each(doc, '//rs:data/rw:row', 
+      "rs" => 'urn:schemas-microsoft-com:rowset',
+      "rw" => '#RowsetSchema') { |row|
+      code = row.attributes['ATCCode']
+      atc = Drugs::Atc.find_by_code(code) || Drugs::Atc.new(code)
+      atc.name.de = row.attributes['Name']
+      atc.save
+    }
+  end
+end
+class Ddd < Xml
+  UNIT_REPLACEMENTS = {
+    'TSD E' => 'TsdI.E.',
+    'MIO E' => 'MioI.E.',
+  }
+  def import_document(doc)
+    REXML::XPath.each(doc, '//rs:data/rw:row', 
+      "rs" => 'urn:schemas-microsoft-com:rowset',
+      "rw" => '#RowsetSchema') { |row|
+      attrs = row.attributes
+      code = attrs['ATCCode']
+      atc = Drugs::Atc.find_by_code(code) || Drugs::Atc.new(code)
+      adm = attrs['AdmCode']
+      comment = attrs['DDDComment']
+      ddd = atc.ddds.find { |candidate|
+        adm == candidate.administration \
+          && comment == candidate.comment
+      } || Drugs::Ddd.new(adm)
+      ddd.comment = comment
+      unit = attrs['UnitType']
+      unit = UNIT_REPLACEMENTS.fetch(unit, unit)
+      ddd.dose = Drugs::Dose.new(attrs['DDD'], unit)
+      ddd.atc = atc
+      ddd.save
+      atc.save
+    }
+  end
+end
+class Guidelines < Import
+  attr_reader :codes
+  class CodeHandler
+    ATC_TOP_LEVEL = %w{A B C D G H J L M N P R S V}
+    attr_reader :queue, :visited
+    def initialize
+      @queue = ATC_TOP_LEVEL.dup
+      @visited = []
+    end
+    def push(code)
+      unless((@queue + @visited).include?(code))
+        @queue.push(code)
+      end
+    end
+    def shift
+      code = @queue.shift
+      @visited.push(code)
+      code
+    end
+  end
+  @@query_re = /query=([A-Z0-9]+)/
+  def initialize
+    super
+    @url = 'http://www.whocc.no/atcddd/database/index.php'
+    @codes = CodeHandler.new
+    @count = 0
+    @created = 0
+    @ddd_guidelines = 0
+    @guidelines = 0
+  end
+  def extract_text(node)
+    unless(node.children.any? { |br| br.element? && br.name != 'br' })
+      node.inner_html.gsub(/\s+/, ' ').gsub(/\s*<br\s*\/?>\s*/, "\n")
+    end
+  end
+  def import(agent)
+    login(agent)
+    while(code = @codes.shift)
+      @count += 1
+      import_code(agent, code)
+    end
+    report
+  end
+  def import_atc(code, link)
+    name = capitalize_all(link.inner_text.to_s)
+    atc = Drugs::Atc.find_by_code(code) || Drugs::Atc.new(code)
+    unless(atc.name.en == name)
+      @created += 1
+      atc.name.en = name
+      atc.save
+    end
+    atc
+  end
+  def import_code(agent, get_code)
+    page = agent.get(@url + "?query=%s&showdescription=yes" % get_code)
+    (page/"//b/a").each { |link|
+      if(match = @@query_re.match(link.attributes['href']))
+        code = match[1] 
+        if(code == get_code)
+          atc = import_atc(code, link) 
+          import_guidelines(atc, link) && atc.save
+        end
+        @codes.push(code)
+      end
+    }
+    (page/"//ul//a").each { |link|
+      if(match = @@query_re.match(link.attributes['href']))
+        code = match[1] 
+        import_atc(code, link)
+      end
+    }
+  end
+  def import_ddd_guidelines(atc, table)
+    guidelines = (table/'td').collect { |td| 
+      extract_text(td) }.join if(table)
+    if(atc.ddd_guidelines.en != guidelines)
+      @ddd_guidelines += 1
+      atc.ddd_guidelines.en = guidelines
+      modified = true
+    end
+  end
+  def import_guidelines(atc, link)
+    node = link.parent
+    while(node.name != 'p')
+      node = node.next_sibling
+    end
+    ## nokogiri fixes the faulty html of whocc.no, and moves the table element
+    #  out of the p-container.
+    table = node.next_sibling
+    modified = false
+    if table.name == 'table' && table[:bgcolor] == '#cccccc'
+      modified = import_ddd_guidelines(atc, table)
+    end
+    guidelines = extract_text(node)
+    if(atc.guidelines.en != guidelines)
+      @guidelines += 1
+      modified = true
+      atc.guidelines.en = guidelines
+    end
+    modified
+  end
+  def login(agent)
+    msg = "Please configure your access to #@url in ODDB.config.credentials['whocc']"
+    credentials = ODDB.config.credentials['whocc'] or raise msg
+    page = agent.get(@url)
+    form = page.forms.first
+    form.username = credentials['username']
+    form.password = credentials['password']
+    agent.submit(form)
+  end
+  def report
+    [
+      sprintf("Imported %3i ATC-Codes", @count),
+      sprintf("Updated  %3i English descriptions", @created),
+      sprintf("Updated  %3i Guidelines", @guidelines),
+      sprintf("Updated  %3i DDD-Guidelines", @ddd_guidelines),
+    ]
+  end
+end
+    end
+  end
+end

data/lib/oddb/import/xml.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# Import::Xml -- de.oddb.org -- 17.11.2006 -- hwyss@ywesee.com
+
+require 'rexml/document'
+require 'oddb/import/import'
+
+module ODDB
+  module Import
+    class Xml < Import
+      def import(io)
+        import_document(REXML::Document.new(io))
+      end
+    end
+  end
+end

data/lib/oddb/model.rb

@@ -0,0 +1,179 @@
+#!/usr/bin/env ruby
+# Model -- de.oddb.org -- 04.09.2006 -- hwyss@ywesee.com
+
+require 'fixes/singular'
+require 'facet/module/basename'
+
+module ODDB
+  # forward definitions (circular dependency Model <-> M10lDocument)
+  class Model; end 
+  module Util; class M10lDocument < Model; end; end
+  class Model
+    class Predicate
+      attr_reader :action, :type, :delegators
+      def initialize(action, type, *delegators)
+        raise "unknown predicate type: #{type}" unless respond_to?(type)
+        @action, @type, @delegators = action, type, delegators
+      end
+      def cascade(action, next_level)
+        if(next_level.is_a?(Array))
+          next_level.each { |element| 
+            cascade(action, element)
+          }
+        else
+          next_level.send(action) if(next_level.respond_to?(action))
+        end
+      end
+      def delegate(action, next_level)
+      end
+      def execute(action, object)
+        if(action == @action)
+          @delegators.each { |delegator|
+            self.send(@type, action, object.send(delegator))
+          }
+        end
+      end
+    end
+    class << self
+      def belongs_to(groupname, *predicates)
+        attr_reader groupname
+        varname = :"@#{groupname}"
+        connections.push(varname)
+        selfname = singular
+        define_method("#{groupname}=") { |group|
+          old = instance_variable_get(varname)
+          if(old != group)
+            if(old)
+              old.send("remove_#{selfname}", self)
+              old.save
+            end
+            if(group)
+              group.send("add_#{selfname}", self)
+              group.save
+            end
+          end
+          instance_variable_set(varname, group)
+        }
+        predicates.each { |predicate|
+          if(predicate.action == :method_missing)
+            predicate.delegators.each { |key|
+              define_method(key) { 
+                if(group = instance_variable_get(varname))
+                  group.send(key)
+                end
+              }
+            }
+          else
+            predicate.delegators.push(groupname)
+            self.predicates.push(predicate)
+          end
+        }
+      end
+      def connections
+        @connections ||= []
+      end
+      def connector(key)
+        connectors.push :"@#{key}"
+      end
+      def connectors
+        @connectors ||= []
+      end
+      def delegates(*delegators)
+        Predicate.new(:method_missing, :delegate, *delegators)
+      end
+      def has_many(plural, *predicates)
+        varname = :"@#{plural}"
+        define_method(plural) {
+          instance_variable_get(varname) or begin
+            instance_variable_set(varname, Array.new)
+          end
+        }
+        define_method("add_#{plural.to_s.singular}") { |inst|
+          container = self.send(plural)
+          unless(container.any? { |other| inst.eql? other })
+            container.push(inst) 
+          end
+          inst
+        }
+        define_method("remove_#{plural.to_s.singular}") { |inst|
+          self.send(plural).delete_if { |other| inst.eql? other }
+        }
+        connectors.push(varname)
+        predicates.each { |predicate|
+          if(predicate.type == :delegate)
+            predicate.delegators.each { |key|
+              define_method(key) {
+                self.send(plural).collect { |inst|
+                  inst.send(key)
+                }.flatten
+              }
+            }
+          else
+            predicate.delegators.push(plural)
+            self.predicates.push(predicate)
+          end
+        }
+      end
+      def on_delete(action, *delegators)
+        Predicate.new(:delete, action, *delegators)
+      end
+      def on_save(action, *delegators)
+        Predicate.new(:save, action, *delegators)
+      end
+      def predicates
+        @predicates ||= []
+      end
+      def is_coded
+        has_many :codes
+        define_method(:code) { |*args|
+          type, country = *args
+          codes.find { |code| code.is_for?(type, country || ODDB.config.country) }
+        }
+      end
+      def m10l_document(key)
+        varname = :"@#{key}"
+        define_method(key) {
+          instance_variable_get(varname) or begin
+            instance_variable_set(varname, Util::M10lDocument.new)
+          end
+        }
+        connectors.push varname
+      end
+      def multilingual(key)
+        define_method(key) {
+          instance_variable_get(:"@#{key}") or begin
+            instance_variable_set(:"@#{key}", Util::Multilingual.new)
+          end
+        }
+        define_method(:to_s) { 
+          self.send(key).to_s
+        }
+      end
+      def singular
+        basename.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      end
+      def serialize(key)
+      end
+    end
+    def data_origin(key)
+      data_origins[key]
+    end
+    def data_origins
+      @data_origins ||= {}
+    end
+    def delete
+      self.class.predicates.each { |predicate|
+        predicate.execute(:delete, self)
+      }
+      self
+    end
+    def save
+      self.class.predicates.each { |predicate|
+        predicate.execute(:save, self)
+      }
+      self
+    end
+  end
+end
+
+require 'oddb/util/m10l_document'

data/lib/oddb/persistence/odba.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# Persistence::ODBA -- de.oddb.org -- 01.09.2006 -- hwyss@ywesee.com
+
+require 'oddb/config'
+require 'odba'
+require 'odba/connection_pool'
+require 'odba/drbwrapper'
+
+require 'oddb/persistence/odba/business/company'
+require 'oddb/persistence/odba/business/invoice'
+require 'oddb/persistence/odba/drugs/atc'
+require 'oddb/persistence/odba/drugs/galenic_form'
+require 'oddb/persistence/odba/drugs/galenic_group'
+require 'oddb/persistence/odba/drugs/package'
+require 'oddb/persistence/odba/drugs/product'
+require 'oddb/persistence/odba/drugs/sequence'
+require 'oddb/persistence/odba/drugs/substance'
+require 'oddb/persistence/odba/drugs/substance_group'
+require 'oddb/persistence/odba/drugs/unit'
+require 'oddb/persistence/odba/regulatory/authority'
+require 'oddb/persistence/odba/regulatory/registration'
+require 'oddb/persistence/odba/text/document'
+require 'oddb/persistence/odba/util/m10l_document'
+
+module ODDB
+  module Persistence
+    module ODBA
+    end
+  end
+  ODBA.storage.dbi = ODBA::ConnectionPool.new("DBI:Pg:#{@config.db_name}",
+                                              @config.db_user, @config.db_auth)
+  ODBA.cache.setup
+end

data/lib/oddb/persistence/odba/business/company.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# Business::Company -- de.oddb.org -- 22.11.2006 -- hwyss@ywesee.com
+
+require 'oddb/business/company'
+require 'oddb/persistence/odba/model'
+
+module ODDB
+  module Business
+    class Company < Model
+      odba_index :name, 'name.all'
+    end
+  end
+end

data/lib/oddb/persistence/odba/business/invoice.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# Business::Invoice -- de.oddb.org -- 23.01.2008 -- hwyss@ywesee.com
+
+require 'oddb/business/invoice'
+require 'oddb/persistence/odba/model'
+
+module ODDB
+  module Business
+    class Invoice < Model
+      odba_index :yus_name
+      odba_index :id
+      serialize :items
+    end
+  end
+end

data/lib/oddb/persistence/odba/drugs/atc.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# Drugs::Atc -- de.oddb.org -- 17.11.2006 -- hwyss@ywesee.com
+
+require 'oddb/drugs/atc'
+require 'oddb/persistence/odba/model'
+
+module ODDB
+  module Drugs
+    class Atc < Model
+      odba_index :code
+      odba_index :level, :code
+      odba_index :name, 'name.all'
+    end
+  end
+end