de.oddb 2.0.0

data/lib/oddb/export/xls.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+# Export::Xls -- de.oddb.org -- 13.03.2007 -- hwyss@ywesee.com
+
+require 'fileutils'
+require 'spreadsheet/excel'
+require 'oddb/currency'
+require 'oddb/remote/drugs/package'
+require 'oddb/util/comparison'
+
+module ODDB
+  module Export
+    module Xls
+class ComparisonDeCh
+  attr_reader :error_data
+  attr_reader :backtrace_info
+  def export(drb_uri, io)
+    write_xls(io, collect_comparables(drb_uri))
+  end
+  def adjust_price(price)
+    price * currency_rate * tax_factor
+  end
+  def collect_comparables(drb_uri)
+    data = []
+    @error_data = []
+    @backtrace_info = []
+    DRb::DRbObject.new(nil, drb_uri).remote_each_package { |remote|
+      package = Remote::Drugs::Package.new(drb_uri, remote,
+                                           1.0 / currency_rate, 
+                                           tax_factor)
+      begin
+        if(package.price(:public) \
+          && (comparable = package.local_comparables.select { |pac|
+              pac.price(:public)
+            }.sort_by { |pac|
+              pac.price(:public)
+            }.first))
+          data.push [comparable, package]
+        end
+      rescue NoMethodError => err
+        # This is a temporary solution for a NoMethodError bug
+        # See the bug http://dev.ywesee.com/wiki.php/Masa/20101020-debug-importChdeXls#DebugChde
+        @error_data.push("http://ch.oddb.org/en/gcc/compare/ean13/" + package.code(:ean).value)
+        @backtrace_info.push("\nhttp://ch.oddb.org/en/gcc/compare/ean13/" + package.code(:ean).value)
+        @backtrace_info.concat err.backtrace
+      end
+      nil # don't return data from the block across drb
+    }
+    data
+  end
+  def collect_cell(local, remote, format = "%s (%s)", &block)
+    lval = block.call(local) rescue StandardError
+    rval = block.call(remote) rescue StandardError
+    lval == rval ? lval : sprintf(format, lval, rval)
+  end
+  def currency_rate
+    @currency_rate ||= Currency.rate('EUR', 'CHF')
+  end
+  def tax_factor
+    1.076 / 1.19
+  end
+  def write_row(worksheet, idx, local, remote)
+    comparison = Util::Comparison.new(local, remote)
+    lexf = local.price(:exfactory)
+    rexf = remote.price(:exfactory)
+    data = [
+      collect_cell(local, remote) { |x| 
+        x.name.de || x.product.name.de },
+      collect_cell(local, remote) { |x| x.comparable_size.to_s },
+      adjust_price(local.price(:public)).to_s,
+      collect_cell(local, remote) { |x| x.company.name.de },
+      local.code(:cid).to_s,
+      remote.code(:ean).to_s,
+      collect_cell(local, remote) { |x| 
+        x.galenic_forms.first.description.de },
+      collect_cell(local, remote) { |x| 
+        x.active_agents.first.dose.to_s },
+      collect_cell(local, remote) { |x| 
+        x.active_agents.first.substance.name.de },
+      remote.atc.code,
+      remote.ikscat,
+      remote.sl_entry ? 'SL' : '',
+      sprintf("%+4.2f", adjust_price(comparison.absolute)),
+      sprintf("%+4.2f%%", comparison.difference),
+      sprintf("%4.2f", comparison.factor),
+      (adjust_price(lexf) if lexf).to_s,
+      (adjust_price(rexf) if rexf).to_s,
+    ]
+    if(lexf && rexf)
+      data.push sprintf("%+4.2f", adjust_price(comparison.absolute_exfactory)),
+        sprintf("%+4.2f%%", comparison.difference_exfactory)
+    end
+    worksheet.write idx, 0, data
+  end
+  def write_xls(io, data)
+    workbook = Spreadsheet::Excel.new(io)
+    worksheet = workbook.add_worksheet('Preisvergleich')
+    fmt_title = Spreadsheet::Format.new(:bold => true)
+    workbook.add_format(fmt_title)
+    worksheet.write 0, 0, [
+      "Name DE (Name CH)",
+      "Pkg Grösse DE (Pkg Grösse CH)",
+      "AVP inkl. Mwst in CHF nach Abzug und Zuschlag",
+      "Hersteller DE (Hersteller CH)",
+      "PZN", "EAN",
+      "Gal Form DE (gal. Form CH)",
+      "Stärke (Schreibweise CH)",
+      "Wirkstoff (Schreibweise CH)",
+      "ATC-Code", "Abgabekategorie CH", "SL Schweiz",
+      "Preisunterschied inkl. Mwst. in CHF",
+      "Preisunterschied in % (normalisiert)",
+      "Packungsäquivalenzfaktor",
+      "FAP DE exkl. MwSt (errechnet)",
+      "FAP CH exkl. MwSt",
+      "Preisunterschied FAP in CHF ",
+      "Preisunterschied FAP in % (normalisiert)",
+    ], fmt_title
+    data.sort_by { |local, remote| 
+      local.name.de || local.product.name.de
+    }.each_with_index { |(local, remote), idx|
+      write_row(worksheet, idx.next, local, remote)
+    }
+    workbook.close
+  end
+end
+    end
+  end
+end

data/lib/oddb/export/yaml.rb

@@ -0,0 +1,212 @@
+#!/usr/bin/env ruby
+# Export::Yaml -- de.oddb.org -- 09.10.2007 -- hwyss@ywesee.com
+
+require 'fixes/yaml'
+require 'oddb/business/company'
+require 'oddb/drugs'
+
+module ODDB
+  module OddbUri
+    YAML_URI = '!de.oddb.org,2007'
+    yaml_as YAML_URI
+		def to_yaml_type
+			"#{YAML_URI}/#{self.class}"
+		end
+    def to_yaml( opts = {} )
+      YAML::quick_emit( self.object_id, opts ) { |out|
+        out.map( taguri ) { |map|
+          to_yaml_map(map)
+        }
+      }
+    end
+    def to_yaml_map(map)
+      if(respond_to?(:oid) && id = oid)
+        map.add("oid", id) 
+      end
+      to_yaml_properties.each { |m|
+        map.add( m[1..-1], instance_variable_get( m ) )
+      }
+    end
+  end
+  module Yaml
+    include OddbUri
+    def to_yaml_properties
+      super - self.class.connections - self.class.connectors
+    end
+    def Yaml.append_features(mod)
+      super
+      mod.module_eval {
+        class << self 
+          def export(*args)
+            define_method(:to_yaml_properties) {
+              super.push(*args).uniq.reject { |name| 
+                instance_variable_get(name).nil? }
+            }
+          end
+        end
+      }
+    end
+  end
+  class Model
+    include Yaml
+  end
+  module Util
+    class Code
+      include OddbUri 
+      def to_yaml_map(map)
+        super
+        map.add('value', value)
+      end
+      def to_yaml_properties
+        super - ['@values']
+      end
+    end
+    class Multilingual
+      include OddbUri
+    end
+    class M10lDocument
+      export '@canonical'
+    end
+  end
+  module Business
+    class Company
+      export '@name'
+    end
+  end
+  module Drugs
+    class ActiveAgent
+      export '@substance'
+    end
+    class Atc
+      export '@ddds'
+    end
+    class Composition
+      export '@active_agents', '@parts'
+    end
+    class Dose
+      include OddbUri
+      def to_yaml_properties
+        [ '@val', '@unit' ]
+      end
+    end
+    class GalenicForm
+      export '@group'
+    end
+    class Package
+      def to_yaml_map(map)
+        super
+        map.add('prices', self.prices.inject({}) { |memo, price|
+          memo.store(price.type, price.to_f)
+          memo 
+        } )
+      end
+      def to_yaml_properties
+        (super - ['@prices']).push('@parts')
+      end
+    end
+    class Product
+      export '@company', '@sequences'
+    end
+    class Sequence
+      export '@atc', '@compositions', '@packages'
+    end
+    class Substance
+      export '@group'
+    end
+  end
+  module Text
+    class Document
+      export '@title', '@chapters', '@date', '@source'
+    end
+    class Chapter
+      include OddbUri
+    end
+    class Paragraph
+      include OddbUri
+      def to_yaml_properties
+        [ '@text', '@formats' ]
+      end
+    end
+    class Picture
+      include OddbUri
+      def to_yaml_map(map)
+        super
+        map.add('path', path)
+      end
+    end
+    class Table
+      include OddbUri
+    end
+    class Format
+      include OddbUri
+    end
+  end
+  module Export
+    module Yaml
+class Drugs
+  def export(io)
+    ODDB::Drugs::Product.all { |product| io.puts product.to_yaml }
+    nil
+  end
+end
+class Infos
+  def export(io)
+    raise "please specify which type of document you want to export" unless infotype
+    infos = []
+    ## Documents may be garbage-collected during this export. That's why we'll
+    #  keep names in a separate table on the stack, and assign them just before
+    #  calling #to_yaml
+    names = {}
+    ODDB::Drugs::Sequence.all do |seq|
+      info = seq.send infotype
+      # export sequence names as title
+      unless info.empty?
+        lnms = names[info.oid] ||= {}
+        info.canonical.each do |key, doc|
+          if (doc = info.send(key)) && (name = identify_name(seq, key))
+            lnms[key] = name
+          end
+        end
+        infos.push info
+      end
+    end
+    infos.uniq!
+    infos.each do |info|
+      info.canonical.each do |key, doc|
+        doc.title = names[info.oid][key]
+      end
+      io.puts info.to_yaml
+    end
+    nil
+  end
+end
+class Fachinfos < Infos
+  def infotype
+    :fachinfo
+  end
+  def identify_name seq, lang
+    seq.cascading_name(lang)
+  end
+end
+class Patinfos < Infos
+  def infotype
+    :patinfo
+  end
+  def identify_name seq, lang
+    names = seq.packages.collect do |pac| u pac.cascading_name(lang) end.uniq
+    if names.size == 1
+      return names.first
+    end
+    name = ''
+    pos = 0
+    while(chars = names.collect do |nm| nm[pos,1] end.uniq; chars.size == 1) do
+      pos += 1
+      name << chars.first
+    end 
+    name.gsub! /\([^\)]+$/u, ''
+    name.strip
+  end
+end
+    end
+  end
+end

data/lib/oddb/html/state/download.rb

@@ -0,0 +1,13 @@
+require 'oddb/html/state/global_predefine'
+require 'oddb/html/view/download'
+
+module ODDB
+  module Html
+    module State
+class Download < State::Global
+	VIEW = View::Download
+	VOLATILE = true
+end
+    end
+	end
+end

data/lib/oddb/html/state/drugs/admin/package.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+# Html::State::Drugs::Admin::Package -- de.oddb.org -- 29.10.2007 -- hwyss@ywesee.com
+
+require 'oddb/html/state/drugs/package'
+require 'oddb/html/view/drugs/admin/package'
+require 'oddb/import/pharmnet'
+require 'oddb/util/code'
+
+module ODDB
+  module Html
+    module State
+      module Drugs
+        module Admin
+class AjaxParts < Global
+  VOLATILE = true
+  VIEW = View::Drugs::Admin::Parts
+end
+class Package < Drugs::Package
+  VIEW = View::Drugs::Admin::Package
+  def ajax_create_part
+    check_model
+    parts = @model.parts.dup
+    if(!error?)
+      part = ODDB::Drugs::Part.new
+      part.package = Util::UnsavedHelper.new(@model)
+      parts.push part
+    end
+    AjaxParts.new @session, parts
+  end
+  def ajax_delete_part
+    check_model
+    keys = [:code_cid, :part]
+    input = user_input(keys, keys)
+    agents = []
+    if(!error? \
+       && (part = @model.parts.at(input[:part].to_i)))
+      part.delete
+    end
+    AjaxParts.new(@session, @model.parts)
+  end
+  def check_model
+    if(@model.code(:cid, 'DE') != @session.user_input(:code_cid))
+      @errors.store :code_cid, create_error(:e_state_expired, :code_cid, nil)
+    end
+  end
+  def delete
+    check_model
+    unless error?
+      seq = @model.sequence
+      if(seq.is_a? Util::UnsavedHelper)
+        seq = seq.delegate
+      end
+      @model.delete
+      Sequence.new(@session, seq)
+    end
+  end
+  def update
+    mandatory = [ :name, :code_cid ]
+    keys = [ :price_exfactory, :price_public, :price_festbetrag,
+             :code_festbetragsstufe, :code_festbetragsgruppe,
+             :code_zuzahlungsbefreit, :code_prescription, :unit, :sequence,
+             :size, :multi, :composition, :quantity ]
+    input = user_input(mandatory + keys, mandatory)
+    others = ODDB::Drugs::Package.search_by_code(:type    => 'cid',
+                                                 :value   => input[:code_cid],
+                                                 :country => 'DE')
+    others.delete(@model)
+    unless others.empty?
+      value = sprintf "'%i' (%s)", input[:code_cid], 
+                      others.collect { |pac| pac.name.de }.join(', ')
+      @errors.store(:code_cid, 
+                    create_error(:e_duplicate_pzn, :code_cid, value))
+    end
+    _update input
+  end
+  def _update input
+    email = @session.user.email
+    input.each { |key, value|
+      unless(@errors[key])
+        set = case key
+              when :name
+                @model.name.de = value unless(@model.name.de == value)
+              when :price_public, :price_festbetrag, :price_exfactory
+                update_price(/price_(.*)/.match(key.to_s)[1].to_sym, value.to_f)
+              when :code_cid, :code_festbetragsgruppe, :code_festbetragsstufe
+                update_code(/code_(.*)/.match(key.to_s)[1].to_sym, value)
+              when :code_zuzahlungsbefreit, :code_prescription
+                update_code(/code_(.*)/.match(key.to_s)[1].to_sym, !!value)
+              when :size
+                update_parts(input)
+              end
+        unless(set.nil?)
+          @model.data_origins.store key, email
+        end
+      end
+    }
+    if((uid = input[:sequence]) \
+       && (seq = ODDB::Drugs::Sequence.find_by_uid(uid)) \
+       && @model.sequence != seq)
+      @model.sequence = seq
+      @model.parts.each_with_index { |part, idx| 
+        part.composition = seq.compositions[idx]
+        part.save
+      }
+    elsif((seq = @model.sequence) && seq.is_a?(Util::UnsavedHelper))
+      @model.sequence = seq.delegate
+    end
+    @model.save
+    self
+  end
+  def package
+    if((code = @session.user_input(:pzn)) && @model.code(:cid, 'DE') == code)
+      self
+    else
+      super
+    end
+  end
+  private
+  def update_code(type, value)
+    if(code = @model.code(type))
+      code.value = value unless(code == value)
+    else
+      @model.add_code ODDB::Util::Code.new(type, value, 'DE')
+    end
+  end
+  def update_parts(input)
+    if(sizes = input[:size])
+      sizes.each { |idx, size|
+        part = @model.parts.at(idx.to_i)
+        part ||= ODDB::Drugs::Part.new
+        current = {}
+        [:multi, :size, :unit, :quantity, :composition].each { |key|
+          values = (input[key] ||= {})
+          if((val = values[idx]) && !val.empty?)
+            current.store(key, val)
+          end
+        }
+        part.multi = current[:multi] && current[:multi].to_i
+        part.size = current[:size]
+        if(unitname = current[:unit])
+          if(unit = ODDB::Drugs::Unit.find_by_name(unitname))
+            part.unit = unit
+          else
+            key = :"unit[#{idx}]"
+            @errors.store key, create_error(:e_unknown_unit, key, unitname)
+          end
+        else
+          part.unit = nil
+        end
+        if(str = current[:quantity])
+          part.quantity = ODDB::Drugs::Dose.new(*str.split(/\s*(?=[^\d.,])/, 2))
+        else
+          part.quantity = nil
+        end
+        if(comp = current[:composition])
+          part.composition = @model.compositions.at(comp.to_i)
+        end
+        part.package = @model unless(part.package == @model)
+        part.save
+      }
+    end
+  end
+  def update_price(type, amount)
+    if price = @model.price(type, 'DE')
+      if amount > 0
+        price.amount = amount unless(price == amount)
+      else
+        @model.remove_price price
+      end
+    elsif amount > 0
+      @model.add_price ODDB::Util::Money.new(amount, type, 'DE')
+    end
+  end
+end
+class NewPackage < Package
+  def direct_event
+    # disable redirector
+  end
+  def _update input
+    unless @errors[:code_cid]
+      super 
+      Package.new(@session, @model)
+    end
+  end
+end
+        end
+      end
+    end
+  end
+end