levinalex-LiaisonLabor 0.1.7

data/History.txt

@@ -0,0 +1,10 @@
+== 0.1.6 / 2007-09-11
+
+* change name of configuration file to ".liaison_labor"
+* change configuration keys to strings
+* honor HTTP endpoint given in configuration file
+
+== 0.1.5 / 2007-07-19
+
+* delete patient list on initialization
+

data/Manifest.txt

@@ -0,0 +1,13 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/liaison_server
+liaison_labor.gemspec
+lib/liaison_labor.rb
+lib/liaison_labor/interface.rb
+lib/liaison_labor/packets.rb
+lib/liaison_server.rb
+spec/liaison_interface_spec.rb
+spec/liaison_packet_spec.rb
+spec/mock/mock_liaison.rb

data/README.txt

@@ -0,0 +1,49 @@
+LiaisonLabor
+    by Levin Alexander
+    http://levinalex.net/src/liaison_labor
+
+== DESCRIPTION:
+  
+An interface to the LIAISON® analyser by DiaSorin 
+<http://www.diasorin.com/en/productsandsystems/liaison>
+
+== FEATURES/PROBLEMS:
+  
+* not yet written
+
+== SYNOPSIS:
+
+  not yet written
+
+== REQUIREMENTS:
+
+* not yet written
+
+== INSTALL:
+
+* not yet written
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007-2008 Levin Alexander
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'hoe'
+require 'spec/rake/spectask'
+
+require './lib/liaison_labor.rb'
+
+Hoe.new('LiaisonLabor', LiaisonLabor::VERSION) do |p|
+  p.rubyforge_name = 'liaison_labor'
+  p.summary = 'interfaces Liaison device to worklist_manager'
+
+  p.url = 'http://levinalex.net/src/liaison'
+  p.developer('Levin Alexander', 'mail@levinalex.net')
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+
+  # p.extra_deps ['levinalex-serial_interface']
+end
+
+Rake.application.instance_eval { @tasks["test"] = nil }
+
+Spec::Rake::SpecTask.new do |t|
+  t.warning = true
+  t.spec_opts = %w(-c -f specdoc)
+end
+task :test => :spec
+
+task :cultivate do
+  system "touch Manifest.txt; rake check_manifest | grep -v \"(in \" | patch"
+  system "rake debug_gem | grep -v \"(in \" > `basename \\`pwd\\``.gemspec"
+end

data/bin/liaison_server

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+# start a process that continuously listens on a port and
+# processes packets
+#
+# see "./liaison_server -h" for help
+#
+require File.join(File.dirname(__FILE__),'..','lib','liaison_server.rb')
+Diasorin::LiaisonServer.new.run!

data/liaison_labor.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{LiaisonLabor}
+  s.version = "0.1.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Levin Alexander"]
+  s.date = %q{2009-06-11}
+  s.default_executable = %q{liaison_server}
+  s.description = %q{An interface to the LIAISON® analyser by DiaSorin  <http://www.diasorin.com/en/productsandsystems/liaison>}
+  s.email = ["mail@levinalex.net"]
+  s.executables = ["liaison_server"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "bin/liaison_server", "liaison_labor.gemspec", "lib/liaison_labor.rb", "lib/liaison_labor/interface.rb", "lib/liaison_labor/packets.rb", "lib/liaison_server.rb", "spec/liaison_interface_spec.rb", "spec/liaison_packet_spec.rb", "spec/mock/mock_liaison.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://levinalex.net/src/liaison}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{liaison_labor}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{interfaces Liaison device to worklist_manager}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<hoe>, [">= 1.12.1"])
+    else
+      s.add_dependency(%q<hoe>, [">= 1.12.1"])
+    end
+  else
+    s.add_dependency(%q<hoe>, [">= 1.12.1"])
+  end
+end

data/lib/liaison_labor.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+
+require File.join(File.dirname(__FILE__),'liaison_labor','interface.rb')
+require File.join(File.dirname(__FILE__),'liaison_labor','packets.rb')
+
+class LiaisonLabor
+  VERSION = '0.1.7'
+end

data/lib/liaison_labor/interface.rb

@@ -0,0 +1,236 @@
+require 'rubygems'
+require 'serial_interface'
+
+module Diasorin
+  module Liaison
+
+    class Interface < PacketIO
+
+      def initialize(read, write=read, options = {}, &blk)
+        super(LiaisonProtocol, read, write, options)
+
+        # define default handlers for import/export of patients
+        # and results
+        #
+        @on_order_request = lambda { nil }
+
+        # is called whenever a result is sent
+        #
+        @on_result = lambda { |patient, order, result| }
+
+        yield self if block_given?
+
+        add_sender( {
+          :message_header => Packets::MessageHeaderRecord,
+          :patient => Packets::PatientInformationRecord,
+          :order => Packets::TestOrderRecord,
+          :terminator => Packets::MessageTerminatorRecord
+        } )
+
+        add_receiver :message_header => Packets::MessageHeaderRecord do |p|
+          # delete the list of patients
+          @patient_information ||= {}
+        end
+
+        add_receiver :patient_record => Packets::PatientInformationRecord do |p|
+          @last_order_packet = nil
+          @last_result_record = nil
+
+          @last_patient_packet = p
+        end
+
+        add_receiver :comment => Packets::CommentRecord do |p|
+          @on_result.call(@last_patient_packet, @last_order_packet, @last_result_record, p)
+        end
+
+        add_receiver :order => Packets::TestOrderRecord do |p|
+          @last_result_record = nil
+
+          @last_order_packet = p
+        end
+
+        add_receiver :test_result => Packets::ResultRecord do |p|
+          @last_result_record = p
+          @on_result.call(@last_patient_packet, @last_order_packet, @last_result_record)
+        end
+
+
+        add_receiver :request_information => Packets::RequestInformationSegment do |p|
+          puts "RequestInformation: #{p.inspect}"
+
+          @patient_information ||= {}
+          requests = @on_order_request.call(p.starting_range)
+          @patient_information[p.sequence_number] = requests if requests
+
+          @mode = :request_information
+        end
+
+        add_receiver :ack => Packets::Acknowledge do |p|
+          if @mode == :request_information
+            @mode = @transmitting
+            send_packet(:message_header, "HOST", "Liaison")
+            transmit_requests
+          else
+            # keep on sending
+          end
+        end
+
+        add_receiver :nack => Packets::NotAcknowledge do |p|
+          puts "Nack!"
+          raise "NACK received"
+        end
+
+        add_receiver :message_terminator => Packets::MessageTerminatorRecord do |p|
+          puts "got MessageTerminatorRecord"
+          if @mode == :request_information
+            puts "should now send information"
+            # initiate transfer (ENQ)
+            send_packet("\x05", :raw => true)
+          end
+        end
+
+        run
+      end
+
+      def on_order_request(&blk)
+        @on_order_request = blk
+      end
+      def on_result(&blk)
+        @on_result = blk
+      end
+
+      def transmit_requests
+        @patient_information.each do |sequence_nr, data|
+          p "sequence: #{sequence_nr.inspect}"
+          p "data: #{data.inspect}"
+          send_packet(:patient, sequence_nr, data["patient"]["number"], data["patient"]["last_name"], data["patient"]["first_name"])
+          data["types"].each do |request|
+            send_packet(:order, sequence_nr, data["id"], request)
+          end
+        end
+        send_packet(:terminator, "1")
+        # EOT
+        send_packet("\x04", :raw => true)
+
+        @mode = :neutral
+      end
+
+    end
+
+
+    class LiaisonProtocol
+      STX = 0x02 # STX
+      ETX = 0x03  # ETX
+      NACK = 0x15 # NACK
+      ACK = 0x06 # ACK
+      ENQ = 0x05 # ENQ
+      CR = 0x0d
+      LF = 0x0a
+      EOT = 0x04
+
+      def initialize(send_callback, receive_callback, options = {})
+        @send_callback, @receive_callback = send_callback, receive_callback
+        @packet_buffer = ""
+        @send_buffer = []
+        @checksum = 0
+        @frame_number = 1
+        @state = :neutral
+      end
+
+      def self.checksum_valid?(string, expected)
+        sum = string.to_enum(:each_byte).inject(ETX) { |s,v| s+v } % 0x100
+        if sum == expected
+          return true
+        else
+          raise ::SerialProtocol::ChecksumMismatch, "expected #{expected}, got #{sum}"
+        end
+      end
+
+      def get_packet(str)
+        @receive_callback.call(str)
+      end
+
+      def add_char_to_packet(char)
+
+        case @state
+        when :neutral
+          if char == ENQ # establishment
+            send_packet(ACK.chr, :raw => true)
+            @state = :transfer_begin
+          elsif char == ACK
+            get_packet(ACK.chr)
+          elsif char == NACK
+            get_packet(NACK.chr)
+          else
+            # receive and ignore partial data
+          end
+        when :transfer_begin
+          if char == STX
+            # begin to receive a packet
+            @packet_buffer = ""
+            @state = :packet_data
+          elsif char == EOT
+            @state = :neutral
+          else
+            raise "unexpected data after ENQ, expected STX, got #{char.to_i}"
+          end
+        when :packet_data
+          if char == ETX
+            @state = :packet_checksum_1
+          else
+            @packet_buffer << char
+          end
+        when :packet_checksum_1
+          @checksum_str = "" << char
+          @state = :packet_checksum_2
+        when :packet_checksum_2
+          @checksum_str << char
+          @state = :packet_cr
+        when :packet_cr
+          if char == CR
+            @state = :packet_lf
+          else
+            raise "unexpected data after checksum, expected CR, got #{char.to_i}"
+          end
+        when :packet_lf
+          if char == LF
+            if self.class.checksum_valid?(@packet_buffer, @checksum_str.to_i(16))
+              send_packet(ACK.chr, :raw => true)
+              # cut the sequence ID
+              get_packet(@packet_buffer[1..-1])
+            else
+              send_packet(NACK.chr, :raw => true)
+            end
+            @state = :transfer_begin
+          else
+            raise "unexpected data after checksum, expected LF, got #{char.to_i}"
+          end
+        end
+      end
+
+      def checksum(data)
+        val = data.to_enum(:each_byte).inject(0) { |sum,b| sum+b } % 0x100
+        val.to_s(16).rjust(2,'0')
+      end
+
+      def send_packet(data, options = {})
+        warn "--> #{data.inspect}"
+        if options[:raw]
+          if data == ENQ.chr
+            @frame_number = 1 # reset frame number on new transmission
+          end
+          @send_callback.call(data)
+        else
+          @frame_number ||= 1
+
+          data = "" << @frame_number.to_s << data
+          packet_str = "" << "\x02" << data << "\r" << "\x03" << checksum("" << data << "\r\x03") << "\r\n"
+          p "--~> #{packet_str.inspect}"
+          @send_callback.call(packet_str)
+
+          @frame_number = (@frame_number + 1) % 8
+        end
+      end
+    end
+  end
+end

data/lib/liaison_labor/packets.rb

@@ -0,0 +1,302 @@
+require 'date'
+require 'serial_interface'
+
+module Diasorin
+  module Liaison
+    module Packets
+      class LiaisonPacket < SerialPacket
+        FieldDelimiter = '|'
+        RepeatDelimiter = '\\'
+        ComponentDelimiter = '^'
+        EscapeDelimiter = "&"
+        
+        header_format "A"
+        
+        def sequence_number=(val)
+          @sequence_number = val.to_i    
+        end
+
+        def to_str
+          to_s
+        end
+      end
+
+      class Acknowledge < LiaisonPacket
+        def self.matches?(str)
+          str == "\x06" ? true : false
+        end
+        def to_s; "\x06"; end
+      end
+
+      class NotAcknowledge < LiaisonPacket
+        def self.matches?(str)
+          str == "\x15" ? true : false
+        end
+        def to_s; "\x15"; end
+      end
+      
+      class MessageHeaderRecord < LiaisonPacket
+        header_format "A"
+        header_filter "H"
+        header ["H"]
+        
+        attr_reader :sender_id
+        attr_reader :receiver_id
+        attr_reader :timestamp
+        
+        def initialize(sender_id, receiver_id)
+          @sender_id = sender_id
+          @receiver_id = receiver_id
+        end
+        
+        def to_s
+          arr = []
+          arr[1] = "H"
+          arr[2] = "\\^&"
+          arr[5] = @sender_id
+          arr[10] = @receiver_id
+          arr.shift
+          
+          arr.join("|")
+        end
+        
+        def initialize_from_packet(str)
+          records = str.split(FieldDelimiter)
+          
+          @sender_id = records[4]
+          @receiver_id = records[9]
+          @timestamp = DateTime.new(*records[13].scan(/(....)(..)(..)(..)(..)(..)/)[0].map {|x| x.to_i })
+          
+          @version = records[12]
+          raise "Version is not supported" unless @version == '1'
+          
+        end
+      end
+      
+      class MessageTerminatorRecord < LiaisonPacket
+        header_format "A"
+        header_filter "L"
+        header ["L"]
+        
+        attr_reader :sequence_number
+        attr_reader :termination_code
+        
+        def initialize_from_packet(str)
+          records = str.split(FieldDelimiter)
+          _, self.sequence_number, @termination_code = records
+        end
+
+        def initialize(sequence_number, termination_code = "N")
+          @sequence_number = sequence_number
+          @termination_code = termination_code
+        end
+
+        def to_s
+          arr = []
+          arr[1] = "L"
+          arr[2] = @sequence_number
+          arr[3] = @termination_code
+          arr.shift
+          
+          arr.join("|")
+        end
+      end
+      
+      class PatientInformationRecord < LiaisonPacket
+        header_format "A"
+        header_filter "P"
+        header ["P"]
+        
+        attr_reader :sequence_number
+        attr_reader :patient_id
+        attr_reader :patient_last_name
+        attr_reader :patient_first_name
+        attr_reader :birthdate
+        attr_reader :sex
+        attr_reader :physician
+        
+        def patient_name=(val)
+          @patient_last_name, @patient_first_name = val.split(ComponentDelimiter)
+        end
+        def birthdate=(val)
+          @birthdate = case val
+                       when String
+                         DateTime.new(*val.scan(/(....)(..)(..)/)[0].map {|x| x.to_i }) rescue nil
+                       end  
+        end
+        
+        def initialize(sequence_nr, patient_id, lastname = "", firstname = "")
+          @sequence_number = sequence_nr.to_i
+          @patient_id = patient_id
+          @patient_last_name, @patient_first_name = lastname, firstname
+        end
+        
+        def to_s
+          arr = []
+          arr[1] = "P"
+          arr[2] = @sequence_number
+          arr[4] = @patient_id.to_s
+          arr[6] = [@patient_last_name, @patient_first_name].join("^")
+          arr.shift
+          
+          arr.join("|")
+        end
+        
+        def initialize_from_packet(str)
+          records = str.split(FieldDelimiter)
+         
+          _1, 
+          self.sequence_number, 
+          _3, 
+          @patient_id, 
+          _5, 
+          self.patient_name,
+          _7, 
+          self.birthdate, 
+          @sex,
+          _10, 
+          _11, 
+          _12, 
+          _13,
+          @physician, 
+          _rest = records
+        end
+      end
+      
+      class RequestInformationSegment < LiaisonPacket
+        header_format "A"
+        header_filter "Q"
+        header ["Q"]
+        
+        attr_reader :sequence_number
+        attr_reader :starting_range
+        
+        def initialize_from_packet(str)
+          records = str.split(FieldDelimiter)
+           
+          _1, self.sequence_number, @starting_range, _rest = records
+        end
+      end
+      
+      class TestOrderRecord < LiaisonPacket
+        header_format "A"
+        header_filter "O"
+        header ["O"]
+        
+        attr_reader :sequence_number
+        attr_reader :specimen_id
+        attr_reader :test_id
+        attr_reader :dilution
+        attr_reader :priority
+        attr_reader :timestamp
+        attr_reader :record_type
+        
+        def sequence_number=(val)
+          @sequence_number = val.to_i    
+        end
+        def test_order=(data)
+          _1, _2, _3, @test_id, @dilution = data.split(ComponentDelimiter)
+        end  
+        def timestamp=(val)
+            @timestamp = case val
+                         when String
+                           DateTime.new(*val.scan(/(....)(..)(..)/)[0].map {|x| x.to_i  }) rescue nil
+                         end  
+        end
+        def initialize_from_packet(str)
+          records = str.split(FieldDelimiter)
+          
+          _1,
+          self.sequence_number, 
+          @specimen_id,
+          _4,
+          self.test_order,
+          @priority,
+          self.timestamp, _, _, _10, _, _, _, _, _, _, _, _, _, _20, _, _, _, _, _, @record_type,
+          _rest = records
+        end
+
+        def initialize(sequence_number, specimen_id, test_id)
+          @sequence_number = sequence_number
+          @specimen_id = specimen_id
+          @test_id = test_id
+        end
+
+
+        def to_s
+          arr = []
+          arr[1] = "O"
+          arr[2] = @sequence_number
+          arr[3] = @specimen_id
+          arr[5] = [nil,nil,nil,@test_id].join("^")
+          arr.shift
+
+          arr.join("|")
+        end
+      end
+     
+      class ResultRecord < LiaisonPacket
+        header_format "A"
+        header_filter "R"
+        header ["R"]
+        
+        attr_reader :sequence_number
+        attr_reader :test_id
+        attr_reader :value
+        attr_reader :unit
+        attr_reader :abnormal_flags
+        attr_reader :result_status
+        attr_reader :timestamp
+        attr_reader :instrument
+        
+        def test_result=(data)
+          _1, _2, _3, @test_id = data.split(ComponentDelimiter)
+        end
+        def timestamp=(val)
+            @timestamp = case val
+                         when String
+                           DateTime.new(*val.scan(/(....)(..)(..)(..)(..)(..)/)[0].map {|x| x.to_i }) rescue nil
+                         end  
+        end
+        
+        def initialize_from_packet(str)
+          records = str.split(FieldDelimiter)
+          
+          _1,
+          self.sequence_number,
+          self.test_result,
+          @value,
+          @unit,
+          _6,
+          @abnormal_flags,
+          _7,
+          @result_status,
+          _10, _11, _12, 
+          self.timestamp,
+          @instrument,
+          rest  = records
+        end
+      end
+      
+      class CommentRecord < LiaisonPacket
+        header_format "A"
+        header_filter "C"
+        header ["C"]
+
+        attr_reader :comment
+
+        def initialize_from_packet(str)
+          records = str.split(FieldDelimiter)
+
+          _1,
+          self.sequence_number,
+          _3,
+          @comment,
+          rest = records
+        end
+      end
+        
+
+    end
+  end
+end

data/lib/liaison_server.rb

@@ -0,0 +1,169 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'net/http'
+require 'yaml'
+
+require 'rubygems'
+
+require File.join(File.dirname(__FILE__),'liaison_labor.rb')
+
+class Hash
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+    end
+  end
+
+  def stringify_keys
+    inject({}) do |options, (key, value)|
+      options[key.to_s] = value
+      options
+    end
+  end
+
+end
+
+
+module Diasorin
+  ConfigFilename = ".liaison_server"
+  ConfigFile = File.join(ENV['HOME'] || ENV['APPDATA'], ConfigFilename)
+
+  # defaults are used when they are not overwritten in a config file
+  # or with command line options
+  #
+  DefaultConfig = {
+    :serial_port => "/dev/ttyUSB0",
+    :baudrate => 9600,
+    :uri => "http://localhost/liaison/"
+  }
+
+  class LiaisonServer
+
+    # load configuration from configfile, merge with
+    # default options
+    #
+    def load_configuration
+     # try to read configuration from file
+      @options_from_file = YAML.load_file(ConfigFile) || {} rescue {}
+      @options_from_file = @options_from_file.symbolize_keys
+
+      # if an option is not given on the command line
+      # it is taken from the config file, or the default is used
+      @options = Hash.new() { |h,k| @options_from_file[k] || DefaultConfig[k] }
+    end
+
+    # parse command line options
+    #
+    def initialize
+      load_configuration
+
+      @opts = OptionParser.new do |opts|
+
+        opts.separator ""
+        opts.separator "liaison_labor is an interface between the Liaison device connected via "
+        opts.separator "serial port, and a worklist_manager HTTP-server"
+        opts.separator ""
+        opts.separator "configuration can be given in '#{ConfigFile}' "
+        opts.separator ""
+
+        opts.on "-V","--version","Display version and exit" do
+          puts "#{self.class} #{::LiaisonLabor::VERSION}"
+          exit
+        end
+        opts.on "-s", "--serial-port DEVICE", "serial port, default is /dev/ttyUSB0"  do |arg|
+          @options[:serial_port] = arg
+        end
+        opts.on "--baudrate BAUDRATE", "baudrate of the serial connection, default is 9600" do |arg|
+          @options[:baudrate] = arg.to_i
+        end
+        opts.on "-u", "--uri URI", "URI of the HTTP-Endpoint where data is read or posted" do |arg|
+          @options[:endpoint] = arg
+        end
+        opts.on_tail "-p", "--print-config", "Print the current configuration",
+                                             "in a format that can be used as a configuration file" do
+          puts @options_from_file.merge(@options).stringify_keys.to_yaml
+          exit
+        end
+      end
+    end
+
+
+    # open the serial port for reading and writing
+    #
+    # make sure that output buffering is disabled so that data
+    # is sent immediately
+    #
+    def open_port(portfile, speed)
+      system("stty -echo raw ospeed #{speed} ispeed #{speed} < #{portfile}")
+      port = File.open(portfile, "w+")
+      port.sync = true
+      port
+    end
+
+    def communicate!
+      port = open_port(@options[:serial_port], @options[:baudrate])
+
+      client = Liaison::Interface.new(port) do |liaison|
+
+        # yields the barcode of a sample
+        #
+        # expects a hash consisting of patient information and a list
+        # of requests for this patient
+        #
+        liaison.on_order_request do |barcode|
+          begin
+            data = YAML.load(::Net::HTTP.get( URI.join(@options[:endpoint],"find_requests/",barcode) ))
+          rescue Exception => e
+            puts e
+            puts e.backtrace
+            data = nil
+          end
+          p data
+          data
+        end
+
+        liaison.on_result do |patient, order, result, comment|
+          if comment
+            comment_str = comment.comment
+          else
+            comment_str = nil
+          end
+
+          barcode = order.specimen_id
+          data = {
+            "test_name" => order.test_id,
+            "value" => result.value,
+            "unit" => result.unit,
+            "status" => result.result_status,
+            "flags" => result.abnormal_flags,
+            "comment" => comment_str,
+            "result_timestamp" => result.timestamp
+          }
+
+          ::Net::HTTP.post_form(URI.join(@options[:endpoint], "result/", "#{URI.encode(barcode)}"), data.to_hash )
+        end
+      end
+
+      client.run
+
+      puts "Listening on #{File.expand_path(port.path)}"
+
+      begin
+        yield client if block_given?
+        client.join
+      rescue Interrupt => e
+        puts "exiting"
+        raise
+      end
+    end
+
+    # run the application
+    #
+    def run!(args = ARGV)
+      @opts.parse!(args)
+
+      communicate!
+    end
+  end
+end

data/spec/liaison_interface_spec.rb

@@ -0,0 +1,43 @@
+require 'lib/liaison_labor/interface.rb'
+
+require 'stringio'
+
+include Diasorin::Liaison
+
+context "" do
+  setup do
+    @to_host = StringIO.new
+    @from_host = StringIO.new
+    
+    @host = PacketIO.new(LiaisonProtocol, @to_host, @from_host)
+    @host.run
+  end
+  
+  def transmit_string(str)
+    @to_host << str
+    @to_host.rewind
+    30.times { Thread.pass }
+    @from_host.rewind
+  end
+  
+  specify "ENQ should be acknowledged" do
+    transmit_string "\x05"
+    response = @from_host.read
+    response.should == "\x06"
+  end
+  
+  specify "Valid packet should be acknowledged" do
+    s = "\x05\x026L|1|N\x0d\x0309\x0d\x0a"
+    transmit_string s
+    response = @from_host.read
+    response.should == "\x06\x06"
+  end
+
+  specify "another valid packet" do
+    s = "\005\0023R|1|^^^TSH|0.182|mIU/l||L||F||||20070510161808|Liaison\r\003E2\r\n"
+    lambda { 
+      transmit_string s 
+      response = @from_host.read
+    }.should_not raise_error
+  end
+end

data/spec/liaison_packet_spec.rb

@@ -0,0 +1,234 @@
+require 'lib/liaison_labor/packets.rb'
+
+include Diasorin
+
+
+def has_header(packet, char)
+  specify "should be matched by packets stating with #{char}" do
+    instance_variable_get("@#{packet}").matches?("#{char}...").should be_true
+  end
+
+  specify "different headers should not match" do
+    instance_variable_get("@#{packet}").matches?("random garbage").should be_false
+  end  
+end
+
+def has_example(packet, example_str)
+  specify "example should parse without errors" do
+    lambda {
+      instance_variable_get("@#{packet}").from_str(example_str) 
+      }.should_not raise_error
+  end
+end
+
+context "checksum for packets" do
+  setup do
+    @full_packet = "\0021O|1|00000023||^^^FT4^|||||||||||||||||||||F\r\003EE\r\n"
+  end
+
+  specify "data should have a correct checksum" do
+    LiaisonProtocol.checksum_valid?("1O|1|00000023||^^^FT4^|||||||||||||||||||||F\r","EE".to_i(16)).should be_true
+  end
+
+end
+
+
+context "The MessageHeaderRecord packet from/to Liaison" do
+  setup do
+    @packet = Liaison::Packets::MessageHeaderRecord
+    @str = "H|\^&|||LaborEDV|||||Liaison|||1|19971113154903"
+  end
+  
+  has_header :packet, "H"
+  
+  specify "should have a sender_id" do
+    @packet.from_str(@str).sender_id.should == "LaborEDV"
+  end
+  
+  specify "should have a receiver_id" do
+    @packet.from_str(@str).receiver_id.should == "Liaison"
+  end
+  
+  specify "should have a timestamp" do
+    @packet.from_str(@str).timestamp.should == DateTime.new(1997,11,13,15,49,03)
+  end
+end
+
+context "Building a MessageHeaderRecord" do
+  setup do
+    @header = Liaison::Packets::MessageHeaderRecord
+    @packet = @header.new("Sender","Receiver")
+  end
+  
+  specify "should build a correct packet" do
+    @packet.to_s.should == "H|\\^&|||Sender|||||Receiver"
+  end
+end
+
+context "the MessageTerminatorRecord packet to Liaison" do
+  setup do
+    @terminator_record = Liaison::Packets::MessageTerminatorRecord
+    @str = "L|1|N"
+    @packet = @terminator_record.from_str(@str)
+  end
+
+  has_header :terminator_record, "L"
+  
+  specify "should have sequence number" do
+    @packet.sequence_number.should == 1
+  end
+  specify "should have termination code" do
+    @packet.termination_code.should == "N"
+  end
+end
+
+context "the PatientInformationRecord from/to Liaison" do
+  setup do
+    @packet = Liaison::Packets::PatientInformationRecord
+    @example = "P|1||PatID01||Meyer^Anna||19741001|F|||||MARTINEZ"
+  end
+  
+  has_header :packet, "P"
+  
+  specify "should have a sequence number" do
+    @packet.from_str(@example).sequence_number.should == 1
+  end
+  
+  specify "should have a patient ID" do
+    @packet.from_str(@example).patient_id.should == "PatID01"
+  end
+  specify "should have a patient name" do
+    @packet.from_str(@example).patient_last_name.should == "Meyer"
+    @packet.from_str(@example).patient_first_name.should == "Anna"
+  end
+  specify "should have a birthday" do
+    @packet.from_str(@example).birthdate.should == Date.new(1974,10,01)
+  end
+  specify "should have sex" do
+    @packet.from_str(@example).sex.should == "F"
+  end
+  specify "should have attending physician" do
+    @packet.from_str(@example).physician.should == "MARTINEZ"
+  end
+end
+
+context "building a PatientInformationRecord" do
+  setup do
+    @record = Liaison::Packets::PatientInformationRecord
+    @packet = @record.new(1, "000204060", "Sierra", "Rudolph")
+  end
+  
+  specify "should just work" do
+    @packet.to_s.should == "P|1||000204060||Sierra^Rudolph"
+  end
+end
+
+context "the RequestInformationSegment" do
+  setup do
+    @request_information = Liaison::Packets::RequestInformationSegment
+    @str = "Q|1|Sample01||ALL||||||||O"
+    @packet = @request_information.from_str(@str)
+  end
+  
+  has_header :request_information, "Q"
+  
+  specify "should have a sequence number" do
+    @packet.sequence_number.should == 1
+  end
+  
+  specify "should have starting range id" do
+    @packet.starting_range.should == "Sample01"
+  end
+end
+
+context "the TestOrderRecord from/to Liaison" do
+  setup do
+    @order_record = Liaison::Packets::TestOrderRecord
+    @example = "O|1|SampleID01||^^^AFP^1:10|N|19980506|||||||||S||||||||||X"
+    @packet = @order_record.from_str(@example)
+  end
+  
+  has_header :order_record, "O"
+  
+  specify "should have a sequence number" do
+    @packet.sequence_number.should == 1
+  end
+  specify "should have a specimen id" do
+    @packet.specimen_id.should == "SampleID01"
+  end
+  specify "should have a universal test id" do
+    @packet.test_id.should == "AFP"
+  end
+  specify "should have a dilution" do
+    @packet.dilution.should == "1:10"
+  end
+  specify "should have a priority" do
+    @packet.priority.should == "N"
+  end
+  specify "should have timestamp" do
+    @packet.timestamp.should == DateTime.new(1998,5,6,0,0,0)
+  end
+  specify "should have report type" do
+    @packet.record_type.should == "X"
+  end
+end
+
+context "building a TestOrderRecord" do
+  setup do
+    @order_record = Liaison::Packets::TestOrderRecord
+  end
+
+  specify "should generate a correct packet" do
+    @packet = @order_record.new(17, "BarcodeID", "TSH")
+    @packet.to_s.should == "O|17|BarcodeID||^^^TSH"
+  end
+end
+
+context "the ResultRecord" do
+  setup do
+    @result_record = Liaison::Packets::ResultRecord
+    @example = "R|1|^^^AFP|0.20|IU/ml||<||F||||19980506123145|Liaison"
+    @packet = @result_record.from_str(@example)
+  end
+  
+  has_header :result_record, "R"
+  
+  specify "should have sequence number" do
+    @packet.sequence_number.should == 1
+  end
+  specify "should have test id" do
+    @packet.test_id.should == "AFP"
+  end
+  specify "should have value" do
+    @packet.value.should == "0.20"
+  end
+  specify "should have unit" do
+    @packet.unit.should == "IU/ml"
+  end
+  specify "should have abnormal flags" do
+    @packet.abnormal_flags.should == "<"
+  end
+  specify "should have result status" do
+    @packet.result_status.should == "F"
+  end
+  specify "should have timestamp" do
+    @packet.timestamp.should == DateTime.new(1998,05,06,12,31,45)
+  end
+  specify "should have instrument" do
+    @packet.instrument.should == "Liaison"
+  end
+  
+end
+
+# TODO: empty result data should be allowed
+
+context "the CommentRecord" do
+  setup do
+    @packet = Liaison::Packets::CommentRecord
+  end
+  has_header :packet, "C"
+end
+
+
+
+

data/spec/mock/mock_liaison.rb

@@ -0,0 +1,43 @@
+
+module Diasorin
+  module Liaison
+    class MockInterface < PacketIO
+      def initialize(read, write, options = {})
+        super(SerialProtocol, read, write, options)
+
+        add_sender( {
+          :init => Packets::MessageHeaderRecord,
+          :next_patient => Packets::NextPatient,
+          :result => Packets::Result,
+          :end => Packets::EndOfData
+        } )
+
+        add_receiver :end => Packets::EndOfData do |d|
+          self.end_of_list
+        end
+
+        add_receiver :next_result => Packets::NextResult do |d|
+        end
+
+        run
+      end
+      
+      def init
+        send_packet :init
+      end
+
+      def result(pat_with_results)
+        
+      end
+
+      def next_patient nr
+        send_packet :next_patient, nr
+      end
+
+      def end_of_list
+        send_packet :end
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: levinalex-LiaisonLabor
+version: !ruby/object:Gem::Version 
+  version: 0.1.7
+platform: ruby
+authors: 
+- Levin Alexander
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-11 00:00:00 -07:00
+default_executable: liaison_server
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.12.1
+    version: 
+description: "An interface to the LIAISON\xC2\xAE analyser by DiaSorin  <http://www.diasorin.com/en/productsandsystems/liaison>"
+email: 
+- mail@levinalex.net
+executables: 
+- liaison_server
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/liaison_server
+- liaison_labor.gemspec
+- lib/liaison_labor.rb
+- lib/liaison_labor/interface.rb
+- lib/liaison_labor/packets.rb
+- lib/liaison_server.rb
+- spec/liaison_interface_spec.rb
+- spec/liaison_packet_spec.rb
+- spec/mock/mock_liaison.rb
+has_rdoc: true
+homepage: http://levinalex.net/src/liaison
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: liaison_labor
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: interfaces Liaison device to worklist_manager
+test_files: []
+