sandozxmlconv 1.0.0

data/lib/conversion/xundart_bdd.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# Conversion::XundartBdd -- xmlconv -- 16.07.2009 -- hwyss@ywesee.com
+
+require 'conversion/pharmacieplus_bdd'
+
+module XmlConv
+  module Conversion
+    class XundartBdd < PharmaciePlusBdd
+class << self
+  ## this is essentially the same format as PharmaciePlus - with the exception of
+  #  what fields are used to transmit names. The PharmaciePlus converter needs to
+  #  uncross last-name and pharmacy-name. The following two overriding methods
+  #  remove this switch. From a design point-of view this is really the wrong way
+  #  around (it would be better to have specialized behavior in the descendent
+  #  class), but historically, and in terms of the
+  #  "Xundart-is-a-PharmaciePlus-Format"-Relation, this seems the best way to
+  #  do it.
+  def _delivery_add_xml_customer(delivery, xml_delivery)
+    customer = Model::Party.new
+    customer.role = 'Customer'
+    _customer_add_party(customer, '1075', 'BillTo')
+    ship_to = _customer_add_party(customer,
+                                  _latin1(xml_delivery.attributes['ean']),
+                                  'ShipTo')
+    if(xml_header = REXML::XPath.first(xml_delivery, 'livraison'))
+      name = Model::Name.new
+      # Pharmacieplus delivers the Pharmacy-Name in 'last-name', and the name
+      # of the contact person in 'other-name' - we need to juggle the pieces
+      # around a bit. (see also _party_add_xml_address)
+      if(xml_name = REXML::XPath.first(xml_header, 'last-name'))
+        name.last = _latin1(xml_name.text)
+      end
+      if(xml_name = REXML::XPath.first(xml_header, 'first-name'))
+        name.first = _latin1(xml_name.text)
+      end
+      if(xml_name = REXML::XPath.first(xml_header, 'other-name'))
+        name.text = _latin1(xml_name.text)
+      end
+      customer.name = name
+      ship_to.name = name
+      _party_add_xml_address(ship_to, xml_header)
+    end
+    if(xml_email = REXML::XPath.first(xml_delivery, '//groupe/online/email'))
+      customer.add_id('email', _latin1(xml_email.text))
+    end
+    delivery.add_party(customer)
+  end
+  def _party_add_xml_address(party, xml_header)
+    if(xml_address = REXML::XPath.first(xml_header, 'address'))
+      address = Model::Address.new
+      address.zip_code = _text(xml_address, 'zip')
+      address.city = _text(xml_address, 'city')
+      if(line = _text(xml_address, 'street'))
+        address.add_line(line)
+      end
+      party.address = address
+    end
+  end
+  ## this method adapts Xundart to the fact that the number of items is stored
+  #  in the attribute qte_facture instead of qte-facture - for whatever reason...
+  def _delivery_add_xml_item(delivery, xml_item)
+    item = Model::DeliveryItem.new
+    item.line_no = _latin1(delivery.items.size.next.to_s)
+    item.add_id('ET-Nummer', _latin1(xml_item.attributes['ean']))
+    item.add_id('Pharmacode', _latin1(xml_item.attributes['pharmacode']))
+    item.qty = _latin1(xml_item.attributes['qte_facture'])
+    item.unit = 'PCE'
+    delivery.add_item(item)
+  end
+end
+    end
+  end
+end

data/lib/postprocess/bbmb.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+# PostProcess::Bbmb -- xmlconv2 -- 25.08.2006 -- hwyss@ywesee.com
+
+require 'drb'
+
+module XmlConv
+  module PostProcess
+    module Bbmb
+      def Bbmb.inject(drb_url, name_short, inject_id, transaction=nil)
+        ## inject with 4 arguments is a special case where the recipient is 
+        #  not known in BBMB. In all other cases we can take the inject_id
+        #  directly from customer.acc_id. If so, inject is called with 
+        #  3 arguments, with transaction as the third argument.
+        if(transaction.nil?)
+          transaction = inject_id
+          inject_id = nil
+        end
+        if(bdd = transaction.model)
+          bbmb = DRbObject.new(nil, drb_url)
+          bdd.deliveries.each { |delivery|
+            begin
+              iid  = inject_id || delivery.customer.acc_id
+              order = order(delivery)
+              info = info(delivery)
+              bbmb.inject_order(name_short, iid, order, info)
+            rescue Exception => e
+              message = "Bestellung OK, Eintrag in BBMB Fehlgeschlagen:\n" \
+                << e.class.to_s << "\n" \
+                << e.message << "\n\n" \
+                << e.backtrace.join("\n") << "\n\n" \
+                << "name_short: #{name_short}\n" \
+                << "hospital: #{inject_id}\n"
+              if(order)
+                message << "\norder: \n"
+                order.each { |k,v|  message << "#{k.inspect} => #{v}\n" }
+              end
+              if(info)
+                message << "\ninfo: \n"
+                  info.each { |k,v| message << "#{k} => #{v}\n" }
+              end
+              raise message
+            end
+          }
+        end
+      end
+      def Bbmb.item_ids(item)
+        item.id_table.inject({}) { |memo, (domain, value)|
+          key = case domain
+                when 'et-nummer'
+                  :article_ean13
+                when 'pharmacode'
+                  :article_pcode
+                when 'lieferantenartikel'
+                  :article_number
+                end
+          memo.store(key, value.gsub(/^0+/, ''))
+          memo
+        }
+      end
+      def Bbmb.order(delivery)
+        pairs = []
+        delivery.items.each { |item|
+          pairs.push([item_ids(item), item.qty.to_i])
+        }
+        pairs
+      end
+      def Bbmb.info(delivery)
+        info = {
+          :order_reference => delivery.customer_id,
+        }
+        if(date = delivery.delivery_date)
+          info.store(:order_expressdate, date)
+        end
+        lines = []
+        if((cust = delivery.customer) && ship = cust.ship_to)
+          lines.push(ship.acc_id)
+          lines.push(ship.name)
+          if(addr = ship.address)
+            lines.concat(addr.lines)
+            lines.push([addr.zip_code, addr.city].compact.join(' '))
+          end
+          info.store(:order_comment, lines.compact.join("\n"))
+        end
+        info
+      end
+    end
+  end
+end

data/lib/postprocess/bbmb2.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+# PostProcess::Bbmb2 -- xmlconv2 -- 25.08.2006 -- hwyss@ywesee.com
+
+require 'drb'
+require 'iconv'
+
+module XmlConv
+  module PostProcess
+    module Bbmb2
+      def Bbmb2.inject(drb_url, idtype, transaction=nil)
+        if transaction.nil?
+          transaction, idtype = idtype, nil
+        end
+        if(bdd = transaction.model)
+          bbmb = DRbObject.new(nil, drb_url)
+          messages = []
+          bdd.deliveries.each_with_index { |delivery, idx|
+            inject_id, order, info = nil
+            begin
+              customer = delivery.customer
+              inject_id = customer.acc_id
+              name = customer.name
+              if ship = customer.ship_to
+                name = ship.name
+                if addr = ship.address
+                  name = addr.lines.first
+                end
+                inject_id ||= ship.acc_id
+              end
+              inject_id ||= customer.party_id
+              order = order(delivery)
+              info = info(delivery)
+							options = {
+								:deliver => true,
+								:create_missing_customer => idtype.to_s,
+								:transaction => transaction.transaction_id.to_s,
+								:customer_name => name.to_s,
+							}
+							resp = bbmb.inject_order(inject_id, order, info, options)
+              transaction.respond(idx, resp)
+            rescue Exception => e
+              transaction.respond(idx, :products => order)
+              message = "Bestellung OK, Eintrag in BBMB Fehlgeschlagen:\n" \
+                << e.class.to_s << "\n" \
+                << e.message << "\n\n" \
+                << e.backtrace.join("\n") << "\n\n" \
+                << "hospital: #{inject_id}\n"
+              if(order)
+                message << "\norder: \n"
+                order.each { |k|  message << "#{k.inspect}\n" }
+              end
+              if(info)
+                message << "\ninfo: \n"
+                  info.each { |k,v| message << "#{k} => #{v}\n" }
+              end
+              messages.push message
+            end
+          }
+          unless messages.empty?
+            raise messages.join("\n\n")
+          end
+          transaction.status = :bbmb_ok
+        end
+      end
+      def Bbmb2.item_ids(item)
+        item.id_table.inject({}) { |memo, (domain, value)|
+          key = case domain
+                when 'et-nummer'
+                  :ean13
+                when 'pharmacode'
+                  :pcode
+                when 'lieferantenartikel'
+                  :article_number
+                end
+          memo.store(key, value.gsub(/^0+/, ''))
+          memo
+        }
+      end
+      def Bbmb2.order(delivery)
+        delivery.items.collect { |item|
+          data = item_ids(item)
+          data.store(:quantity, item.qty.to_i)
+          data
+        }
+      end
+      def Bbmb2.info(delivery)
+        info = {
+          :reference => iconv(delivery.customer_id),
+        }
+        lines = []
+        if(text = delivery.free_text)
+          info.store(:comment, iconv(text))
+        end
+        info
+      end
+      def Bbmb2.iconv(str)
+        @iconv ||= Iconv.new('utf8', 'latin1')
+        @iconv.iconv str
+      end
+    end
+  end
+end

data/lib/postprocess/soap.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# PostProcess::Soap -- xmlconv2 -- 25.08.2006 -- hwyss@ywesee.com
+
+module XmlConv
+  module PostProcess
+    module Soap
+      def Soap.update_partner(transaction)
+        if((bdd = transaction.model) && (delivery = bdd.deliveries.first) \
+           && (bsr = delivery.bsr) && (customer = bsr.customer))
+          transaction.partner = customer.acc_id || customer.party_id
+        end
+      end
+    end
+  end
+end

data/lib/sandozxmlconv.rb

@@ -0,0 +1,3 @@
+class Oddb.org
+    VERSION = '1.0.0'
+end

data/test/mock.rb

@@ -0,0 +1,149 @@
+# Ruby/Mock version 1.0
+# 
+# A class for conveniently building mock objects in RUnit test cases.
+# Copyright (c) 2001 Nat Pryce, all rights reserved
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+require 'runit/error'
+
+
+class Mock
+    # Creates a new, named mock object. The name is reported in exceptions
+    # thrown by the mock object when method invocations are incorrect.
+    # 
+    def initialize( mock_name = self.to_s )
+        @mock_calls = []
+        @next_call = 0
+        @name = mock_name
+    end
+    
+    # Mock the next method call to be made to this mock object.
+    # 
+    # A mock method is defined by the method name (a symbol) and a block
+    # that defines the arity of the method and the mocked behaviour for
+    # this call.  The mocked behaviour should assert preconditions and
+    # return a value.  Mocked behaviour should rarely be any more complex
+    # than that.  If it is,  that's probably an indication that the tests
+    # need some restructuring or that the tested code needs refactoring.
+    # 
+    # If no block is given and preconditions have been defined for the named
+    # method, a block is created for the mocked methodthat has the same arity
+    # as the precondition and returns self.
+    # 
+    def __next( name, &test )
+        if test == nil
+            if respond_to?( Mock.__pre(name) )
+                test = proc { |*args| self }
+            else
+                raise "no block given for mocked method #{name}"
+            end
+        end
+        @mock_calls.push( [name,test] )
+    end
+    
+    # Call this at the end of a test to ensure that all scheduled calls
+    # have been made to the mock
+    #
+    def __verify
+        if @next_call != @mock_calls.length
+            raise RUNIT::AssertionFailedError,
+                  "not all expected method calls were made to #{@name}",
+                  caller
+        end
+    end
+    
+    
+private
+    # Dispatches aribtrary method calls to the next mocked behaviour
+    # 
+    def method_missing( name, *args, &block )
+        __mock_call( name, args, (block_given? ? block : nil) )
+    end
+    
+    # Implements a method call using the next mocked behaviour and asserts
+    # that the expected method is called with the expected number of 
+    # arguments.
+    #
+    def __mock_call( name, args, block )
+        if @next_call >= @mock_calls.length
+            raise RUNIT::AssertionFailedError,
+                  "unexpected call to #{name} method of #{@name}",
+                  caller(2)
+        end
+        
+        expected_name,body = @mock_calls[@next_call]
+        @next_call += 1
+        
+        if name != expected_name
+            raise RUNIT::AssertionFailedError,
+                  "wrong method called on #{@name}; " +
+                      "expected #{expected_name}, was #{name}",
+                  caller(2)
+        end
+        
+        args_length = args.length + (block ? 1 : 0)
+        
+        if body.arity < 0
+            if (body.arity+1).abs > args_length 
+                raise RUNIT::AssertionFailedError,
+                      "too few arguments to #{name} method of #{@name}; " +
+                          "require #{(body.arity+1).abs}, got #{args.length}",
+                      caller(2)
+            end
+        else
+            if body.arity != args_length
+                raise RUNIT::AssertionFailedError,
+                      "wrong number of arguments to " +
+                          "#{name} method of #{@name}; " +
+                          "require #{body.arity}, got #{args.length}",
+                      caller(2)
+            end
+        end
+        
+        if respond_to? Mock.__pre(name)
+            if block
+                precondition_ok = __send__( Mock.__pre(name), *args, &block )
+            else
+                precondition_ok = __send__( Mock.__pre(name), *args )
+            end
+            
+            if not precondition_ok
+                raise RUNIT::AssertionFailedError,
+                    "precondition of #{name} method violated",
+                    caller(2)
+            end
+        end
+        
+        if block
+            instance_eval { body.call( block, *args ) }
+        else
+            instance_eval { body.call( *args ) }
+        end
+    end
+
+    #  The name of a precondition for a method
+    def Mock.__pre( method )
+        "__pre_#{method.to_i}".intern
+    end
+    
+		
+    def Mock.method_added( name )
+			unless(/^__pre_/.match(name.to_s))
+        pre = self.__pre(name)
+        alias_method( pre, name )
+        undef_method(name)
+			end
+    end
+end

data/test/rcov

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec rcov -Ilib -I ../xmlconv/lib/ test/suite.rb ../xmlconv/test/suite.rb

data/test/suite.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# TestSuite -- xmlconv2 -- 01.06.2004 -- hwyss@ywesee.com
+
+$: << File.dirname(File.expand_path(__FILE__))
+
+current_dir = File.dirname(__FILE__) 
+Dir.foreach(current_dir) { |dirname|
+	dirpath = File.expand_path(dirname, current_dir)
+	if(/^test_/o.match(dirname) && (File.ftype(dirpath) == 'directory'))
+		Dir.foreach(dirpath) { |filename|
+			if(/\.rb$/o.match(filename))
+				require "#{dirname}/#{filename}"
+			end
+		}
+	end
+}