ramaze.ch.oddb.org 1.0.0

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

@@ -0,0 +1,189 @@
+#!/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/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, ODDB.config.country).to_s != @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 => ODDB.config.country)
+    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_cid, :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(:cid)) && @model.code(:cid, ODDB.config.country) == 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, ODDB.config.country)
+    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, ODDB.config.country)
+      if amount > 0
+        price.value = amount unless(price == amount)
+      else
+        @model.remove_price price
+      end
+    elsif amount > 0
+      @model.add_price ODDB::Business::Price.new(type, ODDB.config.country, amount)
+    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

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

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# Html::State::Drugs::Admin::Product -- de.oddb.org -- 04.04.2008 -- hwyss@ywesee.com
+
+require 'oddb/html/view/drugs/admin/product'
+require 'oddb/html/state/drugs/global'
+
+module ODDB
+  module Html
+    module State
+      module Drugs
+        module Admin
+class Product < Global
+  VIEW = View::Drugs::Admin::Product
+  def check_model
+    if(@model.uid.to_s != @session.user_input(:uid))
+      @errors.store :uid, create_error(:e_state_expired, :uid, nil)
+    end
+  end
+  def direct_event
+    direct_event = [:product]
+    if(uid = @model.uid)
+      direct_event.push([:uid, uid])
+    end
+    direct_event
+  end
+  def update
+    value = user_input :company
+    error_check_and_store(:company, value, [:company])
+    unless error?
+      set = if(company = ODDB::Business::Company.find_by_name(value))
+              @model.company = company
+            else
+              @errors.store :company, create_error(:e_unknown_company,
+                                                   :company, value)
+              nil
+            end
+      unless(set.nil?)
+        @model.data_origins.store :company, @session.user.email
+        @model.save
+      end
+    end
+    self
+  end
+  def product
+    if((uid = @session.user_input(:uid)) && @model.uid.to_s == uid)
+      self
+    else
+      super
+    end
+  end
+end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,259 @@
+#!/usr/bin/env ruby
+# Html::State::Drugs::Admin::Sequence -- de.oddb.org -- 04.04.2008 -- hwyss@ywesee.com
+
+require 'oddb/html/view/drugs/admin/sequence'
+require 'oddb/html/state/drugs/global'
+
+module ODDB
+  module Html
+    module State
+      module Drugs
+        module Admin
+class AjaxActiveAgents < Global
+  VOLATILE = true
+  VIEW = View::Drugs::Admin::ActiveAgents
+end
+class AjaxCompositions < Global
+  VOLATILE = true
+  VIEW = View::Drugs::Admin::Compositions
+end
+class Sequence < Global
+  VIEW = View::Drugs::Admin::Sequence
+  def ajax_create_active_agent
+    check_model
+    keys = [:uid, :composition]
+    input = user_input(keys, keys)
+    agents = []
+    if(!error? \
+       && (composition = @model.compositions.at(input[:composition].to_i)))
+      agents = composition.active_agents
+    end
+    AjaxActiveAgents.new(@session, agents.dup.push(nil))
+  end
+  def ajax_create_composition
+    check_model
+    comps = @model.compositions.dup
+    if(!error?)
+      comp = ODDB::Drugs::Composition.new
+      comp.active_agents.push nil
+      comps.push comp
+    end
+    AjaxCompositions.new @session, comps
+  end
+  def ajax_delete_active_agent
+    check_model
+    keys = [:uid, :active_agent, :composition]
+    input = user_input(keys, keys)
+    agents = []
+    if(!error? \
+       && (composition = @model.compositions.at(input[:composition].to_i)))
+      if(agent = composition.active_agents.at(input[:active_agent].to_i))
+        agent.delete
+        composition.remove_active_agent(agent)
+        composition.save
+      end
+      agents = composition.active_agents
+    end
+    AjaxActiveAgents.new(@session, agents)
+  end
+  def ajax_delete_composition
+    check_model
+    keys = [:uid, :composition]
+    input = user_input(keys, keys)
+    agents = []
+    if(!error? \
+       && (composition = @model.compositions.at(input[:composition].to_i)))
+      composition.delete
+    end
+    AjaxCompositions.new(@session, @model.compositions)
+  end
+  def check_model
+    if(@model.uid.to_s != @session.user_input(:uid))
+      @errors.store :uid, create_error(:e_state_expired, :uid, nil)
+    end
+  end
+  def delete
+    check_model
+    unless error?
+      prod = @model.product
+      if(prod.is_a? Util::UnsavedHelper)
+        prod = prod.delegate
+      end
+      @model.delete
+      Product.new(@session, prod)
+    end
+  end
+  def direct_event
+    direct_event = [:sequence]
+    if(uid = @model.uid)
+      direct_event.push([:uid, uid])
+    end
+    direct_event
+  end
+=begin ## temporarily disabled: this should be recoded to work with swiss infos
+       #  in 2.0
+  def _import_rtf(key, seq, url)
+    if(url && !url.empty?)
+      seq.send "#{key}_url=", url
+      imp = Import::PharmNet::Import.new
+      document = imp.import_rtf(key, WWW::Mechanize.new, url, seq.product.name.de,
+                                :reparse => true, :reload => true)
+      parent = seq.send(key)
+      parent.de = document
+      parent.save
+    end
+  rescue StandardError
+  end
+=end
+  def update
+    check_model
+    mandatory = [ :atc ]
+    keys = [ :atc_name, :registration, :fachinfo_url, :patinfo_url,
+      :galenic_form, :substance, :dose ]
+    input = user_input(mandatory + keys, mandatory)
+    unless /^EU/.match input[:registration].to_s
+      others = ODDB::Drugs::Sequence.search_by_code(:type => 'registration',
+                                                    :value => input[:registration],
+                                                    :country => 'EU')
+      others.delete(@model)
+      unless others.empty?
+        value = sprintf "'%s' (%s)", input[:registration],
+                        others.collect { |seq|
+                          seq.name.de || seq.product.name.de }.join(', ')
+        @errors.store(:registration,
+                      create_error(:e_duplicate_registration, :registration, value))
+      end
+    end
+    _update input
+  end
+  def _update input
+    email = @session.user.email
+    if((prod = @model.product) && prod.is_a?(Util::UnsavedHelper))
+      @model.product = prod.delegate
+    end
+    input.each { |key, value|
+      unless(@errors[key])
+        set = case key
+              when :atc
+                if(value.empty?)
+                  warn "empty atc"
+                elsif(atc = ODDB::Drugs::Atc.find_by_code(value))
+                  @model.atc = atc
+                elsif((name = input[:atc_name]) && !name.empty?)
+                  atc = ODDB::Drugs::Atc.new value
+                  atc.name.de = name
+                  atc.save
+                  @model.atc = atc
+                else
+                  @errors.store :atc, create_error(:e_unknown_atc, :atc, value)
+                  nil
+                end
+=begin ## temporarily disabled: this should be recoded to work with swiss infos
+       #  in 2.0
+              when :fachinfo_url
+                unless value == @model.fachinfo_url
+                  _import_rtf(:fachinfo, @model, value)
+                end
+              when :patinfo_url
+                unless value == @model.patinfo_url
+                  _import_rtf(:patinfo, @model, value)
+                end
+=end
+              when :registration
+                if(value.empty?)
+                  @model.remove_code(@model.registration)
+                elsif(code = @model.registration)
+                  code.value = value unless code == value
+                else
+                  @model.add_code ODDB::Util::Code.new(:registration, value, 'EU')
+                end
+              when :substance
+                update_compositions(input)
+              end
+        unless(set.nil?)
+          @model.data_origins.store key, email
+        end
+      end
+    }
+    @model.save
+    self
+  end
+  def sequence
+    if((uid = @session.user_input(:uid)) && @model.uid.to_s == uid)
+      self
+    else
+      super
+    end
+  end
+  private
+  def update_compositions(input)
+    saved = nil
+    if(substances = input[:substance])
+      substances.each { |cmp_idx, substances|
+        doses = input[:dose][cmp_idx]
+        gfstr = input[:galenic_form][cmp_idx]
+        cmp_idx = cmp_idx.to_i
+        comp = @model.compositions.at(cmp_idx)
+        if(comp.nil?)
+          comp = ODDB::Drugs::Composition.new
+          comp.sequence = @model
+        end
+        if gfstr.to_s.empty?
+          comp.galenic_form = nil
+        elsif gform = ODDB::Drugs::GalenicForm.find_by_description(gfstr)
+          comp.galenic_form = gform
+        else 
+          key = :"galenic_form[#{cmp_idx}]"
+          @errors.store key, create_error(:e_unknown_galenic_form, key, gfstr)
+        end
+        substances.each { |sub_idx, sub|
+          parts = doses[sub_idx].split(/\s*(?=[^\d.,])/, 2)
+          sub_idx = sub_idx.to_i
+          if(substance = ODDB::Drugs::Substance.find_by_name(sub))
+            changed = false
+            dose = ODDB::Drugs::Dose.new(*parts) unless parts.empty?
+            agent = comp.active_agents.at(sub_idx)
+            if(agent.nil?)
+              agent = ODDB::Drugs::ActiveAgent.new substance, dose
+              agent.composition = comp
+              changed = true
+            end
+            if(agent.substance != substance)
+              agent.substance = substance 
+              changed = true
+            end
+            if(agent.dose != dose)
+              agent.dose = dose
+              changed = true
+            end
+            if changed
+              saved = true
+              agent.save 
+            end
+          else
+            key = :"substance[#{cmp_idx}][#{sub_idx}]"
+            @errors.store key, create_error(:e_unknown_substance, key, sub)
+          end
+        }
+        comp.save
+      }
+    end
+    saved
+  end
+end
+class NewSequence < Sequence
+  def direct_event
+    # disable redirector
+  end
+  def _update input
+    unless @errors[:registration]
+      super
+      Sequence.new(@session, @model)
+    end
+  end
+end
+        end
+      end
+    end
+  end
+end