ramaze.ch.oddb.org 1.0.0

data/lib/oddb/html/util/need_all_input.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# Html::Util::NeedAllInput -- de.oddb.org -- 08.04.2008 -- hwyss@ywesee.com
+
+module ODDB
+  module Html
+    module Util
+module NeedAllInput
+  def user_input(keys, mandatory)
+    input = super
+    pass1 = input[:pass]
+    pass2 = input[:confirm_pass]
+    unless(@user || pass1 == pass2)
+      err1 = create_error(:e_non_matching_set_pass, :pass, pass1)
+      err2 = create_error(:e_non_matching_set_pass, :confirm_pass, pass2)
+      @errors.store(:pass, err1)
+      @errors.store(:confirm_pass, err2)
+    end
+    msg = 'e_need_all_input'
+    @errors.each { |key, err|
+      if(err.message.match(/^e_missing_/))
+        @errors.store(key, create_error(msg, key, err.value))
+      end
+    }
+    input
+  end
+end
+    end
+  end
+end

data/lib/oddb/html/util/session.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+# Html::Util::Session -- de.oddb.org -- 27.10.2006 -- hwyss@ywesee.com
+
+require 'oddb/config'
+require 'oddb/html/state/drugs/init'
+require 'oddb/html/state/global'
+require 'oddb/html/state/drugs/global'
+require 'oddb/html/util/lookandfeel'
+require 'sbsm/redirector'
+require 'sbsm/session'
+
+module ODDB
+  module Html
+    module Util
+class Session < SBSM::Session
+  attr_reader :desired_state
+  include SBSM::Redirector
+  DEFAULT_FLAVOR = 'oddb'
+  DEFAULT_LANGUAGE = 'de'
+  DEFAULT_STATE = State::Drugs::Init
+  DEFAULT_ZONE = 'drugs'
+  EXPIRES = ODDB.config.session_timeout
+  LF_FACTORY = LookandfeelFactory
+  @@requests ||= {}
+  def Session.reset_query_limit(ip = nil)
+    if(ip)
+      @@requests.delete(ip)
+    else
+      @@requests.clear
+    end
+  end
+  def allowed?(*args)
+    @user.allowed?(*args)
+  rescue
+    false
+  end
+  def limit_queries
+    requests = (@@requests[remote_ip] ||= [])
+    if(@state.limited?)
+      requests.delete_if { |other| 
+        (@process_start - other) >= ODDB.config.query_limit_phase
+      }
+      requests.push(@process_start)
+      if(requests.size > ODDB.config.query_limit)
+        @desired_state = @state
+        @active_state = @state = @state.limit_state
+        @state.request_path = @desired_state.request_path
+      end
+    end
+  end
+  def login
+    @user = @app.login(user_input(:email), user_input(:pass))
+    @user.session = self if(@user.respond_to?(:session=))
+    @user
+  end
+  def logout
+    @app.logout(@user.auth_session) if(@user.respond_to?(:auth_session))
+    super
+  end
+  def navigation
+    state.navigation
+  end
+  def pagelength
+    100
+  end
+  def passed_turing_test?
+    ## At the moment, attempting to produce a captcha using the Turing-Gem
+    #  results in a Segmentation-Fault. Returning true here is a convenient way
+    #  of disabling the captcha.
+    # state.respond_to?(:passed_turing_test) && state.passed_turing_test
+    true
+  end
+  def process(request)
+    @request_path = request.unparsed_uri
+    @process_start = Time.now
+    super
+    if(!is_crawler? && lookandfeel.enabled?(:query_limit))
+      limit_queries 
+    end
+    '' ## return empty string across the drb-border
+  end
+  def server_name
+    super || @server_name = ODDB.config.server_name
+  end
+end
+    end
+  end
+end

data/lib/oddb/html/util/sort.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+# Html::Util::Sort -- de.oddb.org -- 07.12.2006 -- hwyss@ywesee.com
+
+module ODDB
+  module Html
+    module Util
+module Sort
+  def sort
+    _sort
+    self
+  end
+  def _sort
+    if(key = @session.user_input(:sortvalue))
+      sort_by(key.to_sym)
+    end
+  end
+  def sort_by(key, default='')
+    sorter = sort_proc(key) || Proc.new { |pac| pac.send(key) || default }
+    if(@sortvalue == key)
+      @reverse = !@reverse
+    else
+      @reverse = false
+      @sortvalue = key
+    end
+    @model = _sort_by(@model, @reverse, &sorter)
+  end
+  def _sort_by(model, reverse, &sorter)
+    model = model.sort_by(&sorter)
+    if(reverse)
+      model.reverse!
+    end
+    model
+  end
+  def sort_proc(key)
+  end
+end
+module PackageSort
+  include Sort
+  def sort_proc(key)
+    case key
+    when :company
+      Proc.new { |pac| 
+        (multilingual = pac.send(key)) \
+          && multilingual.name.send(@session.language) || '' }
+    when :ddd_prices
+      Proc.new { |pac| 
+        pac.ddds.collect { |ddd| pac.dose_price(ddd.dose) }.compact
+      }
+    when :difference
+      nilval = 9999999.0
+      Proc.new { |pac| pac.difference || nilval }
+    when :package_infos
+      Proc.new { |pac| [ 
+        pac.code(:festbetragsgruppe).to_s,
+        pac.code(:festbetragsstufe).to_s,
+        pac.code(:prescription).to_s, 
+        pac.code(:zuzahlunggsbefreit).to_s,
+      ] }
+    when :price_public, :price_festbetrag
+      nilval = ODDB::Util::Money.new(0)
+      key = key.to_s.sub(/^price_/, '').to_sym
+      Proc.new { |pac| pac.price(key) || nilval }
+    when :product
+      Proc.new { |pac| 
+        pac.name.send(@session.language) \
+          || ((prod = pac.product) && prod.name.send(@session.language)) || '' }
+    end
+  end
+end
+    end
+  end
+end

data/lib/oddb/html/util/unsaved_helper.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# Html::Util::UnsavedHelper -- de.oddb.org -- 10.04.2008 -- hwyss@ywesee.com
+
+module ODDB
+  module Html
+    module Util
+class UnsavedHelper
+  attr_reader :delegate
+  def initialize(delegate)
+    @delegate = delegate
+  end
+  def method_missing(key, *args, &block)
+    unless /^(add_|save$)/.match(key.to_s)
+      @delegate.send(key, *args, &block)
+    end
+  end
+end
+    end
+  end
+end

data/lib/oddb/html/util/validator.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# Html::Util::Validator -- de.oddb.org -- 02.11.2006 -- hwyss@ywesee.com
+
+require 'sbsm/validator'
+
+module ODDB
+  module Html
+    module Util
+class Validator < SBSM::Validator
+  BOOLEAN = [ :code_prescription, :code_zuzahlungsbefreit, :email_public,
+              :item_good_experience, :item_good_impression, :item_recommended,
+              :item_helps, ]
+  ENUMS = {
+    :display   => ['paged', 'grouped'],
+    :dstype    => ['tradename', 'compare', 'substance', 'company',
+                   'indication'],
+    :range     => ("A".."Z").to_a.push('0-9'),
+    :salutation => [nil, "salutation_f", "salutation_m"],
+    :sortvalue => [ 'active_agents', 'atc', 'code_festbetragsstufe',
+      'code_zuzahlungsbefreit', 'company', 'ddd_prices', 'difference',
+      'doses', 'package_infos', 'price_festbetrag', 'price_difference',
+      'price_public', 'product', 'size', 
+    ],
+  }
+  EVENTS = [ :ajax_autofill, :ajax_create_active_agent, :ajax_create_composition,
+             :ajax_create_part, :ajax_delete_active_agent, 
+             :ajax_delete_composition, :ajax_delete_part, :atc_assign,
+             :atc_browser, :collect, :ddd, :delete, :explain_ddd_price,
+             :explain_price, :fachinfo, :feedback, :checkout, :compare,
+             :compare_remote, :home, :login, :login_, :logout, :new_package,
+             :new_sequence, :package, :package_infos, :patinfo, :proceed_export,
+             :proceed_poweruser, :product, :products, :remote_infos, :search,
+             :sequence, :sort, :update ]
+  NUMERIC = [ :active_agent, :code_festbetragsgruppe,
+              :code_festbetragsstufe, :composition, :days, :equivalence_factor,
+              :multi, :offset, :part, :price_exfactory, :price_festbetrag,
+              :price_public, :sequence, :size ]
+  PATTERNS = {
+    :atc => /[ABCGHJLMNPRSV](\d{2}([A-Z]([A-Z](\d{2})?)?)?)?/,
+  }
+  STRINGS = [ :atc_name, :captcha, :chapter, :code, :code_cid, :company, :dose,
+              :fachinfo_url, :galenic_form, :invoice, :message, :name,
+              :name_first, :name_last, :patinfo_url, :cid, :quantity, :query,
+              :registration, :substance, :uid, :unit ]
+  def page(value) 
+    if(num = validate_numeric(:page, value))
+      # pages are 1-based for the human user
+      [num.to_i - 1, 0].max
+    end
+  end
+end
+    end
+  end
+end

data/lib/oddb/html/view/ajax/json.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# Html::View::Ajax::Json -- oddb -- 22.06.2006 -- hwyss@ywesee.com
+
+require 'htmlgrid/component'
+require 'json'
+
+module ODDB
+  module Html
+    module View
+      module Ajax
+class Json < HtmlGrid::Component
+  HTTP_HEADERS = {
+    'Content-Type'  =>  'text/javascript; charset=UTF-8',
+  }
+  def to_html(context)
+    @model.to_json
+  end
+end
+      end
+    end
+  end
+end

data/lib/oddb/html/view/alpha_header.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# Html::View::AlphaHeader -- de.oddb.org -- 07.12.2006 -- hwyss@ywesee.com 
+
+module ODDB
+  module Html
+    module View
+module AlphaHeader
+  EMPTY_LIST_KEY = :choose_range
+  def compose_header(offset=[0,0])
+    offset = super
+    current_range = @model.query
+    @session.state.intervals.each { |range|
+      link = HtmlGrid::Link.new(:range, @model, @session, self)
+      link.value = range
+      unless(range == current_range)
+        link.href = @lookandfeel._event_url(@session.direct_event,
+          'range' => range)
+      end
+      @grid.add(link, *offset)
+    }
+    @grid.set_colspan(offset.at(0), offset.at(1), full_colspan)
+    @grid.add_attribute('id', 'alphaheader', *offset)
+    resolve_offset(offset, self::class::OFFSET_STEP)
+  end
+end
+    end
+  end
+end

data/lib/oddb/html/view/document.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+# Html::View::Document -- de.oddb.org -- 30.10.2007 -- hwyss@ywesee.com
+
+require 'htmlgrid/divlist'
+require 'htmlgrid/image'
+
+module ODDB
+  module Html
+    module View
+class ChapterNames < HtmlGrid::DivList
+  COMPONENTS = {
+    [0,0] => :link,
+  }
+  def initialize(type, *args)
+    @document_type = type
+    super(*args)
+  end
+  def init
+    @current = @session.user_input(:chapter)
+    @model = @model.chapter_names.unshift(nil)
+    super
+    @css_grid = @model.collect { |name| 
+      { "id" => "chapter_%s" % name || @document_type } 
+    }
+  end
+  def link(model)
+    link = HtmlGrid::Link.new("chapter_#{model || @document_type}", 
+                              model, @session, self)
+    if(@current != model)
+      event, args = @session.direct_event
+      args.push :chapter, model if(model)
+      link.href = @lookandfeel._event_url(event, args)
+    end
+    link.value ||= model
+    link
+  end
+end
+class Chapter < HtmlGrid::Component
+  STYLES = {
+    "b"     => [["font-weight", "bold"]],
+    "i"     => [["font-style", "italic"]],
+    "sub"   => [["vertical-align", "sub"], ["font-size", "smaller"]],
+    "sup"   => [["vertical-align", "sup"], ["font-size", "smaller"]],
+    "symbol"=> [["font-family", "symbol, 'Standard Symbols L'"]],
+    "u"     => [["text-decoration", "underline"]],
+  }
+  def to_html(context)
+    @model.paragraphs.inject('') { |memo, paragraph|
+      memo << case paragraph
+              when Text::Picture
+                context.img(:src => paragraph.path, :alt => paragraph.filename)
+              when Text::Table
+                formatted_table(context, paragraph)
+              else
+                formatted_paragraph(context, paragraph)
+              end
+    }
+  end
+  def formatted_paragraph(context, paragraph)
+    return '' unless paragraph
+    args = {}
+    if paragraph.respond_to?(:preformatted?) && paragraph.preformatted?
+      args.store 'style', 'white-space:pre;font-family:fixed-width,Courier'
+    end
+    context.p(args) {
+      _formatted_paragraph(context, paragraph)
+    }
+  end
+  def _formatted_paragraph(context, paragraph)
+    return '' unless paragraph
+    paragraph.formats.inject('') { |memo, format|
+      memo << formatted_string(context, format.values) { 
+        paragraph[format.range].gsub(/\n/, context.br)
+      }
+    }
+  end
+  def formatted_string(context, stack, &block)
+    if(stack.empty?)
+      block.call
+    else
+      styles = stack.inject({}) { |memo, fmt| 
+        if pairs = STYLES[fmt]
+          pairs.each { |pair| memo.store(*pair) } 
+        else
+          warn "unknown style '#{fmt.inspect}'"
+        end
+        memo
+      }
+      args = { :style => styles.collect { |pair| pair.join(":") }.join(";") }
+      context.span(args) { block.call }
+    end
+  end
+  def formatted_table(context, table)
+    context.table {
+      memo = ''
+      table.each_normalized { |row|
+        memo << context.tr {
+          row.inject('') { |tr, cell| 
+            args = {}
+            if(cell && (align = cell.align))
+              args.store :style, "text-align: #{align}"
+            end
+            tr << context.td(args) { _formatted_paragraph(context, cell) }
+          }
+        }
+      }
+      memo
+    }
+  end
+end
+class Document < HtmlGrid::DivList
+  COMPONENTS = {
+    [0,0] => Chapter,
+  }
+  CSS_MAP = ["chapter"]
+  def init
+    @model = @model.chapters
+    if(name = @session.user_input(:chapter))
+      @model = @model.select { |chapter| chapter.name == name }
+    end
+    super
+  end
+end
+    end
+  end
+end