de.oddb 2.0.0

data/lib/oddb/util/server.rb

@@ -0,0 +1,150 @@
+#!/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 grant_download(*arg)
+        # This method is for bin/admin sub-command
+        usage = "Usage:\n" +
+          "  Set  grant: grant_download 'email address', 'file', Time.local(20yy,mm,dd)\n" +
+          "  Show grant: grant_download 'email address'\n" 
+        email = arg[0]
+        file  = arg[1]
+        expiry_time = arg[2]
+        if arg.length == 3      # register
+          unless user = ODDB::Business::GrantDownload.find_by_email(email)
+            user = ODDB::Business::GrantDownload.new(email)
+          end
+          user.grant_download(file, expiry_time)
+          user.save
+          ODDB.config.http_server + '/de/temp/grant_download/email/' + email + '/file/' + file
+        elsif arg.length == 1   # search
+          if user = ODDB::Business::GrantDownload.find_by_email(email)
+            grant_list = user.grant_list.sort_by{|filename, expirytime| expirytime}.reverse
+            str = grant_list[0..3].map{|x| x[1].strftime("%Y%m%d") + ', ' + x[0]}.join("\n")
+            "grant list(total:" + grant_list.length.to_s + "): odba_id: " + user.uid.to_s + "\n" + str
+          else
+            'No registration for ' + email
+          end
+        else
+          usage
+       end
+      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 peer_cache cache
+        ODBA.peer cache
+      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 unpeer_cache cache
+        ODBA.unpeer cache
+      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/smtp_tls.rb

@@ -0,0 +1,58 @@
+require "openssl"
+require "net/smtp"
+
+Net::SMTP.class_eval do
+  private
+  def do_start(helodomain, user, secret, authtype)
+    raise IOError, 'SMTP session already started' if @started
+    check_auth_args user, secret, authtype if user or secret
+
+    sock = timeout(@open_timeout) { TCPSocket.open(@address, @port) }
+    @socket = Net::InternetMessageIO.new(sock)
+    @socket.read_timeout = 60 #@read_timeout
+    @socket.debug_output = STDERR #@debug_output
+
+    check_response(critical { recv_response() })
+    do_helo(helodomain)
+
+    raise 'openssl library not installed' unless defined?(OpenSSL)
+    starttls
+    ssl = OpenSSL::SSL::SSLSocket.new(sock)
+    ssl.sync_close = true
+    ssl.connect
+    @socket = Net::InternetMessageIO.new(ssl)
+    @socket.read_timeout = 60 #@read_timeout
+    @socket.debug_output = STDERR #@debug_output
+    do_helo(helodomain)
+
+    authenticate user, secret, authtype if user
+    @started = true
+  ensure
+    unless @started
+      # authentication failed, cancel connection.
+      @socket.close if not @started and @socket and not @socket.closed?
+      @socket = nil
+    end
+  end
+
+  def do_helo(helodomain)
+    begin
+      if @esmtp
+        ehlo helodomain
+      else
+        helo helodomain
+      end
+    rescue Net::ProtocolError
+      if @esmtp
+        @esmtp = false
+        @error_occured = false
+        retry
+      end
+      raise
+    end
+  end
+
+  def starttls
+    getok('STARTTLS')
+  end
+end

data/lib/oddb/util/updater.rb

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby
+# Util::Updater -- de.oddb.org -- 02.02.2007 -- hwyss@ywesee.com
+
+require 'date'
+require 'mechanize'
+require 'oddb/import/dimdi'
+require 'oddb/import/gkv'
+require 'oddb/import/pharma24'
+require 'oddb/import/pharmnet'
+require 'oddb/import/whocc'
+require 'oddb/util/mail'
+
+module ODDB
+  module Util
+    module Updater
+      DIMDI_INDEX = "http://www.dimdi.de/static/de/amg/fbag/index.htm"
+      def Updater.import_dimdi
+        if(date = Import::Dimdi.current_date(DIMDI_INDEX))
+          import_dimdi_substances(date)
+          import_dimdi_galenic_forms(date)
+          import_dimdi_products(date)
+        end
+      end
+      def Updater.import_dimdi_galenic_forms(date)
+        file = date.strftime("darreichungsformen-%Y%m.xls")
+        Import::Dimdi.download(file) { |io|
+          reported_import(Import::Dimdi::GalenicForm.new(date), io,
+                          :filetype => 'XLS')
+        }
+      end
+      def Updater.import_dimdi_products(date)
+        file = date.strftime("festbetraege-%Y%m.xls")
+        Import::Dimdi.download(file) { |io|
+          reported_import(Import::Dimdi::Product.new(date), io,
+                         :subject => "Update Festbeträge",
+                         :filetype => 'XLS')
+        }
+      end
+      def Updater.import_dimdi_substances(date)
+        file = date.strftime("wirkstoffkuerzel-%Y%m.xls")
+        Import::Dimdi.download(file) { |io|
+          reported_import(Import::Dimdi::Substance.new(date), io,
+                          :filetype => 'XLS')
+        }
+      end
+      def Updater.import_fachinfos(term, opts = {})
+        importer = Import::PharmNet::Importer.new
+        _reported_import(importer, :filetype => 'HTML') {
+          importer.import_missing(Mechanize.new, term, opts)
+        }
+      rescue StandardError => error
+        ODDB.logger.error('Updater') { error.message }
+      end
+      def Updater.import_gkv(opts = {})
+        importer = Import::Gkv.new
+        if url = opts[:pdf] || importer.latest_url(Mechanize.new, opts)
+          importer.download_latest url, opts do |fh|
+            reported_import(importer, fh,
+                            :subject => 'Zubef', :filetype => 'PDF')
+          end
+        else
+          # This is temporary solution.
+          # This should be composed in reporting email or logging process.
+          host = 'https://www.gkv-spitzenverband.de'
+          url = '/Befreiungsliste_Arzneimittel_Versicherte.gkvnet'
+          print "WARNING: Updater.import_gkv did nothing. It looks failing in grabbing PDF link.\n" 
+          print "Check HTML source code at " + host + url + "\n"
+          print "Probably you have to modify Gkv#latest_url method."
+          print "20100910 masa\n"
+          return nil
+        end
+      end
+      def Updater.import_missing(name)
+        name.split('|').each do |term|
+          Updater.import_fachinfos term, :info_unrestricted => true
+        end
+      end
+      def Updater.import_pharmnet(opts = {})
+        opts = { :replace => true,  :reload  => false, 
+                 :remove  => false, :repair  => false,
+                 :reparse => false, :retries => 3,
+                 :retry_unit => 60 }.update opts
+        importer = Import::PharmNet::Importer.new
+        _reported_import(importer, {:filetype => 'HTML'}, {:skip_totals => true}) {
+          importer._import(Mechanize.new, Drugs::Sequence.all, opts)
+        }
+      rescue StandardError => error
+        ODDB.logger.error('Updater') { error.message }
+      end
+      def Updater.import_product_infos
+        Import::Csv::ProductInfos.download_latest { |io|
+          reported_import(Import::Csv::ProductInfos.new, io, :filetype => 'CSV')
+        }
+      end
+      def Updater.import_whocc_guidelines
+        reported_import(Import::Whocc::Guidelines.new, 
+                        Mechanize.new, :filetype => 'HTML')
+      end
+      def Updater.report_fachinfos
+        importer = Import::PharmNet::Importer.new
+        _reported_import(importer) {
+          importer.report
+        }
+      end
+      def Updater.reported_import(importer, io, subject=nil)
+        _reported_import(importer, subject) { importer.import io }
+      end
+      def Updater._reported_import(importer, args={}, error_args={}, &block)
+        lines = [
+          sprintf("%s: %s %s#import", Time.now.strftime('%c'),
+                  ODDB.config.server_name, importer.class)
+        ]
+        lines.concat block.call(importer)
+      rescue Exception => err
+        lines.push(err.class.to_s, err.message, *err.backtrace)
+        if importer.respond_to?(:report)
+          report = if importer.method(:report).arity == 0
+                     importer.report
+                   else
+                     importer.report(error_args)
+                   end rescue [$!.message]
+          lines.concat report
+        end
+      ensure
+        ft = args[:filetype]
+        fmt = ft ? "%s: %s %s (%s)" : "%s: %s %s"
+        subject = sprintf(fmt, Time.now.strftime('%c'), ODDB.config.server_name,
+                          args[:subject] || importer.class, ft)
+        Mail.notify_admins(subject, lines)
+      end
+      def Updater.run(today = Date.today)
+        run_logged_job 'import_dimdi'
+        run_logged_job 'import_gkv'
+        case today.day
+        when 1
+          run_logged_job 'import_pharmnet'
+          run_logged_job 'import_whocc'
+        when 15
+          run_logged_job 'import_pharma24'
+        end
+      end
+      def Updater.run_logged_job job
+        dir = ODDB.config.oddb_dir
+        cmd = File.join dir, 'jobs', job
+        log = File.join dir, 'log', job
+        IO.popen "#{cmd} log_file=#{log}" do |io|
+          # wait for importer to exit
+        end
+      end
+      def Updater.update_prices(packages = Drugs::Package.all,
+                                opts={:all => false})
+        importer = Import::Pharma24.new
+        _reported_import(importer) {
+          importer.import Mechanize.new, packages
+        }
+      rescue StandardError => error
+        ODDB.logger.error('Updater') { error.message }
+      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