ramaze.ch.oddb.org 1.0.0

data/lib/oddb/util/server.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+# Util::Server -- de.oddb.org -- 01.09.2006 -- hwyss@ywesee.com
+
+require 'oddb/html/util/known_user'
+require 'oddb/html/util/session'
+require 'oddb/html/util/validator'
+require 'oddb/util/exporter'
+require 'oddb/util/ipn'
+require 'oddb/util/updater'
+require 'oddb/export/rss'
+require 'paypal'
+require 'sbsm/drbserver'
+
+module ODDB
+  module Util
+    class Server < SBSM::DRbServer
+      ENABLE_ADMIN = true 
+      SESSION = Html::Util::Session
+      VALIDATOR = Html::Util::Validator
+      def initialize(*args)
+        super
+        @rss_mutex = Mutex.new
+        run_exporter if(ODDB.config.run_exporter)
+        run_updater if(ODDB.config.run_updater)
+      end
+      def _admin(src, result, priority=0)
+        raise "admin interface disabled" unless(self::class::ENABLE_ADMIN)
+        t = Thread.new {
+          Thread.current.abort_on_exception = false
+          begin
+            response = instance_eval(src)
+            str = response.to_s
+            result << if(str.length > 200)
+              response.class
+            else
+              str
+            end.to_s
+          rescue StandardError => error
+            result << error.message
+            require 'pp'
+            ODDB.logger.error('admin') { error.class }
+            ODDB.logger.error('admin') { error.message }
+            ODDB.logger.error('admin') { error.backtrace.pretty_inspect }
+            error
+          end
+        }
+        t[:source] = src
+        t.priority = priority
+        @admin_threads.add(t)
+        t
+      end
+      def create_product name
+        if prod = ODDB::Drugs::Product.find_by_name(name)
+          "The product already exists. You may edit it at http://de.oddb.org/de/drugs/product/uid/#{prod.uid}"
+        else
+          prod = ODDB::Drugs::Product.new
+          prod.name.de = name
+          prod.save
+          "Success! You may now edit the product at http://de.oddb.org/de/drugs/product/uid/#{prod.uid}"
+        end
+      end
+      def generate_dictionary(language, locale)
+        ODBA.storage.remove_dictionary(language)
+        base = File.join(ODDB.config.data_dir,
+                         "fulltext", "data", "dicts", language)
+        ODBA.storage.generate_dictionary(language, locale, base)
+      end
+      def generate_dictionaries
+        generate_dictionary('german', 'de_DE@euro')
+      end
+      def ipn(notification)
+        Util::Ipn.process notification
+        nil # don't return the invoice back across drb - it's not defined in yipn
+      end
+      def login(email, pass)
+        session = ODDB.auth.login(email, pass, ODDB.config.auth_domain)
+        Html::Util::KnownUser.new(session)
+      end
+      def logout(session)
+        ODDB.auth.logout(session)
+      rescue DRb::DRbError, RangeError, NameError
+      end
+      def run_at(hour, &block)
+        Thread.new {
+          loop {
+            now = Time.now 
+            run_at = Time.local(now.year, now.month, now.day, hour)
+            while(now > run_at)
+              run_at += 24*60*60
+            end
+            sleep(run_at - now)
+            block.call
+          }
+        }
+      end
+      def run_exporter
+        @exporter = run_at(ODDB.config.export_hour) { Exporter.run }
+      end
+      def run_updater
+        @updater = run_at(ODDB.config.update_hour) { Updater.run }
+      end
+      def update_feedback_rss_feed
+        async {
+          begin
+            @rss_mutex.synchronize {
+              Export::Rss::Feedback.new.export
+            }
+          rescue StandardError => error
+            ODDB.logger.error('rss_feed') { error.class }
+            ODDB.logger.error('rss_feed') { error.message }
+            ODDB.logger.error('rss_feed') { error.backtrace.pretty_inspect }
+          end
+        }
+      end
+    end
+  end
+end

data/lib/oddb/util/updater.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# Util::Updater -- de.oddb.org -- 02.02.2007 -- hwyss@ywesee.com
+
+require 'date'
+require 'mechanize'
+require 'oddb/import/whocc'
+require 'oddb/util/mail'
+
+module ODDB
+  module Util
+    module Updater
+      def Updater.import_whocc_guidelines
+        reported_import(Import::Whocc::Guidelines.new, 
+                        WWW::Mechanize.new)
+      end
+      def Updater.reported_import(importer, io, subject=nil)
+        _reported_import(importer, subject) { importer.import io }
+      end
+      def Updater._reported_import(importer, subject=nil, &block)
+        lines = [
+          sprintf("%s: %s#import", Time.now.strftime('%c'), importer.class)
+        ]
+        lines.concat block.call
+      rescue StandardError => err
+        lines.push(err.class.to_s, err.message, *err.backtrace)
+        if importer.respond_to?(:report)
+          lines.concat importer.report rescue [$!.message]
+        end
+        raise
+      ensure
+        subject = sprintf("%s: %s", 
+                          Time.now.strftime('%c'), subject || importer.class)
+        Mail.notify_admins(subject, lines)
+      end
+      def Updater.run(today = Date.today)
+        ## disabled until 2.0
+      end
+    end
+  end
+end

data/lib/oddb/util/ydim.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+# Util::Ydim -- de.oddb.org -- 30.01.2008 -- hwyss@ywesee.com
+
+require 'ydim/config'
+require 'ydim/client'
+require 'oddb/config'
+require 'oddb/util/yus'
+require 'openssl'
+
+module ODDB
+  module Util
+module Ydim
+  DATE_FMT = "%d.%m.%Y"
+  SALUTATIONS = {
+    'salutation_m'  =>  'Herr',  
+    'salutation_f'  =>  'Frau',  
+  }
+  def Ydim.connect(&block)
+    config = YDIM::Client::CONFIG
+    server = DRbObject.new(nil, config.server_url)
+    client = YDIM::Client.new(config)
+    key = OpenSSL::PKey::DSA.new(File.read(config.private_key))
+    client.login(server, key)
+    block.call(client)
+  ensure
+    client.logout if(client)
+  end
+  def Ydim.create_debitor(email)
+    connect { |client|
+      keys = [ :salutation, :name_last, :name_first ]
+      info = Util::Yus.get_preferences(email, keys)
+      debitor = client.create_debitor
+      debitor.salutation = SALUTATIONS[info[:salutation]]
+      debitor.contact_firstname = info[:name_first]
+      debitor.contact = info[:name_last]
+      debitor.debitor_type = 'dt_info'
+      debitor.email = email
+      debitor.save
+      debitor
+    }
+  end
+  def Ydim.debitor_id(email)
+    if(id = Util::Yus.get_preference(email, :ydim_id))
+      id
+    elsif(debitor = identify_debitor(email))
+      debitor.unique_id
+    else
+      create_debitor(email).unique_id
+    end
+  end
+  def Ydim.identify_debitor(email)
+    connect { |client|
+      client.search_debitors(email).first
+    }
+  end
+  def Ydim.inject(invoice, opts = {:payment_received => false})
+    if(id = invoice.ydim_id)
+      Ydim.connect { |client| client.invoice(id) }
+    elsif(email = invoice.yus_name)
+      ydim_inv = inject_from_items(invoice_date(invoice), email, invoice.items,
+                                  invoice.currency || 'EUR')
+      ydim_inv.payment_received = opts[:payment_received]
+      ydim_inv.save
+      invoice.ydim_id = ydim_inv.unique_id
+      invoice.save
+      ydim_inv
+    end
+  end
+  def Ydim.inject_from_items(date, email, items, currency='EUR')
+    connect { |client|
+      debitor_id = debitor_id(email)
+      Util::Yus.set_preference(email, :ydim_id, debitor_id)
+      ydim_inv = client.create_invoice(debitor_id)
+      ydim_inv.description = invoice_description(items)
+      ydim_inv.date = date
+      ydim_inv.currency = currency
+      ydim_inv.payment_period = ODDB.config.payment_period
+      item_data = sort_items(items).collect { |item| 
+        if(sprintf('%1.2f', item.quantity) == "0.00")
+          ydim_inv.precision = 3
+        end
+        item.ydim_data 
+      }
+      client.add_items(ydim_inv.unique_id, item_data)
+      ydim_inv
+    }
+  end
+  def Ydim.invoice_date(invoice)
+    Date.new(invoice.time.year, invoice.time.month, invoice.time.day)
+  end
+  def Ydim.invoice_description(items)
+    types = []
+    items.each { |item| types.push(item.type) }
+    main = items.first
+    if(types.include?(:poweruser))
+      exp = main.expiry_time || main.time + (24 * 60 *60)
+      sprintf("PowerUser %s %s - %s", ODDB.config.server_name, 
+              main.time.strftime(DATE_FMT), exp.strftime(DATE_FMT))
+    else
+      sprintf("%s %s", ODDB.config.server_name, main.time.strftime(DATE_FMT))
+    end
+  end
+  def Ydim.sort_items(items)
+    items.sort_by { |item| 
+      [item.time.to_i / (24 * 60 * 60), item.text, item.type.to_s]
+    }
+  end
+end
+  end
+end

data/lib/oddb/util/yus.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# Yus -- de.oddb.org -- 30.01.2008 -- hwyss@ywesee.com
+
+require 'drb'
+require 'yus/session'
+
+module ODDB
+  module Util
+module Yus
+  def Yus.create_user(email, pass=nil)
+    Yus.server.autosession(ODDB.config.auth_domain) { |session|
+      session.create_entity(email, pass)
+    }
+    # if there is a password, we can log in
+    ODDB.server.login(email, pass) if(pass)
+  end
+  def Yus.get_preference(name, key)
+    Yus.server.autosession(ODDB.config.auth_domain) { |session|
+      session.get_entity_preference(name, key)
+    }
+  rescue ::Yus::YusError
+    nil # return nil
+  end
+  def Yus.get_preferences(name, *keys)
+    Yus.server.autosession(ODDB.config.auth_domain) { |session|
+      session.get_entity_preferences(name, keys.flatten)
+    }
+  rescue ::Yus::YusError
+    {} # return an empty hash
+  end
+  def Yus.grant(name, key, item, expires=nil)
+    Yus.server.autosession(ODDB.config.auth_domain) { |session|
+      session.grant(name, key, item, expires)
+    }
+  end
+  def Yus.server
+    DRb::DRbObject.new(nil, ODDB.config.auth_server)
+  end
+  def Yus.set_preference(name, key, value, domain=ODDB.config.auth_domain)
+    Yus.server.autosession(ODDB.config.auth_domain) { |session|
+      session.set_entity_preference(name, key, value, domain)
+    }
+  end
+end
+  end
+end

data/test/business/test_company.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# Business::TestCompany -- de.oddb.org -- 22.11.2006 -- hwyss@ywesee.com
+
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'flexmock'
+require 'test/unit'
+require 'oddb/business/company'
+
+module ODDB
+  module Business
+    class TestCompany < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        @company = Company.new
+      end
+      def test_packages
+        prod1 = flexmock('product')
+        prod2 = flexmock('product')
+        @company.add_product(prod1)
+        @company.add_product(prod2)
+        prod1.should_receive(:packages).and_return(['foo', 'bar'])
+        prod2.should_receive(:packages).and_return(['baz'])
+        assert_equal(['foo', 'bar', 'baz'], @company.packages)
+      end
+    end
+  end
+end

data/test/business/test_price.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# Business::TestPrice -- ch.oddb.org -- 24.07.2009 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'oddb/business/price'
+require 'oddb/util/money'
+
+module ODDB
+  module Business
+class TestPrice < Test::Unit::TestCase
+  def setup
+    @price = Price.new
+  end
+  def test_empty
+    assert_nil @price.current
+    assert_equal 0.0, @price.to_f
+    assert_equal true, @price.is_for?(nil, nil)
+    assert_equal false, @price.is_for?(nil, 'CH')
+    assert_equal false, @price.is_for?(:public, nil)
+  end
+  def test_values
+    @price.value = Util::Money.new 12.5
+    assert_equal 12.5, @price
+    older = Util::Money.new 10.5
+    time = Time.now - 3600
+    older.valid_from = time
+    @price.value = older
+    assert_equal 12.5, @price
+    assert_equal 10.5, @price.at(time)
+    @price.value = 15
+    assert_equal 15, @price
+    assert_instance_of Util::Money, @price.current
+    time = Time.now - 1800
+    @price.value = 11, time
+    assert_equal 11, @price.at(time)
+  end
+  def test_argument_error
+    assert_raises(ArgumentError) do
+      @price.value = "foobar"
+    end
+  end
+end
+  end
+end

data/test/drugs/test_active_agent.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# Drugs::TestActiveAgent -- de.oddb.org -- 22.11.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'flexmock'
+require 'test/unit'
+require 'oddb/drugs/active_agent'
+require 'oddb/drugs/dose'
+
+module ODDB
+  module Drugs
+    class TestActiveAgent < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_create
+        substance = flexmock('substance')
+        dose = Dose.new(100, 'mg')
+        agent = ActiveAgent.new(substance, dose)
+        assert_equal(dose, agent.dose)
+        agent = ActiveAgent.new(substance, 100, 'mg')
+        assert_equal(dose, agent.dose)
+      end
+      def test_equality
+        substance = flexmock('substance')
+        dose = Dose.new(100, 'mg')
+        agent = ActiveAgent.new(substance, dose)
+        equal = ActiveAgent.new(substance, dose)
+        assert_equal(true, agent == equal)
+        assert_equal(true, equal == agent)
+
+        other = ActiveAgent.new(substance, Dose.new(200, 'mg'))
+        assert_equal(false, other == agent)
+        assert_equal(false, agent == other)
+        
+        substance = flexmock('different substance')
+        other = ActiveAgent.new(substance, dose)
+        assert_equal(false, other == agent)
+        assert_equal(false, agent == other)
+
+        other.chemical_equivalence = equal
+        assert_equal(true, other == agent)
+        assert_equal(true, agent == other)
+      end
+      def test_equality__nil
+        substance = flexmock('substance')
+        dose = Dose.new(100, 'mg')
+        agent = ActiveAgent.new(substance, dose)
+
+        assert_equal(false, agent == nil)
+      end
+    end
+  end
+end