lis 0.0.0 → 0.1.0

data/.yardopts

@@ -0,0 +1 @@
+--protected

data/README.markdown

@@ -0,0 +1,9 @@
+# LIS
+
+A simple interface to medical laboratory instruments. It implments a rough subset of ASTM E1394-97 (or, possibly CLSI LIS02-A2)
+
+It listens for test requests and results and forwards them via HTTP.  It is intended to interface with the [worklist_manager](http://github.com/levinalex/worklist_manager) web application.
+
+## Copyright
+
+Copyright (c) 2010 Levin Alexander. See LICENSE for details.

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.1.0

data/bin/lis2http

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby1.9
+
+require 'lib/lis.rb'
+require 'lis/commands/application.rb'
+
+LIS::Application.new(ARGV).run!

data/features/lis.feature

@@ -1,9 +1,50 @@
-Feature: something something
-  In order to something something
-  A user something something
-  something something something
+Feature:
+  In order to value
+  As a role
+  I want feature
 
-  Scenario: something something
-    Given inspiration
-    When I create a sweet new gem
-    Then everyone should see how awesome I am
+  Scenario: sending results from Immulite to LIS
+    Given LIS Interface listening for messages
+    When receiving
+    """
+      H|\^||PASSWORD|DPC||||SYSTEM||P|1|19940407085426
+      P|1|119813;TGH|||Last 1^First 1|||F|||||
+      O|1|130000445||^^^TT4|||19950118085700
+      R|1|^^^TT4|10.3|ug/dL|4.5\.4^12.5\24|N|N|F||test|19950119084508|19950119092826|SenderID
+      O|2|130000445||^^^TU|||19950118085700
+      R|1|^^^TU|26.6|Percnt|23\10^35\70|N|N|F||test|19950119084508|19950119092756|SenderID
+      P|2|325031;AH|||Last 2^First 2|||F|||||
+      O|1|130000617||^^^FER|||19950118103000
+      R|1|^^^FER|173.|ng/mL|.5\.5^1500\1500|N|N|F||test|19950119084641|19950119092858|SenderID
+      P|3|326829;AH|||Last 3^First 3|||F|||||
+      O|1|130000722||^^^FER|||19950118102000
+      R|1|^^^FER|490.|ng/mL|.5\.5^1500\1500|N|N|F||test|19950119084741|19950119092928|SenderID
+      P|4|124462;TGH|||Last 4^First 4|||F|||||
+      O|1|130000724||^^^E2|||19950118122000
+      R|1|^^^E2|25.3|pg/mL|12\12^2000\2000|N|N|F||test|19950119084815|19950119100049|SenderID
+      O|2|130000724||^^^FSH|||19950118122000
+      R|1|^^^FSH|60.6|mIU/mL|.1\.1^170\170|N|N|F||test|19950119084815|19950119093030|SenderID
+      O|3|130000724||^^^LH|||19950118122000
+      R|1|^^^LH|24.4|mIU/mL|.7\.7^400\400|N|N|F||test|19950119084815|19950119093101|SenderID
+      P|5|556395;AH|||Last 5^First 5|||M|||||
+      O|1|130000741||^^^FER|||19950118115500
+      R|1|^^^FER|238.|ng/mL|.5\.5^1500\1500|N|N|F||test|19950119084949|19950119093132|SenderID
+      P|6|556357;MB|||Last 6^First 6|||M|||||
+      O|1|130000790||^^^IGE|||19950118120000
+      R|1|^^^IGE|517.|IU/mL|.01\.01^600\600|N|N|F||test|19950119085018|19950119093202|SenderID
+      P|7|141053;TGH|||Last 7^First 7|||F|||||
+      O|1|130000805||^^^FER|||19950118120000
+      R|1|^^^FER|21.0|ng/mL|.5\.5^1500\1500|N|N|F||test|19950119085049|19950119093233|SenderID
+      P|8|320439;TGH|||Last 8^First 8|||F|||||
+      O|1|130000890||^^^FER|||19950118130000
+      R|1|^^^FER|12.9|ng/mL|.5\.5^1500\1500|N|N|F||test|19950119085254|19950119093609|SenderID
+      P|9||||Last 9^First 9||||||||
+      O|1|130000911||^^^E2
+      R|1|^^^E2|71.3|pg/mL|12\12^2000\2000|N|N|F||test|19950119085423|19950119100800|SenderID
+      P|10|358069;TGH|||Last 10^First 10|||F|||||
+      O|1|130000929||^^^FER|||19950118123000
+      R|1|^^^FER|219.|ng/mL|.5\.5^1500\1500|N|N|F||test|19950119085628|19950119093843|SenderID
+      L|1
+    """
+    Then should have posted results:
+      | device_name | barcode |

data/lib/lis/application_protocol.rb

@@ -1,6 +1,7 @@
 
 module LIS::Transfer
   class ApplicationProtocol < Base
+    attr_reader :device_name
 
     def on_result(&block)
       @on_result_callback = block
@@ -10,13 +11,13 @@ module LIS::Transfer
       @on_request_callback = block
     end
 
-
     def received_header(message)
-      @patient_information ||= {} # delete the list of patients
+      @patient_information_requests ||= {} # delete the list of patients
+      @device_name = message.sender_name
     end
 
     def result_for(patient, order, result)
-      @on_result_callback.call(patient, order, result)
+      @on_result_callback.call(@device_name, patient, order, result)
     end
 
     def received_patient_information(message)
@@ -33,14 +34,30 @@ module LIS::Transfer
     end
 
     def received_request_for_information(message)
-      @patient_information ||= {}
-      requests = @on_request_callback.call(p.starting_range)
-      @patient_information[p.sequence_number] = requests if requests
+      @patient_information_requests ||= {}
+      requests = @on_request_callback.call(@device_name, message.starting_range_id)
+      @patient_information_requests[message.sequence_number] = requests if requests
+    end
+
+    def send_pending_requests
+      sending_session(@patient_information_requests) do |patient_information|
+        patient_information.each do |sequence_nr, data|
+          write :message, LIS::Message::Patient.new(sequence_nr,
+                                                    data["patient"]["number"],
+                                                    data["patient"]["last_name"],
+                                                    data["patient"]["first_name"]).to_message
+          data["types"].each do |request|
+            write :message, LIS::Message::Order.new(sequence_nr, data["id"], request).to_message
+          end
+        end
+      end
+      @patient_information_requests = {}
     end
 
     def initialize(*args)
       super
 
+      @patient_information_requests = {}
       @last_patient = nil
       @last_order = nil
       @handlers = {
@@ -53,17 +70,35 @@ module LIS::Transfer
     end
 
     def receive(type, message = nil)
+      warn "[R] #{message}" if type == :message and $VERBOSE
       case type
         when :begin
           @last_patient = nil
           @last_order = nil
         when :idle
+          send_pending_requests
         when :message
           @message = LIS::Message::Base.from_string(message)
           handler = @handlers[@message.class]
           send(handler, @message) if handler
       end
     end
-  end
 
-end
+    def write(type, message=nil)
+      warn "[S] #{message}" if type == :message and $VERBOSE
+      super
+    end
+
+    # @yield data
+    def sending_session(data)
+      # don't send anything if there are no pending requests
+      return if data.nil? or data.empty?
+
+      write :begin
+      write :message, LIS::Message::Header.new("LIS", @device_name).to_message
+      yield data
+      write :message, LIS::Message::Terminator.new.to_message
+      write :idle
+    end
+  end
+end

data/lib/lis/commands/application.rb

@@ -0,0 +1,55 @@
+require 'optparse'
+
+module LIS
+  class Options < Hash
+    attr_reader :opts
+
+    def initialize(args)
+      super()
+
+      default_options = { :port => "/dev/ttyUSB0", :uri => "http://localhost/lis/" }
+      self.merge!(default_options)
+
+      @opts = OptionParser.new do |o|
+        appname = File.basename($0)
+        o.banner = "Usage: #{appname} [options]"
+
+        o.on('-l, --listen PORT', 'which port to listen on (default: "/dev/ttyUSB0")') do |port|
+          self[:port] = port
+        end
+        o.on('-e, --endpoint URI', 'HTTP endpoint (default: "http://localhost/lis/")') do |endpoint|
+          self[:uri] = endpoint
+        end
+        o.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+          $VERBOSE = v
+          self[:verbose] = v
+        end
+      end
+
+      begin
+        @opts.parse!(args)
+        self[:project_name] = args.shift
+      rescue OptionParser::ParseError => e
+        self[:invalid_argument] = e.message
+      end
+    end
+  end
+
+  class Application
+    def initialize(opts)
+      @options = Options.new(opts)
+
+      if @options[:invalid_argument]
+        warn @options.opts
+        exit 1
+      end
+    end
+
+    def run!
+      warn "listening on: #{@options[:port]}"
+      port = File.open(@options[:port], "w+")
+      LIS::InterfaceServer.new(port, @options[:uri]).run!
+    end
+  end
+
+end

data/lib/lis/interface_server.rb

@@ -0,0 +1,23 @@
+module LIS
+  class InterfaceServer
+    def initialize(port, http_endpoint)
+      @server  = LIS::Transfer::IOListener.new(port)
+      @packets = LIS::Transfer::PacketizedProtocol.new(@server)
+
+      app_protocol = LIS::Transfer::ApplicationProtocol.new(@packets)
+      interface    = WorklistManagerInterface.new(http_endpoint)
+
+      app_protocol.on_request do |device_name, barcode|
+        interface.load_requests(device_name, barcode)
+      end
+      app_protocol.on_result do |*args|
+        interface.send_result(*args)
+      end
+    end
+
+    def run!
+      warn "listener started" if $VERBOSE
+      @server.run!
+    end
+  end
+end

data/lib/lis/io_listener.rb

@@ -2,41 +2,72 @@ require 'strscan'
 
 module LIS::Transfer
 
-  # a chainable IO-Listener that provides to methods:
+  # a chainable IO-Listener that provides two methods:
   #
-  # +on_data+ :: a callback that is called whenever a message is received
-  # +write+   :: can be called so send messages to the underlying IO
+  # {#on_data} ::
+  #   a callback that is called whenever a message is received
+  # {#write} ::
+  #   can be called so send messages to the underlying IO
   #
   # when overriding this class, you need to implement two methods:
   #
-  # +receive+ :: is called from an underlying IO whenever a message is received
-  #              the message can be handled, if messages should be propagated, you
-  #              need to call `forward`
+  # {#receive} ::
+  #   is called from an underlying IO whenever a message is received
+  #   the message can be handled.  Call {#forward} to propagate
   #
-  # +write+ :: when data needs to be encoded, formatted before it can be send
-  #            send it with `super`
+  # {#write} ::
+  #   transform/encode a message before sending it. Call +super+ to propagate
   #
+  # See {LineBasedProtocol} for a toy implementation which strips
+  # newlines and only forwards complete lines.
   #
   class Base
+
+    # @param [Base, #on_data] read data source
+    # @param [Base, IO, #write] write object where messages are written to
+    #
     def initialize(read, write = read)
       @reader, @writer = read, write
       @on_data = nil
       @reader.on_data { |*data| receive(*data) } if @reader.respond_to?(:on_data)
     end
 
+    # register a block, to be run whenever the protocol implementation
+    # receives data (by calling {#forward})
+    #
+    # this is used to chain protocol layers together
+    #
+    # @return [self]
+    # @yield [*args] called whenever the protocol implementaion calls {#forward}
+    # @yieldreturn [nil]
+    #
     def on_data(&block)
       @on_data = block
+      self
     end
 
-    def write(message)
-      @writer << message if @writer
-    end
+    # @see #write
     def <<(*args)
       write(*args)
     end
 
-    private
+    # write data to underlying interface. override if data needs to be preprocessed
+    #
+    def write(*args)
+      @writer.<<(*args) if @writer
+    end
+
 
+    protected
+
+    # override this method to handle data received from an underlying interface, for
+    # example splitting it into messages or only passing on complete lines
+    # (see {LineBasedProtocol#receive} for an example)
+    #
+    # call {#forward} to pass it on to higher levels
+    #
+    # @return [nil]
+    #
     def receive(data)
       forward(data)
     end
@@ -48,6 +79,11 @@ module LIS::Transfer
 
 
   class LineBasedProtocol < Base
+
+    # strip newlines from received data and pass on complete lines
+    #
+    # @param [String] data
+    #
     def receive(data)
       @memo ||= ""
       scanner = StringScanner.new(@memo + data)
@@ -58,6 +94,9 @@ module LIS::Transfer
       nil
     end
 
+    # add a newline to data and pass it on
+    # @param [String] data
+    #
     def write(data)
       super(data + "\n")
     end
@@ -73,4 +112,3 @@ module LIS::Transfer
   end
 end
 
-

data/lib/lis/messages/header.rb

@@ -0,0 +1,23 @@
+module LIS::Message
+  class Header < Base
+    type_id "H"
+    has_field  2, :delimiter_definition, :default => "^&"
+    has_field  4, :access_password
+    has_field  5, :sender_name
+    has_field  6, :sender_address
+    has_field  7 # reserved
+    has_field  8 # sender_telephone_number
+    has_field  9, :sender_characteristics, :default => "8N1"
+    has_field 10, :receiver_name
+    has_field 11 # comments/special_instructions
+    has_field 12, :processing_id, :default => "P"
+    has_field 13, :version, :default => "1"
+    has_field 14, :timestamp, :default => lambda { Time.now.strftime("%Y%m%d%H%M%S") }
+
+    def initialize(sender_name = "SenderID", receiver_name = "ReceiverID", password = "")
+      self.sender_name = sender_name
+      self.receiver_name = receiver_name
+      self.access_password = password
+    end
+  end
+end

data/lib/lis/messages/order.rb

@@ -0,0 +1,35 @@
+module LIS::Message
+  class Order < Base
+    type_id "O"
+
+    has_field  3, :specimen_id
+    has_field  5, :universal_test_id_internal
+    has_field  6, :priority, :default => "R" # routine
+    has_field  7, :requested_at
+    has_field  8, :collected_at
+    has_field 12 # :action_code
+
+    has_field 14 # :relevant_clinical_information
+
+    has_field 25 # :instrument_section_id
+
+    has_field 29 # nosocomial_infection_flag
+    has_field 30 # specimen_service
+    has_field 31 # specimen_institution
+
+    field_count 0
+
+    def initialize(sequence_number, specimen_id, universal_test_id)
+      self.sequence_number = sequence_number
+      self.specimen_id = specimen_id
+      self.universal_test_id = universal_test_id
+    end
+
+    def universal_test_id
+      self.universal_test_id_internal.gsub(/\^/,"")
+    end
+    def universal_test_id=(val)
+      self.universal_test_id_internal = "^^^#{val}"
+    end
+  end
+end

data/lib/lis/messages/patient.rb

@@ -0,0 +1,22 @@
+module LIS::Message
+  class Patient < Base
+    type_id "P"
+
+    has_field  3, :practice_assigned_patient_id
+    has_field  4, :laboratory_assigned_patient_id
+    has_field  5, :patient_id
+    has_field  6, :name
+    has_field  7 # :mothers_maiden_name
+    has_field  8, :birthdate
+    has_field  9, :sex
+    has_field 10, :race
+    has_field 14, :attending_physician
+
+    def initialize(sequence_number, patient_id, last_name = "", first_name = "")
+      self.sequence_number = sequence_number
+      self.practice_assigned_patient_id = patient_id
+      self.name = [last_name, first_name].join("^")
+    end
+
+  end
+end

data/lib/lis/messages/query.rb

@@ -0,0 +1,13 @@
+module LIS::Message
+  class Query < Base
+    type_id "Q"
+    has_field 3, :starting_range_id_internal
+
+    def starting_range_id
+      starting_range_id_internal.gsub(/\^/,"")
+    end
+    def starting_range_id=(val)
+      starting_range_id_internal = "^#{val}"
+    end
+  end
+end

data/lib/lis/messages/result.rb

@@ -0,0 +1,20 @@
+module LIS::Message
+  class Result < Base
+    type_id "R"
+    has_field  3, :universal_test_id_internal
+    has_field  4, :result_value
+    has_field  5, :unit
+    has_field  6, :reference_ranges
+    has_field  7, :abnormal_flags
+    has_field  9, :result_status
+    has_field 12, :test_started_at, :type => :timestamp
+    has_field 13, :test_completed_at, :type => :timestamp
+
+    def universal_test_id
+      universal_test_id_internal.gsub(/\^/,"")
+    end
+    def universal_test_id=(val)
+      universal_test_id_internal = "^^^#{val}"
+    end
+  end
+end

data/lib/lis/messages/terminator.rb

@@ -0,0 +1,16 @@
+module LIS::Message
+  class Terminator < Base
+    TERMINATION_CODES = {
+      "N" => "Normal termination",
+      "T" => "Sender Aborted",
+      "R" => "Receiver Abort",
+      "E" => "Unknown system error",
+      "Q" => "Error in last request for information",
+      "I" => "No information available from last query",
+      "F" => "Last request for information Processed"
+    }
+
+    type_id "L"
+    has_field 3, :termination_code, :default => "N"
+  end
+end

data/lib/lis/messages.rb

@@ -1,125 +1,122 @@
+require 'date'
 
 module LIS::Message
   module ClassMethods
-    FIELD_TYPES = {
+    CONVERSION_WRITER = {
       :string => lambda { |s| s },
-      :int => lambda { |s| s.to_i }
+      :int => lambda { |s| s.to_i },
+      :timestamp => lambda { |s| DateTime.strptime(s, "%Y%m%d%H%M%S") }
     }
 
+    def field_count(val = nil)
+      @field_count = val if val
+      @field_count
+    end
+
     def from_string(message)
-      frame_number, type, data = parse(message)
+      type, data = parse(message)
       klass = (@@messages_by_type || {})[type]
       raise "unknown message type #{type.inspect}" unless klass
 
       obj = klass.allocate
-      obj.frame_number = frame_number
-      obj.type_id = type
-
-      # populate named fields
-      data.each_with_index do |val, index|
-        klass.get_named_field_attributes(index + 2)
-        if field = klass.get_named_field_attributes(index+2)
-          obj.send(:"#{field[:name]}=", FIELD_TYPES[field[:type]].call(val))
-        end
+
+      data = data.to_enum(:each_with_index).inject({}) do |h,(elem,idx)|
+        h[idx+2] = elem; h
       end
 
+      obj.instance_variable_set("@fields", data)
       obj
     end
 
-    def initialize_from_message(*list_of_fields)
+    def default_fields
+      arr = Array.new(@field_count)
+      (0 .. @field_count).inject(arr) do |a,i|
+        default = (get_field_attributes(i) || {})[:default]
+        if default
+          default = default.call if default.respond_to?(:call)
+          a[i-1] = default
+        end
+        arr
+      end
     end
 
-    protected
+    def has_field(idx, name = nil, opts={})
+      set_index_for(name, idx) if name
+      set_field_attributes(idx, { :name => name,
+                                  :type => opts[:type] || :string,
+                                  :default => opts[:default]})
+
+      @field_count ||= 0
+      @field_count = [@field_count, idx].max
+
+      return unless name
+
+      define_method :"#{name}=" do |val|
+        @fields ||= {}
+        @fields[idx] = val
+      end
+
+      define_method :"#{name}" do
+        field_attrs = self.class.get_field_attributes(idx)
+        val = (@fields || {})[idx]
+        converter = CONVERSION_WRITER[field_attrs[:type]] if field_attrs
+        val = converter.call(val) if converter
+        val
+      end
+    end
 
     def parse(string)
-      frame_number, type, data = string.scan(/^(.)(.)\|(.*)$/)[0]
+      type, data = string.scan(/^(.)\|(.*)$/)[0]
       data = data.split(/\|/)
 
-      return [frame_number.to_i, type, data]
+      return [type, data]
     end
 
-    def type_id(char)
+    def type_id(char = nil)
+      return @@messages_by_type.find {|c,klass| klass == self }.first unless char
       @@messages_by_type ||= {}
       @@messages_by_type[char] = self
     end
 
-    def named_field(idx, name, type = :string)
-      set_named_field_attributes(idx, :name => name, :type => type)
-      attr_accessor name
+    def set_index_for(field_name, idx)
+      @field_indices ||= {}
+      @field_indices[field_name] = idx
     end
 
-    def get_named_field_attributes(key)
-      @field_names ||= {}
-      val = (@field_names || {})[key]
-      val ||= superclass.get_named_field_attributes(key) if superclass.respond_to?(:get_named_field_attributes)
+    def get_index_for(field_name)
+      val = @field_index[field_name]
+      val ||= superclass.get_index_for(field_name) if superclass.respond_to?(:get_index_for)
       val
     end
 
-    private
+    def get_field_attributes(index)
+      @field_names ||= {}
+      val = (@field_names || {})[index]
+      val ||= superclass.get_field_attributes(index) if superclass.respond_to?(:get_field_attributes)
+      val
+    end
 
-    def set_named_field_attributes(key, *val)
+    def set_field_attributes(index, hash)
       @field_names ||= {}
-      @field_names[key] = *val
+      @field_names[index] = hash
     end
   end
 
   class Base
     extend ClassMethods
     attr_accessor :frame_number
-    attr_accessor :type_id
 
-    named_field 2, :sequence_number, :int
-  end
-
-
-  class Header < Base
-    type_id "H"
-    named_field  2, :delimiter_definition
-    named_field  4, :access_password
-    named_field  5, :sender_name
-    named_field 10, :receiver_id
-  end
-
-  class Order < Base
-    type_id "O"
-    named_field 3, :specimen_id
-    named_field 5, :universal_test_id
-    named_field 6, :priority
-    named_field 7, :requested_at
-    named_field 8, :collected_at
-  end
-
-  class Result < Base
-    type_id "R"
-    named_field 3, :universal_test_id
-    named_field 4, :result_value
-    named_field 5, :unit
-    named_field 6, :reference_ranges
-    named_field 7, :abnormal_flags
-  end
+    has_field 2, :sequence_number, :type => :int, :default => 1
 
-  class Patient < Base
-    type_id "P"
-  end
-
-  class Query < Base
-    type_id "Q"
-  end
-
-
-  class TerminatorRecord < Base
-    TERMINATION_CODES = {
-      "N" => "Normal termination",
-      "T" => "Sender Aborted",
-      "R" => "Receiver Abort",
-      "E" => "Unknown system error",
-      "Q" => "Error in last request for information",
-      "I" => "No information available from last query",
-      "F" => "Last request for information Processed"
-    }
+    def type_id
+     self.class.type_id
+    end
 
-    type_id "L"
-    named_field 3, :termination_code
+    def to_message
+      @fields ||= {}
+      arr = Array.new(self.class.default_fields)
+      type_id + @fields.inject(arr) { |a,(k,v)| a[k-1] = v; a }.join("|")
+    end
   end
 
-end
+end

data/lib/lis/packetized_protocol.rb

@@ -17,10 +17,17 @@ module LIS::Transfer
     ENQ = "\005"
     EOT = "\004"
 
+    # format of a message
     RX = /(?:
           \005 | # ENQ - start a transaction
           \004 | # EOT - ends a transaction
-          (?:\002 (.*?) \015 \003 (.+?) \015 \012)) # a message with a checksum
+          \005 | # ACK
+          \025 | # NAK
+          (?:\002 (.) (.*?) \015 \003 (.+?) \015 \012) # a message with a checksum
+                #  |   |               `-- checksum
+                #  |   `------------------ message
+                #  `---------------------- frame number
+          )
         /xm
 
     def initialize(*args)
@@ -31,42 +38,71 @@ module LIS::Transfer
 
     def receive(data)
       scanner = StringScanner.new(@memo + data)
-      while match = scanner.scan(RX)
+      while scanner.scan_until(RX)
+        match = scanner.matched
         case match
           when ENQ then transmission_start
           when EOT then transmission_end
+          when ACK, NAK then nil
         else
           received_message(match)
-          write ACK
+          write :ack
         end
       end
       @memo = scanner.rest
       nil
     end
 
+    def write(type, data = nil)
+      str = case type
+        when :ack then ACK
+        when :nak then NAK
+        when :begin then
+          @frame_number = 0
+          ENQ
+        when :idle then EOT
+        when :message then
+          @frame_number = (@frame_number + 1) % 8
+          self.class.wrap_message(data, @frame_number)
+      else
+        raise ArgumentError
+      end
+      super(str)
+    end
+
 
     private
 
     def self.message_from_string(string)
       match = string.match(RX)
-      data = match[1]
-      checksum = match[2]
 
-      expected_checksum = data.to_enum(:each_byte).inject(16) { |a,b| (a+b) % 0x100 }
+      frame_number, data, checksum = match[1 .. 3]
+
+      expected_checksum = (frame_number + data).each_byte.inject(16) { |a,b| (a+b) % 0x100 }
       actual_checksum   = checksum.to_i(16)
 
       raise "checksum mismatch" unless expected_checksum == actual_checksum
-      return data
+      return [frame_number.to_i, data]
     end
 
+    def self.wrap_message(string, frame_number)
+      frame_number = (frame_number % 8).to_s
+      checksum = (frame_number + string).each_byte.inject(16) { |a,b| (a+b) % 0x100 }
+      checksum = checksum.to_s(16).upcase.rjust(2,"0")
+
+      "\002#{frame_number}#{string}\015\003#{checksum}\015\012"
+    end
+
+
     def received_message(message)
       return false unless @inside_transmission
-      forward(:message, self.class.message_from_string(message))
+      frame_number, message = *self.class.message_from_string(message)
+      forward(:message, message)
     end
 
     def transmission_start
       return false if @inside_transmission
-      write ACK
+      write :ack
       forward :begin
       @inside_transmission = true
       true
@@ -80,4 +116,4 @@ module LIS::Transfer
     end
   end
 
-end
+end

data/lib/lis/worklist_manager_interface.rb

@@ -1,11 +1,14 @@
+require 'net/http'
+require 'yaml'
+
 class WorklistManagerInterface
   def initialize(endpoint)
     @endpoint = endpoint
   end
 
-  def load_requests(barcode)
+  def load_requests(device_name, barcode)
     begin
-      uri = URI.join(@endpoint,"find_requests/#{barcode}")
+      uri = URI.join(@endpoint,"find_requests/#{[device_name, barcode].join('-')}")
       result = fetch_with_redirect(uri.to_s)
       data = YAML.load(result.body)
       data["id"] = barcode
@@ -14,27 +17,35 @@ class WorklistManagerInterface
       puts e.backtrace
       data = nil
     end
+
+    data
   end
 
-  def send_result(patient, order, result)
+  def send_result(device_name, patient, order, result)
     barcode = order.specimen_id
     data = {
-      "test_name" => order.test_id,
-      "value" => result.value,
+      "test_name" => order.universal_test_id,
+      "value" => result.result_value,
       "unit" => result.unit,
       "status" => result.result_status,
       "flags" => result.abnormal_flags,
-      "result_timestamp" => result.timestamp
+      "result_timestamp" => result.test_completed_at
     }
 
-    Net::HTTP.post_form(URI.join(@endpoint, "result/#{URI.encode(barcode)}"), data.to_hash)
+    p data
+    begin
+      res = Net::HTTP.post_form(URI.join(@endpoint, "result/#{[device_name, barcode].join('-')}"), data.to_hash)
+    rescue Exception => e
+      puts "EXCEPTION"
+      p e
+    end
   end
 
 
   private
 
   def fetch_with_redirect(uri_str, limit = 10)
-    raise ArgumentError, 'HTTP redirect too deep' if limit == 0
+    raise ArgumentError, 'too many HTTP redirects' if limit == 0
 
     response = Net::HTTP.get_response(URI.parse(uri_str))
     case response
@@ -44,4 +55,4 @@ class WorklistManagerInterface
       response.error!
     end
   end
-end
+end

data/lib/lis.rb

@@ -5,6 +5,10 @@ end
 
 require 'lis/io_listener.rb'
 require 'lis/messages.rb'
+
+Dir[File.join(File.dirname(__FILE__), 'lis/messages/**/*.rb')].each { |f| require f }
+
 require 'lis/packetized_protocol.rb'
 require 'lis/application_protocol.rb'
 require 'lis/worklist_manager_interface.rb'
+require 'lis/interface_server.rb'

data/lis.gemspec

@@ -5,40 +5,54 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lis}
-  s.version = "0.0.0"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Levin Alexander"]
-  s.date = %q{2010-02-07}
-  s.default_executable = %q{lis}
+  s.date = %q{2010-02-14}
+  s.default_executable = %q{lis2http}
   s.description = %q{}
   s.email = %q{mail@levinalex.net}
-  s.executables = ["lis"]
+  s.executables = ["lis2http"]
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+     "README.markdown"
   ]
   s.files = [
     ".document",
      ".gitignore",
+     ".yardopts",
      "LICENSE",
-     "README.rdoc",
+     "README.markdown",
      "Rakefile",
      "VERSION",
-     "bin/lis",
+     "bin/lis2http",
      "features/communication basics.feature",
      "features/lis.feature",
      "features/step_definitions/lis_steps.rb",
      "features/support/env.rb",
      "lib/lis.rb",
      "lib/lis/application_protocol.rb",
+     "lib/lis/commands/application.rb",
+     "lib/lis/interface_server.rb",
      "lib/lis/io_listener.rb",
      "lib/lis/messages.rb",
+     "lib/lis/messages/header.rb",
+     "lib/lis/messages/order.rb",
+     "lib/lis/messages/patient.rb",
+     "lib/lis/messages/query.rb",
+     "lib/lis/messages/result.rb",
+     "lib/lis/messages/terminator.rb",
      "lib/lis/packetized_protocol.rb",
      "lib/lis/worklist_manager_interface.rb",
      "lis.gemspec",
      "test/helper.rb",
      "test/lib/mock_server.rb",
+     "test/messages/test_header.rb",
+     "test/messages/test_order.rb",
+     "test/messages/test_patients.rb",
+     "test/messages/test_terminator.rb",
+     "test/test_application_protocol.rb",
      "test/test_io_listener.rb",
      "test/test_messages.rb",
      "test/test_packetized_protocol.rb"
@@ -51,6 +65,11 @@ Gem::Specification.new do |s|
   s.test_files = [
     "test/helper.rb",
      "test/lib/mock_server.rb",
+     "test/messages/test_header.rb",
+     "test/messages/test_order.rb",
+     "test/messages/test_patients.rb",
+     "test/messages/test_terminator.rb",
+     "test/test_application_protocol.rb",
      "test/test_io_listener.rb",
      "test/test_messages.rb",
      "test/test_packetized_protocol.rb"

data/test/helper.rb

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
+require 'mocha'
 require 'lib/mock_server'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))

data/test/messages/test_header.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+class TestHeaderMessages < Test::Unit::TestCase
+  context "header message" do
+    setup do
+      Time.stubs(:now).returns(Time.mktime(2010,2,15,17,28,32))
+    end
+
+    should "have sane defaults" do
+      @message = LIS::Message::Header.new()
+      assert_equal "H|\^&|||SenderID||||8N1|ReceiverID||P|1|20100215172832", @message.to_message
+    end
+
+    should "have overridable sender and receiver IDs" do
+      @message = LIS::Message::Header.new("SEND", "RECV", "PASSWORD")
+      assert_equal "H|\^&||PASSWORD|SEND||||8N1|RECV||P|1|20100215172832", @message.to_message
+    end
+  end
+end

data/test/messages/test_order.rb

@@ -0,0 +1,10 @@
+require 'helper'
+
+class TestOrderMessages < Test::Unit::TestCase
+  context "order message" do
+    should "have sane defaults" do
+      @message = LIS::Message::Order.new("4","123ABC","TU")
+      assert_equal "O|4|123ABC||^^^TU", @message.to_message
+    end
+  end
+end

data/test/messages/test_patients.rb

@@ -0,0 +1,10 @@
+require 'helper'
+
+class TestPatientMessages < Test::Unit::TestCase
+  context "order message" do
+    should "have sane defaults" do
+      @message = LIS::Message::Patient.new(1, 101, "Riker", "Al")
+      assert_equal "P|1|101|||Riker^Al||||||||", @message.to_message
+    end
+  end
+end

data/test/messages/test_terminator.rb

@@ -0,0 +1,25 @@
+require 'helper'
+
+class TestTerminatorMessages < Test::Unit::TestCase
+  context "message parsing" do
+    setup do
+      @message = LIS::Message::Base.from_string("L|1|N")
+    end
+
+    should "have correct type" do
+      assert_equal LIS::Message::Terminator, @message.class
+      assert_equal "L", @message.type_id
+    end
+
+    should "have correct sequence number" do
+      assert_equal 1, @message.sequence_number
+    end
+  end
+
+  context "terminator message" do
+    should "work" do
+      @message = LIS::Message::Terminator.new()
+      assert_equal "L|1|N", @message.to_message
+    end
+  end
+end

data/test/test_application_protocol.rb

@@ -0,0 +1,15 @@
+require 'helper'
+
+class TestApplicationProtocol < Test::Unit::TestCase
+  context "application protocol" do
+    setup do
+      @protocol = LIS::Transfer::ApplicationProtocol.new(nil, nil)
+    end
+
+    should "set device name when receiving header message" do
+      @protocol.receive(:message,
+        "H|\^&||PASSWORD|SenderID|Randolph^New^Jersey^07869||(201)927- 2828|8N1|ReceiverID||P|1|19950522092817")
+      assert_equal "SenderID", @protocol.device_name
+    end
+  end
+end

data/test/test_messages.rb

@@ -1,37 +1,42 @@
 require 'helper'
 
-class TestPacketizedProtocol < Test::Unit::TestCase
+class TestMessages < Test::Unit::TestCase
 
-  context "message parsing" do
+  context "parsing an order message" do
     setup do
-      @message = LIS::Message::Base.from_string("3L|1|N")
+      @str = "O|1|8780||^^^ATA|R|||||||||||||||||||B0135"
+      @message = LIS::Message::Base.from_string(@str)
     end
 
-    should "have correct frame number" do
-      assert_equal 3, @message.frame_number
+    should "have correct type" do
+      assert_equal LIS::Message::Order, @message.class
+      assert_equal "O", @message.type_id
     end
 
-    should "have correct type" do
-      assert_equal LIS::Message::TerminatorRecord, @message.class
-      assert_equal "L", @message.type_id
+    should "have correct speciment id" do
+      assert_equal "8780", @message.specimen_id
     end
 
-    should "have correct sequence number" do
-      assert_equal 1, @message.sequence_number
+    should "return message itself on #to_message" do
+      assert_equal @str, @message.to_message
     end
   end
 
   context "parsing a result message" do
     setup do
-      @str = "7R|1|^^^TSH|0.902|mIU/L|0.400\\0.004^4.00\\75.0|N|N|R|||20100115105636|20100115120641|B0135"
+      @str = "R|1|^^^TSH|0.902|mIU/L|0.400\\0.004^4.00\\75.0|N|N|R|||20100115105636|20100115120641|B0135"
       @message = LIS::Message::Base.from_string(@str)
     end
 
     should "have correct type" do
-      assert_equal LIS::Message::Result, @message.type
+      assert_equal LIS::Message::Result, @message.class
       assert_equal "R", @message.type_id
     end
 
+    should "have correct timestamp" do
+      assert_equal "2010-01-15T10:56:36+00:00", @message.test_started_at.to_s
+    end
+
     should "have correct test id" do
       assert_equal "TSH", @message.universal_test_id
     end
@@ -43,6 +48,10 @@ class TestPacketizedProtocol < Test::Unit::TestCase
     should "have currect value and unit" do
       assert_equal "mIU/L", @message.unit
     end
+
+    should "return message itself on #to_message" do
+      assert_equal @str, @message.to_message
+    end
   end
 
 end

data/test/test_packetized_protocol.rb

@@ -54,6 +54,11 @@ class TestPacketizedProtocol < Test::Unit::TestCase
       assert_equal [[:begin], [:idle]], @data
     end
 
+    should "ignore AKS and NAKs" do
+      @protocol.receive("\005\006\025\004")
+      assert_equal [[:begin], [:idle]], @data
+    end
+
     should "not fire end_of_transmission event after EOT is received" do
       @protocol.receive("\004")
       assert_equal [], @data
@@ -74,7 +79,19 @@ class TestPacketizedProtocol < Test::Unit::TestCase
       @protocol.receive(@str)
       @protocol.receive("\004")
 
-      assert_equal [[:begin], [:message, "3L|1"], [:idle]], @data
+      assert_equal [[:begin], [:message, "L|1"], [:idle]], @data
+    end
+
+    should "add frame number and checksum when sending a message" do
+      @protocol.write(:begin)
+      @protocol.write(:message, "O|1|130000911||^^^E2")
+      @protocol.write(:message, "L|1")
+      @protocol.write(:idle)
+
+      assert_equal ["\005",
+                    "\0021O|1|130000911||^^^E2\r\00301\r\n",
+                    "\0022L|1\r\0033B\r\n",
+                    "\004"], @sent
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: lis
 version: !ruby/object:Gem::Version 
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Levin Alexander
@@ -9,8 +9,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-07 00:00:00 +01:00
-default_executable: lis
+date: 2010-02-14 00:00:00 +01:00
+default_executable: lis2http
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: thoughtbot-shoulda
@@ -45,33 +45,47 @@ dependencies:
 description: ""
 email: mail@levinalex.net
 executables: 
-- lis
+- lis2http
 extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.rdoc
+- README.markdown
 files: 
 - .document
 - .gitignore
+- .yardopts
 - LICENSE
-- README.rdoc
+- README.markdown
 - Rakefile
 - VERSION
-- bin/lis
+- bin/lis2http
 - features/communication basics.feature
 - features/lis.feature
 - features/step_definitions/lis_steps.rb
 - features/support/env.rb
 - lib/lis.rb
 - lib/lis/application_protocol.rb
+- lib/lis/commands/application.rb
+- lib/lis/interface_server.rb
 - lib/lis/io_listener.rb
 - lib/lis/messages.rb
+- lib/lis/messages/header.rb
+- lib/lis/messages/order.rb
+- lib/lis/messages/patient.rb
+- lib/lis/messages/query.rb
+- lib/lis/messages/result.rb
+- lib/lis/messages/terminator.rb
 - lib/lis/packetized_protocol.rb
 - lib/lis/worklist_manager_interface.rb
 - lis.gemspec
 - test/helper.rb
 - test/lib/mock_server.rb
+- test/messages/test_header.rb
+- test/messages/test_order.rb
+- test/messages/test_patients.rb
+- test/messages/test_terminator.rb
+- test/test_application_protocol.rb
 - test/test_io_listener.rb
 - test/test_messages.rb
 - test/test_packetized_protocol.rb
@@ -106,6 +120,11 @@ summary: LIS interface to Siemens Immulite 2000XPi or other similar analyzers
 test_files: 
 - test/helper.rb
 - test/lib/mock_server.rb
+- test/messages/test_header.rb
+- test/messages/test_order.rb
+- test/messages/test_patients.rb
+- test/messages/test_terminator.rb
+- test/test_application_protocol.rb
 - test/test_io_listener.rb
 - test/test_messages.rb
 - test/test_packetized_protocol.rb

data/README.rdoc

@@ -1,7 +0,0 @@
-= LIS
-
-Description goes here.
-
-== Copyright
-
-Copyright (c) 2010 Levin Alexander. See LICENSE for details.

data/bin/lis

@@ -1,32 +0,0 @@
-#!/usr/bin/env ruby -w
-require 'lib/lis.rb'
-
-# protocol = LIS::Transfer::PacketizedProtocol.new
-# server = LIS::Transfer::Server.new(protocol, socket)
-
-socket = File.open("/dev/cu.usbserial-FTC95RQI", "w+")
-server = LIS::Transfer::IOListener.new(socket)
-packet_protocol = LIS::Transfer::PacketizedProtocol.new(server)
-app_protocol = LIS::Transfer::ApplicationProtocol.new(packet_protocol)
-
-interface = WorklistManagerInterface.new("http://localhost:3000")
-
-app_protocol.on_request do |*args|
-  p "ON REQUEST"
-  p args
-
-  nil
-#  interface.load_reqests(*args)
-end
-
-app_protocol.on_result do |*args|
-  p "SEND RESULT"
-  p args
-  interface.send_result(*args)
-end
-
-app_protocol.on_data do |data|
-  p data
-end
-
-server.run!