ruby_astm 1.4.1 → 1.4.3

data/lib/publisher/poller.rb

@@ -24,8 +24,9 @@ class Poller
 	RUNNING = "running"
 	COMPLETED = "completed"
 
-	def initialize(mpg=nil)
+	def initialize(mpg=nil,real_time_db=nil)
 		$redis = Redis.new
+		$real_time_db = real_time_db
 		## this mapping is from MACHINE CODE AS THE KEY
 	    $mappings = JSON.parse(IO.read(mpg || AstmServer.default_mappings))
 	    ## INVERTING THE MAPPINGS, GIVES US THE LIS CODE AS THE KEY.
@@ -177,12 +178,18 @@ class Poller
 	        	puts package_components.to_s
 
 	        	package_components.each do |component|
-	        		puts "doing component: #{component}"
+	        		#puts "doing component: #{component}"
 	        		## these are the machine codes.
 	        		## so to get the tube, you have to get it from the inverted mappings.
 	        		## cant get directly like this.
+	        		#puts "inverted mappings"
+	        		#puts $inverted_mappings
 	        		component_machine_code = $inverted_mappings[component]
-	        		puts "component machine code: #{component_machine_code}"
+	        		#puts "component machine code: #{component_machine_code}"
+
+	        		## for eg plasma tube can do all the tests
+	        		## so can serum
+	        		## but we use the plasma tube only for some.
 
 	        		tube = $mappings[component_machine_code]["TUBE"]
 			        tube_key = nil
@@ -215,6 +222,8 @@ class Poller
 
 	## @param[Integer] epoch : the epoch at which these tests were requested.
 	## @param[Hash] tests : {"EDTA:barcode" => [MCV,MCH,MCHC...]}
+	## the test codes here are the lis_codes
+	## so we need the inverted mappings for this
 	def merge_with_requisitions_hash(epoch,tests)
 	    ## so we basically now add this to the epoch ?
 	    ## or a sorted set ?

data/lib/publisher/real_time_db.rb

@@ -0,0 +1,76 @@
+require 'rest-firebase'
+require "resolv-replace"
+class RealTimeDb
+
+	SITE_URL = ENV["FIREBASE_SITE"]
+	SECRET = ENV["FIREBASE_SECRET"]
+	attr_accessor :connection
+	attr_accessor :work_allotment_hash
+	WORK_TYPES = {
+		"IMMUNO" => "",
+		"BIOCHEM" => "",
+		"BIOCHEM-EXL" => "",
+		"BIOCHEM-ELECTROLYTE" => "",
+		"HEMAT" => "",
+		"URINE" => "",
+		"OUTSOURCE" => ""
+	}
+
+	## first i email myself the site and secret
+	## then we proceed.
+
+	## @param[Hash] work_allotment_hash :
+	## key => one of the work types
+	## value => name of a worker
+	def initialize(work_allotment_hash)
+		self.connection = RestFirebase.new :site => SITE_URL,
+                     :secret => SECRET
+        puts "initialized"
+        self.work_allotment_hash = work_allotment_hash || WORK_TYPES
+	end
+
+	def open_event_stream
+		es = self.connection.event_source('users/tom')
+		es.onopen   { |sock| p sock } # Called when connected
+		es.onmessage{ |event, data, sock| p event, data } # Called for each message
+		es.onerror  { |error, sock| p error } # Called whenever there's an error
+		# Extra: If we return true in onreconnect callback, it would automatically
+		#        reconnect the node for us if disconnected.
+		@reconnect = true
+
+		es.onreconnect{ |error, sock| p error; @reconnect }
+
+		# Start making the request
+		es.start
+
+		self.connection.wait
+	end
+
+
+
+
+	## we pass the real_time_data instance into the 
+
+	def assign_test(barcode,tests,mappings)
+		## so do we get the name of the worker.
+		inverted_mappings = {}
+		mappings.keys.each do |machine_code|
+			lis_code = mappings[machine_code][LIS_CODE]
+			inverted_mappings[lis_code] = mappings[machine_code]
+		end
+		worker_hash = {}
+		tests.each do |lis_code|
+			worker_name = "NO_ONE"
+			unless inverted_mappings[lis_code].blank?
+				test_type = inverted_mappings[lis_code]["TYPE"]
+				worker_name = self.work_allotment_hash[test_type]
+			end
+			worker_hash[worker_name] ||= []
+			worker_hash[worker_name] << lis_code
+		end
+		worker_hash.keys.each do |worker_name|
+			#self.connection.post("lab/work/#{worker_name}", :tests => worker_hash[worker_name], :barcode => barcode, :timestamp => Time.now.to_i)
+		end
+	end
+	
+end

data/lib/ruby_astm.rb

@@ -1,17 +1,21 @@
-require "ruby_astm/usb_module"
-require "ruby_astm/query"
-require "ruby_astm/frame"
-require "ruby_astm/header"
-require "ruby_astm/lab_interface"
-require "ruby_astm/line"
-require "ruby_astm/order"
-require "ruby_astm/patient"
-require "ruby_astm/result"
-require "ruby_astm/astm_server"
-require "publisher/adapter"
-require "publisher/google_lab_interface"
-require "publisher/poller"
-require "ruby_astm/HL7/hl7_header"
-require "ruby_astm/HL7/hl7_patient"
-require "ruby_astm/HL7/hl7_order"
-require "ruby_astm/HL7/hl7_observation"
+require_relative "ruby_astm/usb_module"
+require_relative "ruby_astm/query"
+require_relative "ruby_astm/frame"
+require_relative "ruby_astm/header"
+require_relative "ruby_astm/lab_interface"
+require_relative "ruby_astm/line"
+require_relative "ruby_astm/order"
+require_relative "ruby_astm/patient"
+require_relative "ruby_astm/result"
+require_relative "ruby_astm/astm_server"
+require_relative "publisher/adapter"
+require_relative "publisher/google_lab_interface"
+require_relative "publisher/poller"
+require_relative "publisher/real_time_db"
+require_relative "publisher/pf_lab_interface"
+require_relative "ruby_astm/HL7/hl7_header"
+require_relative "ruby_astm/HL7/hl7_patient"
+require_relative "ruby_astm/HL7/hl7_order"
+require_relative "ruby_astm/HL7/hl7_observation"
+require_relative "ruby_astm/custom/siemens_abg_electrolyte_server"
+

data/lib/ruby_astm/astm_server.rb

@@ -4,6 +4,7 @@ require 'em-rubyserial'
 require "active_support/all"
 require "json"
 require "redis"
+require "rest-firebase"
 
 class AstmServer
 

data/lib/ruby_astm/custom/siemens_abg_electrolyte_server.rb

@@ -0,0 +1,315 @@
+class SiemensAbgElectrolyteServer < AstmServer
+
+	SIEMENS_ELECTROLYTE_END = [10,10,10,10]
+	ELECTROLYTE_START = [45, 45, 45, 32]
+	attr_accessor :current_text_segment
+
+	def get_po2
+		m = []
+		self.current_text_segment.scan(/pO2\s+(?<k>(\d+)(\.\d)*)(\^|v)?\s+mmHg/) do |l|
+	      n = Regexp.last_match
+	      m << n[:k].to_s
+	    end
+	    raise "more than one result #{m.to_s}" if (m.size > 1)
+	    return m[0] if m.size == 1
+	    return nil
+	end
+
+	def get_pco2
+		m = []
+		self.current_text_segment.scan(/pCO2\s+(?<k>(\d+)(\.\d)*)(\^|v)?\s+mmHg/) do |l|
+	      n = Regexp.last_match
+	      m << n[:k].to_s
+	    end
+	    raise "more than one result #{m.to_s}" if (m.size > 1)
+	    return m[0] if m.size == 1
+	    return nil
+	end
+
+	def get_ph
+		m = []
+		self.current_text_segment.scan(/pH\s+(?<k>(\d+)[\.\d]*)(\^|v)?\s+$/) do |l|
+	      n = Regexp.last_match
+	      m << n[:k].to_s
+	    end
+	    raise "more than one result #{m.to_s}" if (m.size > 1)
+	    return m[0] if m.size == 1
+	    return nil
+	end
+
+	def get_na
+		m = []
+		self.current_text_segment.scan(/Na\+\s+(?<k>(\d+)[\.\d]*)(\^|v)?\s+mmol\/L/) do |l|
+	      n = Regexp.last_match
+	      m << n[:k].to_s
+	    end
+	    raise "more than one result #{m.to_s}" if (m.size > 1)
+	    return m[0] if m.size == 1
+	    return nil
+	end
+
+	def get_k
+		m = []
+		self.current_text_segment.scan(/K\+\s+(?<k>(\d+)[\.\d]*)(\^|v)?\s+mmol\/L/) do |l|
+	      n = Regexp.last_match
+	      m << n[:k].to_s
+	    end
+	    raise "more than one result #{m.to_s}" if (m.size > 1)
+	    return m[0] if m.size == 1
+	    return nil
+	end
+
+	def get_cl
+		m = []
+		self.current_text_segment.scan(/Cl\-\s+(?<k>(\d+)[\.\d]*)(\^|v)?\s+mmol\/L/) do |l|
+	      n = Regexp.last_match
+	      m << n[:k].to_s
+	    end
+	    raise "more than one result #{m.to_s}" if (m.size > 1)
+	    return m[0] if m.size == 1
+	    return nil
+	end
+
+	def get_patient_id
+		m = []
+		self.current_text_segment.scan(/Patient\s+ID\s+(?<k>\d+)$/) do |l|
+	      n = Regexp.last_match
+	      m << n[:k].to_s
+	    end
+	    raise "more than one result #{m.to_s}" if (m.size > 1)
+	    return m[0] if m.size == 1
+	    return nil
+	end
+
+	## we override the lab interface methods
+	## and we don't pollute the lab interface itself.
+	## as this is a custom analyzer.
+	## @param[Array] : 
+  	## [[bytes],[bytes]....]
+  	def process_electrolytes(data_bytes)
+	    #puts "came to process electrolytes_plain_text"
+	    byte_arr = data_bytes.flatten
+	    #puts "the end part of the arr is"
+	    return if byte_arr[-4..-1] != SIEMENS_ELECTROLYTE_END
+	    self.data_bytes = []
+	    concat = ""
+	    byte_arr.each do |byte|
+	        x = [byte].pack('c*').force_encoding('UTF-8')
+	        if x == "\r"
+	          concat+="\n"
+	        elsif x == "\n"
+	          #puts "new line found --- "
+	          concat+=x
+	          #puts "last thing in concat."
+	          #puts concat[-1].to_s
+	        else
+	          concat+=x
+	        end
+	    end
+	    
+	    self.headers ||= [Header.new]
+	    concat.split("--------------------------------").each do |record|
+
+	    	self.current_text_segment = record
+	    	if patient_id = get_patient_id
+	    		self.headers[-1].patients ||= []
+	    		p = Patient.new
+	    		p.patient_id = patient_id
+	    		p.orders ||= []
+	    		o = Order.new
+	    		o.results ||= {}
+	    		if sodium = get_na
+	    			r = Result.new
+	    			r.name = "SNATRIUM"
+	    			r.report_name = "Serum Electrolytes"
+	    			r.value = sodium
+	    			r.units = "mmol/L"
+	    			r.timestamp = Time.now.to_i
+	    			o.results["SNATRIUM"] = r
+	    		end
+
+	    		if potassium = get_k
+	    			r = Result.new
+	    			r.name = "SPOTASSIUM"
+	    			r.report_name = "Serum Electrolytes"
+	    			r.value = potassium
+	    			r.units = "mmol/L"
+	    			r.timestamp = Time.now.to_i
+	    			o.results["SPOTASSIUM"] = r
+	    		end
+
+	    		if chloride = get_cl
+	    			r = Result.new
+	    			r.name = "SCHLORIDE"
+	    			r.report_name = "Serum Electrolytes"
+	    			r.value = chloride
+	    			r.units = "mmol/L"
+	    			r.timestamp = Time.now.to_i
+	    			o.results["SCHLORIDE"] = r
+	    		end
+	    		
+	    		if ph = get_ph
+	    			r = Result.new
+	    			r.name = "pH"
+	    			r.report_name = "Serum Electrolytes"
+	    			r.value = ph
+	    			r.units = "mmol/L"
+	    			r.timestamp = Time.now.to_i
+	    			o.results["pH"] = r
+	    		end
+	    		
+	    		if po2 = get_po2
+	    			r = Result.new
+	    			r.name = "po2"
+	    			r.report_name = "Serum Electrolytes"
+	    			r.value = po2
+	    			r.units = "mmHg"
+	    			r.timestamp = Time.now.to_i
+	    			o.results["po2"] = r
+	    		end
+	    		
+	    		if pco2 = get_pco2
+	    			r = Result.new
+	    			r.name = "pco2"
+	    			r.report_name = "Serum Electrolytes"
+	    			r.value = pco2
+	    			r.units = "mmHg"
+	    			r.timestamp = Time.now.to_i
+	    			o.results["pco2"] = r
+	    		end
+	    		
+	    		p.orders << o
+	    		self.headers[-1].patients << p
+	    	end
+	    end
+
+	end
+
+	def process_text_file(full_file_path)
+		k = IO.read(full_file_path)
+		process_electrolytes(k.bytes)
+	end
+
+
+	def receive_data(data)
+      
+
+	    begin
+
+
+	      	self.data_buffer ||= ''
+
+	      	concat = ""
+	      
+	      	byte_arr = data.bytes.to_a
+	      
+	      	self.test_data_bytes ||= []
+	      
+	      	self.data_bytes ||= []
+
+	      	self.test_data_bytes.push(byte_arr)
+
+	      	self.data_bytes.push(byte_arr)
+
+	    
+	      	concat = pre_process_bytes(byte_arr,concat)
+	 
+	      	#puts "concat is:"
+	      
+	      	#puts concat.to_s
+	      
+	      	self.data_buffer << concat
+
+		    ## if the last byte is EOT, then call process text.
+		    ## inside that split by line and process one at a time.
+		    ##process_text(concat)   
+		    #puts "data bytes -1: #{self.data_bytes[-1]}"
+		    #puts "data bytes 0: #{self.data_bytes[0]}"   
+		    #if self.data_bytes[0] == ELECTROLYTE_START
+		    self.process_electrolytes(self.data_bytes) 
+		    #end
+=begin
+	      	if data.bytes.to_a[-1] == 4
+		        puts "GOT EOT --- PROCESSING BUFFER, AND CLEARING."
+		        process_text(self.data_buffer)
+		        #root_path = File.dirname __dir
+		        #puts "root path #{root_path}"
+		        #IO.write((File.join root_path,'test','resources','roche_multi_frame_bytes.txt'),self.test_data_bytes.to_s)
+		        #puts self.test_data_bytes.flatten.to_s
+		        self.data_buffer = ''
+		        unless self.headers.blank?
+		          if self.headers[-1].queries.blank?
+		            #puts "no queries in header so sending ack after getting EOT and processing the buffer"
+		            send_data(ACK)
+		          else
+		            #puts "sending ENQ"
+		            send_data(ENQ)
+		          end
+		        else
+		          puts "sending catch all --------------- ACK --------------"
+		          send_data(ACK)
+		        end
+	    	elsif data.bytes.to_a[0] == 6
+		        puts "GOT ACK --- GENERATING RESPONSE"
+		        unless self.headers.blank?
+		          header_responses = self.headers[-1].build_one_response({machine_name: self.headers[-1].machine_name})
+		          ## if no queries then, we have to send ack.
+		          if header_responses.blank?
+		            #puts "sending ACK since there are no queries in the header"
+		            send_data(ACK)
+		          end
+		          header_responses.each_with_index {|response,key|
+		            message_checksum = checksum(response + terminator + ETX)
+		            final_resp = STX + response + terminator + ETX + message_checksum + "\r" 
+		            final_resp_arr = final_resp.bytes.to_a
+		            final_resp_arr << 10
+		            if (self.headers[-1].response_sent == false)
+		              #puts "sending the  data as follows----------------------------------------------"
+		              #puts "response sent is:"
+		              #puts self.headers[-1].response_sent
+		              #puts final_resp_arr.pack('c*').gsub(/\r/,'\n')
+		              send_data(final_resp_arr.pack('c*')) 
+		              self.headers[-1].response_sent = true if (key == (header_responses.size - 1))
+		            else
+		              #puts "sending EOT"
+		              send_data(EOT)
+		            end
+		          }
+		        else
+		          #puts "NO HEADERS PRESENT --- "
+		        end
+	      	elsif data.bytes.to_a[0] == 255
+	        	puts  " ----------- got 255 data -----------, not sending anything back. "
+	      	else
+		        #unless self.data_buffer.blank?
+		        #  puts self.data_buffer.gsub(/\r/,'\n').to_s
+		        #end
+		        ## send the header 
+		        #puts "--------- SENT ACK -----------"
+		        ## strip non utf 8 characters from it.
+		        self.data_buffer.encode!('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
+		        if self.data_buffer =~ /MSH\|/
+		          #puts " -------------- HEADERS ARE BLANK WITH HL7, sending ack. ------------ "
+		          process_text(self.data_buffer)
+		          self.data_buffer = ''
+		          if self.headers.size > 0
+		            self.headers[-1].commit
+		            send_data(self.headers[-1].generate_ack_success_response)
+		          end
+		        else
+		          #puts " -------------- HEADERS ARE BLANK NOT HL7, sending ack. ------------ "
+		          send_data(ACK)
+		        end
+	      	end
+=end
+	    rescue => e
+	      
+	      #self.headers = []
+	      AstmServer.log("data was: " + self.data_buffer + "error is:" + e.backtrace.to_s)
+	      #send_data(EOT)
+	    end
+
+  	end
+
+
+end