ruby_astm 1.5.3 → 1.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c048fb081850c73e0920aea67af6ba42022e3453
-  data.tar.gz: 447df9ea7aa6eaea6708b120d248af10664f78ae
+SHA256:
+  metadata.gz: 4e23929d7d26dd7c171b839033998571960bf11b5ca4c8668fa3c67a9a08327b
+  data.tar.gz: 603c5c33d330b6bdeb54d7d6d39750cc84f1d428c8dc042c9be278bd72f35644
 SHA512:
-  metadata.gz: 5003ceacee31b6fd72a3e85cb2042bd312bb774ab158215c92fb11e0efcb894a0ab8e446035412fc4c43b193f5ece52140125955fd7f6b2f02880ee957aa63f2
-  data.tar.gz: e944a019d055a5fd14e64660a290ae07806a96793111b1b13a2a9563ed6db97051a9528c6a787a4e0f6741ffd6f887b4315031c26a4b650ba9feb5f1f019f5b6
+  metadata.gz: 5cf677ebb74365e0be42400c7ed573093892343720eba5256a4a2041cf996b2577067e749ee20d4fa7b74dece3682794462273188270319802f1a3523274ab7c
+  data.tar.gz: f4832f9050d30efac849cb7b0bf594716aa468bd0faa66cc53dcbcbdf02090891a0e15e5b18b66a09e9500a43c6fbdd7b3fab6bc2764cf570fae4ab9fc0b672d

data/lib/publisher/pf_download_exception.rb

@@ -0,0 +1,6 @@
+class PfDownloadException < StandardError
+	def initialize(message)
+		super(message)
+		AstmServer.log(message)
+	end
+end

data/lib/publisher/pf_lab_interface.rb

@@ -1,9 +1,60 @@
 require 'fileutils'
-require 'publisher/poller'
+require_relative 'poller'
+require_relative 'pf_download_exception'
 require 'typhoeus'
+require 'resolv-replace'
+
+RestFirebase.class_eval do 
+	
+	attr_accessor :private_key_hash
+
+	def query
+    	{:access_token => auth}
+  	end
+
+  	def get_jwt
+		puts Base64.encode64(JSON.generate(self.private_key_hash))
+		# Get your service account's email address and private key from the JSON key file
+		$service_account_email = self.private_key_hash["client_email"]
+		$private_key = OpenSSL::PKey::RSA.new self.private_key_hash["private_key"]
+		  now_seconds = Time.now.to_i
+		  payload = {:iss => $service_account_email,
+		             :sub => $service_account_email,
+		             :aud => self.private_key_hash["token_uri"],
+		             :iat => now_seconds,
+		             :exp => now_seconds + 1, # Maximum expiration time is one hour
+		             :scope => 'https://www.googleapis.com/auth/userinfo.email https://www.googleapis.com/auth/firebase.database'
+
+		         }
+		  JWT.encode payload, $private_key, "RS256"
+		
+	end
+
+	def generate_access_token
+	  uri = URI.parse(self.private_key_hash["token_uri"])
+	  https = Net::HTTP.new(uri.host, uri.port)
+	  https.use_ssl = true
+	  req = Net::HTTP::Post.new(uri.path)
+	  req['Cache-Control'] = "no-store"
+	  req.set_form_data({
+	    grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+	    assertion: get_jwt
+	  })
+
+	  resp = JSON.parse(https.request(req).body)
+	  resp["access_token"]
+	end
+
+	def generate_auth opts={}
+		generate_access_token
+	end
+ 
+end
 
 class Pf_Lab_Interface < Poller
 
+	include StreamModule
+
 	ORDERS = "orders"
 	ORDERS_SORTED_SET = "orders_sorted_set"
 	BARCODES = "barcodes"
@@ -16,8 +67,8 @@ class Pf_Lab_Interface < Poller
 	## 48 hours, expressed as seconds.
 	DEFAULT_STORAGE_TIME_FOR_ORDERS_IN_SECONDS = 48*3600 
 	## the last request that was made and what it said.
-	POLL_URL_PATH = BASE_URL + "interfaces"
-	PUT_URL_PATH = BASE_URL + "lis_update_orders"
+	POLL_ENDPOINT = "interfaces"
+	PUT_ENDPOINT = "lis_update_orders"
 	LAST_REQUEST = "last_request"
 	FROM_EPOCH = "from_epoch"
 	TO_EPOCH = "to_epoch"
@@ -34,9 +85,16 @@ class Pf_Lab_Interface < Poller
 	ITEMS = "items"
 	CODE = "code"
 	ORDERS_TO_UPDATE_PER_CYCLE = 10
+	PREV_REQUEST_COMPLETED = "prev_request_completed"
 
 	attr_accessor :lis_security_key
 
+	## should include the https://www.xyz.com:3000
+	## defaults to http://localhost:3000
+	attr_accessor :server_url_with_port
+
+	attr_accessor :retry_count
+
 	###################################################################
 	##
 	##
@@ -81,14 +139,20 @@ class Pf_Lab_Interface < Poller
 	###################################################################
 	def remove_order(order_id)
 		order = get_order(order_id)
-		order["reports"].each do |report|
-			report["tests"].each do |test|
-				remove_barcode(test["barcode"])
-				remove_barcode(test["code"])
-			end			
+		puts "order id is:#{order_id} is"
+		unless order.blank?
+			puts "order not blank."
+			order[:reports].each do |report|
+				report[:tests].each do |test|
+					remove_barcode(test[:barcode])
+					remove_barcode(test[:code])
+				end			
+			end
+			$redis.hdel(ORDERS,order_id)
+			$redis.zrem(ORDERS_SORTED_SET,order_id)
+		else
+			puts "order is blank."
 		end
-		$redis.hdel(ORDERS,order[ID])
-		$redis.zrem(ORDERS_SORTED_SET,order[ID])
 	end
 
 	def remove_barcode(barcode)
@@ -132,7 +196,7 @@ class Pf_Lab_Interface < Poller
 
 	## @param[Hash] order : order object, as a hash.
 	def add_order(order)
-		## this whole thing should be done in one transaction
+		at_least_one_item_exists = false
 		order[REPORTS].each do |report|
 			test_machine_codes = report[TESTS].map{|c|
 				$inverted_mappings[c[LIS_CODE]]
@@ -140,6 +204,7 @@ class Pf_Lab_Interface < Poller
 			report[REQUIREMENTS].each do |req|
 				get_priority_category(req)[ITEMS].each do |item|
 					if !item[BARCODE].blank?
+						at_least_one_item_exists = true
 						add_barcode(item[BARCODE],JSON.generate(
 							{
 								:order_id => order[ID],
@@ -147,6 +212,7 @@ class Pf_Lab_Interface < Poller
 							}
 						))
 					elsif !item[CODE].blank?
+						at_least_one_item_exists = true
 						add_barcode(item[CODE],JSON.generate({
 								:order_id => order[ID],
 								:machine_codes => test_machine_codes
@@ -155,14 +221,17 @@ class Pf_Lab_Interface < Poller
 				end
 			end
 		end
-		$redis.hset(ORDERS,order[ID],JSON.generate(order))
-		$redis.zadd(ORDERS_SORTED_SET,Time.now.to_i,order[ID])
+		
+		unless at_least_one_item_exists.blank?
+			$redis.hset(ORDERS,order[ID],JSON.generate(order))
+			$redis.zadd(ORDERS_SORTED_SET,Time.now.to_i,order[ID])
+		end
 	end
 
 	## start work on simple.
 
 	def update_order(order)
-		$redis.hset(ORDERS,order[ID],JSON.generate(order))
+		$redis.hset(ORDERS,order[ID.to_sym],JSON.generate(order))
 	end
 			
 	## @param[Hash] order : the existing order
@@ -171,17 +240,30 @@ class Pf_Lab_Interface < Poller
 	## @working : updates the results from res, into the order at the relevant tests inside the order.
 	## $MAPPINGS -> [MACHINE_CODE => LIS_CODE]
 	## $INVERTED_MAPPINGS -> [LIS_CODE => MACHINE_CODE]
-	def add_test_result(order,res)
+	def add_test_result(order,res,lis_code)
+		#puts "res is:"
+		#puts res.to_s
+
 		order[REPORTS.to_sym].each do |report|
+			#puts "doing report"
 			report[TESTS.to_sym].each_with_index{|t,k|
-				if t[LIS_CODE.to_sym] == $mappings[res[:name]]
+				#puts "doing test"
+				#puts t.to_s
+				
+				puts "teh test lis code to sym is:"
+				puts t[LIS_CODE.to_sym]
+				puts "lis code is: #{lis_code.to_s}"
+				if t[LIS_CODE.to_sym] == lis_code.to_s
+					puts "got equality"
 					t[RESULT_RAW.to_sym] = res[:value]
+					puts "set value"
 				end
 			}
 		end
 	end
 
 	def queue_order_for_update(order)
+		update_order(order)
 		$redis.lpush(UPDATE_QUEUE,order[ID.to_sym])
 	end
 
@@ -199,31 +281,51 @@ class Pf_Lab_Interface < Poller
 	end
 =end
 	def all_hits_downloaded?(last_request)
-		last_request[FROM_EPOCH] == last_request[SIZE]
+		last_request[PREV_REQUEST_COMPLETED].to_s == "true"
 	end
-	
-	def fresh_request_params(from_epoch=nil)
+		
+	## @param[Time] from : time object 
+	## @param[Time] to : time object
+	def fresh_request_params(from,to)
+		#puts "came to make fresh request params, with from epoch: #{from_epoch}"
 		params = {}
-		params[TO_EPOCH] = Time.now.to_i
-		params[FROM_EPOCH] = from_epoch || (params[TO_EPOCH] - DEFAULT_LOOK_BACK_IN_SECONDS)
+		params[TO_EPOCH] = to.to_i
+		params[FROM_EPOCH] = from.to_i
 		params[SKIP] = 0
 		params
 	end
 
-	def build_request
+	## so build request should have a from and a to
+	## what are the defaults ?
+	## @param[Time] from : default (nil)
+	## @param[Time] to : default(nil) 
+	def build_request(from=nil,to=nil)
+		puts "entering build request with from: #{from} and to:#{to}"
+		to ||= Time.now
+		from ||= to - 1.day
 		last_request = get_last_request
 		params = nil
 		if last_request.blank?
-			params = fresh_request_params
+			AstmServer.log("no last request, making fresh request")
+			params = fresh_request_params(from,to)
 		else
 			if all_hits_downloaded?(last_request)
-				params = fresh_request_params(last_request[:to_epoch])
+				AstmServer.log("last request all hits have been downloaded, going for next request.")
+				if last_request[TO_EPOCH].to_i == to.to_i
+					return nil
+				else
+					params = fresh_request_params(last_request[TO_EPOCH],to)
+				end
 			else
+				AstmServer.log("last request all hits not downloaded.")
 				params = last_request
 			end 
 		end
 		params.merge!(lis_security_key: self.lis_security_key)
-		Typhoeus::Request.new(POLL_URL_PATH,params: params)
+		AstmServer.log("reuqest params become: #{params}")
+		AstmServer.log("sleeping")
+		#sleep(10000)
+		Typhoeus::Request.new(self.get_poll_url_path,params: params)
 	end
 
 	## commits the request params to redis.
@@ -237,13 +339,15 @@ class Pf_Lab_Interface < Poller
 		$redis.hset(LAST_REQUEST,SIZE,response_hash[SIZE].to_i)
 		$redis.hset(LAST_REQUEST,FROM_EPOCH,response_hash[FROM_EPOCH].to_i)
 		$redis.hset(LAST_REQUEST,TO_EPOCH,response_hash[TO_EPOCH].to_i)
+		$redis.hset(LAST_REQUEST,PREV_REQUEST_COMPLETED,request_size_completed?(response_hash).to_s)
 	end
 
 	# since we request only a certain set of orders per request
 	# we need to know if the earlier request has been completed
 	# or we still need to rerequest the same time frame again.
 	def request_size_completed?(response_hash)
-		response_hash[SKIP].to_i + response_hash[ORDERS].size >= response_hash[SIZE]
+		#puts response_hash.to_s
+		response_hash[SKIP].to_i + response_hash[ORDERS].size >= response_hash[SIZE].to_i
 	end
 	###################################################################
 	##
@@ -263,36 +367,152 @@ class Pf_Lab_Interface < Poller
 	###################################################################
 	## @param[String] mpg : path to mappings file. Defaults to nil.
 	## @param[String] lis_security_key : the security key for the LIS organization, to be dowloaded from the organizations/show/id, endpoint in the website.
-	def initialize(mpg=nil,lis_security_key)
+	def initialize(mpg=nil,lis_security_key,server_url_with_port,organization_id,private_key_hash)
 	    super(mpg)
+	    self.private_key_hash = private_key_hash
+	    self.event_source = "organizations/" + organization_id
+	    self.on_message_handler_function = "evented_poll_LIS_for_requisition"
 	    self.lis_security_key = lis_security_key
+	    
+	    self.server_url_with_port = (server_url_with_port || BASE_URL)
+	    self.retry_count = 0
+	    ## called from stream module
+	    setup_connection
 	    AstmServer.log("Initialized Lab Interface")
 	end
 
-	def poll_LIS_for_requisition
-		AstmServer.log("Polling LIS at url:#{BASE_URL}")
-		request = build_request
-		request.on_complete do |response|
-		  if response.success?
-		    response_hash = JSON.parse(response.body)
-		    orders = response_hash[ORDERS]
-		    orders.each do |order|
-		    	add_order(order) 
-		    end
-		    commit_request_params_to_redis(response_hash)
-		  elsif response.timed_out?
-		    # aw hell no
-		    # put to astm log.
-		    AstmServer.log("Polling time out")
-		  elsif response.code == 0
-		    # Could not get an http response, something's wrong.
-		    AstmServer.log(response.return_message)
-		  else
-		    # Received a non-successful http response.
-		    AstmServer.log("HTTP request failed: " + response.code.to_s)
-		  end
+	## this is triggered by whatever firebase sends
+	## you put this in the callback, and let me block and see what happens.
+	## we cannot watch two different endpoints ?
+	## or we can ?
+	## on the same endpoint -> will 
+	## so it becomes a merged document.
+	## and both events will fire.
+	## and get triggered.
+	def evented_poll_LIS_for_requisition(data)
+		unless data.blank?
+			
+			data = data["data"].blank? ? data : data["data"]
+
+			unless data["delete_order"].blank?
+				puts "delete order is not blank"
+				unless data["delete_order"]["order_id"].blank?
+					puts "order id is not blank"
+					puts "going to delete the completed order --------------->"
+					delete_completed_order(data["delete_order"]["order_id"])
+				end
+			end
+			unless data["trigger_lis_poll"].blank?
+				unless data["trigger_lis_poll"]["epoch"].blank?
+					new_poll_LIS_for_requisition(data["trigger_lis_poll"]["epoch"].to_i)
+				end
+			end
+		else
+
+		end
+	end
+
+	def delete_completed_order(order_id)
+		remove_order(order_id)
+	end
+
+	def put_delete_order_event(order_id)
+		puts self.connection.put(self.event_source,:order_id => order_id)
+	end
+
+	def test_trigger_lis_poll(epoch=nil)
+		puts self.connection.put(self.event_source + "/trigger_lis_poll", :epoch => epoch)
+	end
+
+	def test_trigger_delete_order(order_id)
+		puts self.connection.put(self.event_source + "/delete_order", :order_id => order_id)
+	end
+
+	def new_poll_LIS_for_requisition(to_epoch=nil)
+		AstmServer.log(to_epoch.to_s)
+		while true
+			orders = []
+			begin
+				Retriable.retriable(on: PfDownloadException) do 
+					self.retry_count+=1
+					AstmServer.log("retrying----->")
+					request = build_request(nil,to_epoch)
+					break if request.blank?
+					request.run
+					response = request.response
+					if response.success?
+						code = response.code
+						time = response.total_time
+						headers = response.headers
+						#AstmServer.log("successfully polled server")
+						response_hash = JSON.parse(response.body)
+					    #AstmServer.log("Pathofast LIS poll response --->")
+					    #AstmServer.log(response_hash.to_s)
+					    orders = response_hash[ORDERS]
+					    orders.each do |order|
+					    	add_order(order) 
+					    end
+					    commit_request_params_to_redis(response_hash)
+					    #puts "are the orders blank: #{orders.blank?}"
+					    #break if orders.blank?
+					elsif response.timed_out?
+						#AstmServer.log("Error polling server with code: #{code}")
+						raise PfDownloadException.new("timeout")
+					elsif response.code == 0
+						#AstmServer.log("Error polling server with code: #{code}")
+						raise PfDownloadException.new("didnt get any http response")
+					else
+						#AstmServer.log("Error polling server with code: #{code}")
+						raise PfDownloadException.new("non 200 response")
+					end
+				end
+			rescue => e
+				puts e.to_s
+				puts "raised exception-----------> breaking."
+				## retryable has raised the errors again.
+				break
+			else
+				## break only if the orders are blank.
+				break if orders.blank?
+			end
+		end
+	end
+
+	## how it deletes the records is that when all the reports in that order are verified, then that order is cleared from all LIS receptive organizations.
+	## that's the only way.
+	## once I'm done with that, its only the barcodes, and then the inventory bits.
+
+	## how it deletes records
+	## so this is called in the form of a while loop.
+	## how it handles the update response.
+	def poll_LIS_for_requisition(to_epoch=nil)
+		AstmServer.log(to_epoch.to_s)
+		while true
+			#puts "came back to true"
+			request = build_request(nil,to_epoch)
+			break if request.blank?
+			request.run
+			response = request.response
+			code = response.code
+			time = response.total_time
+			headers = response.headers
+			if code.to_s != "200"
+				AstmServer.log("Error polling server with code: #{code}")
+				break
+			else
+				AstmServer.log("successfully polled server")
+				response_hash = JSON.parse(response.body)
+			    AstmServer.log("Pathofast LIS poll response --->")
+			    #AstmServer.log(response_hash.to_s)
+			    orders = response_hash[ORDERS]
+			    orders.each do |order|
+			    	add_order(order) 
+			    end
+			    commit_request_params_to_redis(response_hash)
+			    puts "are the orders blank: #{orders.blank?}"
+			    break if orders.blank?
+			end
 		end
-		request.run
 	end
 
 =begin
@@ -388,39 +608,59 @@ data = [
 	def process_update_queue
 		#puts "came to process update queue."
 		order_ids = []
+		#puts $redis.lrange UPDATE_QUEUE, 0, -1
+			
+		## first push that to patient.
+		## first create that order and add that barcode.
+		## for citrate.
+		## then let that get downloaded.
+		## so keep on test going for that.
+		## 
+		## why complicate this so much.
+		## just do a brpop?
+		## 
 		ORDERS_TO_UPDATE_PER_CYCLE.times do |n|
 			order_ids << $redis.rpop(UPDATE_QUEUE)
 		end
 		#puts "order ids popped"
 		#puts order_ids.to_s
+		order_ids.compact!
+		order_ids.uniq!
 		orders = order_ids.map{|c|
 			get_order(c)
 		}.compact
-
+		#puts orders[0].to_s
 		
 		#puts "orders are:"
-		#puts orders.to_s
+		#puts orders.size
+		#exit(1)
 
-		req = Typhoeus::Request.new(PUT_URL_PATH, method: :put, body: {orders: orders}.to_json, params: {lis_security_key: self.lis_security_key}, headers: {Accept: 'application/json', "Content-Type".to_sym => 'application/json'})
+		req = Typhoeus::Request.new(self.get_put_url_path, method: :put, body: {orders: orders}.to_json, params: {lis_security_key: self.lis_security_key}, headers: {Accept: 'application/json', "Content-Type".to_sym => 'application/json'})
 
 
 		req.on_complete do |response|
 			if response.success?
 			    response_body = response.body
 			    orders = JSON.parse(response.body)["orders"]
-			    orders.each do |order|
+			    #puts orders.to_s
+			    orders.values.each do |order|
+			    	#puts order.to_s
 			    	if order["errors"].blank?
 			    	else
 			    		puts "got an error for the order."
 			    		## how many total error attempts to manage.
 			    	end
 			    end
+			    ## here we have to raise.
 			elsif response.timed_out?
 			    AstmServer.log("got a time out")
+			    raise PfUpdateException.new("update order timed out")
 			elsif response.code == 0
 			    AstmServer.log(response.return_message)
+			    raise PfUpdateException.new("update order response code 0")
 			else
 			    AstmServer.log("HTTP request failed: " + response.code.to_s)
+			    raise PfUpdateException.new("update order response code non success: #{response.code}")
 			end
 		end
 
@@ -440,45 +680,142 @@ data = [
 		end
 	end
 
+	ORDERS_KEY = "@orders"
+	FAILED_UPDATES = "failed_updates"
+	PATIENTS_REDIS_LIST = "patients"
+	PROCESSING_REDIS_LIST = "processing"
+
+	## this is only done on startup
+	## okay so what do we 
+	def reattempt_failed_updates
+		$redis.scard(FAILED_UPDATES).times do 
+			if patient_results = $redis.spop(FAILED_UPDATES)
+				patient_results = JSON.parse(patient_results)
+				begin
+					Retriable.retriable(on: PfUpdateException) do 
+						unless update(patient_results)
+							raise PfUpdateException.new("didnt get any http response")
+						end
+					end
+				rescue => e
+					AstmServer.log("reattempted and failed")
+				ensure
+
+				end
+			end
+		end
+	end
+
+	## we can do this.
+	## args can be used to modulate exit behaviours 
+	## @param[Hash] args : hash of arguments
+	def update_LIS(args={})
+		prepare_redis
+		exit_requested = false
+		Kernel.trap( "INT" ) { exit_requested = true }
+		while !exit_requested
+			puts "exit not requested."
+			if patient_results = $redis.brpoplpush(PATIENTS_REDIS_LIST,PROCESSING_REDIS_LIST,0)
+				puts "got patient results."
+				patient_results = JSON.parse(patient_results)
+				puts "patient results are:"
+				puts JSON.pretty_generate(patient_results)
+				begin
+					Retriable.retriable(on: PfUpdateException) do 
+						unless update(patient_results)
+							raise PfUpdateException.new("didnt get any http response")
+						end
+					end
+					exit_requested = !args[:exit_on_success].blank?
+					#puts "exit requested becomes: #{exit_requested}"
+				rescue => e
+					$redis.sadd(FAILED_UPDATES,JSON.generate(patient_results))
+					exit_requested = !args[:exit_on_failure].blank?
+					puts "came to eventual rescue, exit requested is: #{exit_requested}"
+				ensure
+					$redis.lpop("processing")
+				end
+			else
+				puts "no patient results"
+			end
+		end
+	end
+
+
+
 	def update(data)
-		data.each do |result|
-			barcode = result[:id]
-			results = result[:results]
+		puts "data is:"
+		puts JSON.pretty_generate(data)
+		data[ORDERS_KEY].each do |order|
+			puts "order is "
+			puts order
+			barcode = order["id"]
+			results = order["results"]
+			puts "barcode is: #{barcode}, results are : #{results}"
+			results.deep_symbolize_keys!
 			if barcode_hash = get_barcode(barcode)
+				puts "barcode hash is: #{barcode_hash}"
 				if order = get_order(barcode_hash[:order_id])
+					puts "got order"
 					## update the test results, and add the order to the final update hash.
-					puts "order got from barcode is:"
-					puts order
+					#puts "order got from barcode is:"
+					#puts order
 					machine_codes = barcode_hash[:machine_codes]
-					## it has to be registered on this.
-					results.each do |res|
+					puts "machine codes: #{machine_codes}"
+
+					results.keys.each do |lis_code|
+						res = results[lis_code]
+						add_test_result(order,res,lis_code)
+					end
+
+=begin
+					results.values.each do |res|
 						if machine_codes.include? res[:name]
 							## so we need to update to the requisite test inside the order.
-							add_test_result(order,res)	
+							puts "came to add test result"
+							puts res
+							add_test_result(order,res,nil)	
 							## commit to redis
 							## and then 
 						end
 					end
-					puts "came to queue order for update"
+=end
+					#puts "came to queue order for update"
 					queue_order_for_update(order)
 				end
 			else
 				AstmServer.log("the barcode:#{barcode}, does not exist in the barcodes hash")
 				## does not exist.
 			end
-		end 
+		end
 
 		process_update_queue
-		remove_old_orders
+		
 	
 	end
 
+	def get_poll_url_path
+		self.server_url_with_port + POLL_ENDPOINT
+	end
+
+	def get_put_url_path
+		self.server_url_with_port + PUT_ENDPOINT
+	end
+
+	
+	def _start
+		evented_poll_LIS_for_requisition({"trigger_lis_poll" => {"epoch" => Time.now.to_i.to_s}})
+		reattempt_failed_updates
+		update_LIS
+	end
+
+	## the watcher is seperate.
+	## that deals with other things.
+
+	## this method is redundant, and no longer used
+	## the whole thing is now purely evented.
 	def poll
-      	pre_poll_LIS
-      	poll_LIS_for_requisition
-      	update_LIS
-      	post_poll_LIS
   	end
 
-  
+
 end

data/lib/publisher/pf_update_exception.rb

@@ -0,0 +1,6 @@
+class PfUpdateException < StandardError
+	def initialize(message)
+		super(message)
+		AstmServer.log(message)
+	end
+end

data/lib/publisher/poller.rb

@@ -442,7 +442,7 @@ class Poller
   	## name of the sorted set can be defined in the class that inherits from adapter, or will default to "requisitions"
   	## when a query is sent from any laboratory equipment to the local ASTMServer, it will query the redis sorted set, for the test information.
   	## so this poller basically constantly replicates the cloud based test information to the local server.
-	def poll_LIS_for_requisition
+	def poll_LIS_for_requisition(to_epoch=nil)
 
   	end
 

data/lib/publisher/stream_module.rb

@@ -0,0 +1,68 @@
+module StreamModule
+
+	SECRET = ENV["FIREBASE_SECRET"]
+	SITE_URL = ENV["FIREBASE_SITE"]
+
+	attr_accessor :on_message_handler_function
+	attr_accessor :connection
+	attr_accessor :private_key_hash
+	attr_accessor :event_source
+	## the event_stream object
+	attr_accessor :es
+
+	def setup_connection
+		raise "please provide the private key hash, from firebase service account -> create private key " if self.private_key_hash.blank?
+		raise "no event source endpoint provided" if self.event_source.blank?
+		self.connection = RestFirebase.new :site => SITE_URL,
+                     :secret => SECRET, :private_key_hash => private_key_hash, :auth_ttl => 1800
+        self.on_message_handler_function ||= "on_message_handler"
+
+	end
+
+	def watch
+		@reconnect = true
+		self.es = self.connection.event_source(self.event_source)
+		self.es.onopen   { |sock| p sock } # Called when connecte
+		self.es.onmessage{ |event, data, sock| 
+			#puts "event: #{event}"
+			send(self.on_message_handler_function,data)
+		}
+		self.es.onerror  { |error, sock| p error } # Called 4
+		self.es.onreconnect{ |error, sock| p error; @reconnect }
+		self.es.start
+		rd, wr = IO.pipe
+		%w[INT TERM].each do |sig|
+		  Signal.trap(sig) do
+		    wr.puts # unblock the main thread
+		  end
+		end
+		rd.gets # block main thread until INT or TERM received
+		@reconnect = false
+		self.es.close
+		self.es.wait # shutdown cleanly
+	end
+
+	def watch_limited(seconds)
+		
+		@reconnect = true
+		self.es = self.connection.event_source(self.event_source)
+		self.es.onopen   { |sock| p sock } # Called when connecte
+		self.es.onmessage{ |event, data, sock| 
+			send(self.on_message_handler_function,data)
+		}
+		self.es.onerror  { |error, sock| p error } # Called 4
+		self.es.onreconnect{ |error, sock| p error; @reconnect }
+		self.es.start
+		sleep(seconds)
+		@reconnect = false
+		self.es.close
+		self.es.wait # shutdown cleanly
+		
+	end
+
+	def on_message_handler(data)
+		#puts "got some data"
+		#puts data
+	end
+
+end

data/lib/ruby_astm.rb

@@ -1,4 +1,5 @@
 require_relative "ruby_astm/usb_module"
+require_relative "ruby_astm/custom/esr"
 require_relative "ruby_astm/query"
 require_relative "ruby_astm/frame"
 require_relative "ruby_astm/header"
@@ -8,6 +9,9 @@ require_relative "ruby_astm/order"
 require_relative "ruby_astm/patient"
 require_relative "ruby_astm/result"
 require_relative "ruby_astm/astm_server"
+require_relative "publisher/pf_download_exception"
+require_relative "publisher/pf_update_exception"
+require_relative "publisher/stream_module"
 require_relative "publisher/adapter"
 require_relative "publisher/google_lab_interface"
 require_relative "publisher/poller"
@@ -19,4 +23,6 @@ require_relative "ruby_astm/HL7/hl7_order"
 require_relative "ruby_astm/HL7/hl7_observation"
 require_relative "ruby_astm/custom/siemens_abg_electrolyte_module"
 require_relative "ruby_astm/custom/siemens_abg_electrolyte_server"
+require_relative "ruby_astm/custom/siemens_dimension_exl_module"
+require_relative "ruby_astm/custom/siemens_dimension_exl_server"
 

data/lib/ruby_astm/custom/esr.rb

@@ -0,0 +1,3 @@
+class Esr
+	include UsbModule
+end

data/lib/ruby_astm/custom/siemens_abg_electrolyte_module.rb

@@ -207,7 +207,7 @@ module SiemensAbgElectrolyteModule
 	    		unless o.results.blank?
 	    			p.orders << o
 	    			$redis.hset(SIEMENS_ELEC_ABG_RESULTS_HASH,patient_id,JSON.generate(o.results_values_hash))
-	    			self.headers[-1].patients << p
+	    			self.headers[-1].patients = [p]
 	    		end
 
 	    	end

data/lib/ruby_astm/custom/siemens_dimension_exl_module.rb

@@ -0,0 +1,130 @@
+module SiemensDimensionExlModule
+
+	include LabInterface
+
+	def self.included base
+    	base.extend ClassMethods
+  	end
+
+  	FS = "\x1C"
+
+  	def pre_process_bytes(byte_arr,concat)
+
+  	  puts "this is the overridden method"
+      puts byte_arr.to_s
+
+      indices_to_delete = is_mid_frame_end?(byte_arr)
+      #puts "indices to delete"
+      #puts indices_to_delete.to_s
+
+      if self.mid_frame_end_detected == true
+        #puts "deletected mid fram is true, so deleting first byte before delete"
+        #puts byte_arr.to_s
+        byte_arr = byte_arr[1..-1]
+        #puts "after deleteing"
+        #puts byte_arr.to_s
+        self.mid_frame_end_detected = false
+      end
+
+      unless indices_to_delete.blank?
+        if byte_arr[(indices_to_delete[-1] + 1)]
+          #puts "before deleting frame number "
+          #puts byte_arr.to_s
+          byte_arr.delete_at((indices_to_delete[-1] + 1))
+          #puts "after deleting"
+          #puts byte_arr.to_s
+        else
+          self.mid_frame_end_detected = true
+        end
+      end
+      #puts "byte arr before reject"
+      byte_arr = byte_arr.reject.with_index{|c,i|  indices_to_delete.include? i}
+      
+
+      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
+
+      concat
+
+  	end
+
+  	def message_ends?
+  		x = self.data_bytes.flatten[-1] == 3
+  		if x == true
+  			puts "message ends #{self.data_bytes.flatten}"
+  			self.data_bytes = []
+  		end
+  		x
+  	end
+
+  	def enq?
+  		self.data_bytes.flatten[-1] == 5
+  	end
+
+  	def acknowledge
+  		resp = ACK
+  		send_data(ACK)
+  	end
+
+  	def no_request
+  		resp = STX + "N" + FS + "6A" + ETX + "\n" 
+  		send_data(resp.bytes.to_a.pack('c*'))
+  	end
+
+
+
+	def receive_data(data)
+      
+
+	    begin
+
+
+	      self.data_buffer ||= ''
+
+	      #puts "incoming data bytes."
+
+	      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)
+	      
+	      self.data_buffer << concat
+
+
+	      if message_ends?
+	      	acknowledge
+	      	no_request
+	      end
+
+	    
+	    rescue => e
+	      
+	      #self.headers = []
+	      AstmServer.log("data was: " + self.data_buffer + "error is:" + e.backtrace.to_s)
+	      #send_data(EOT)
+	    end
+
+  	end
+
+end

data/lib/ruby_astm/custom/siemens_dimension_exl_server.rb

@@ -0,0 +1,46 @@
+class SiemensDimensionExlServer
+
+	include SiemensDimensionExlModule
+
+	## DEFAULT SERIAL PORT : /dev/ttyS0
+	## DEFAULT USB PORT : /dev/ttyUSB0
+	## @param[Array] ethernet_connections : each element is expected to be a hash, with keys for :server_ip, :server_port.
+	## @param[Array] serial_connections : each element is expected to be a hash with port_address, baud_rate, and parity
+	#def initialize(server_ip=nil,server_port=nil,mpg=nil,respond_to_queries=false,serial_port='/dev/ttyS0',usb_port='/dev/ttyUSB0',serial_baud=9600,serial_parity=8,usb_baud=19200,usb_parity=8)
+	def initialize(ethernet_connections,serial_connections,mpg=nil,respond_to_queries=nil)
+		$redis = Redis.new
+		self.class.log("Initializing AstmServer")
+		self.ethernet_connections = ethernet_connections
+		self.serial_connections = serial_connections
+		self.server_ip = server_ip || "127.0.0.1"
+		self.server_port = server_port || 3000
+		self.respond_to_queries = respond_to_queries
+		self.serial_port = serial_port
+		self.serial_baud = serial_baud
+		self.serial_parity = serial_parity
+		self.usb_port = usb_port
+		self.usb_baud = usb_baud
+		self.usb_parity = usb_parity
+		$mappings = JSON.parse(IO.read(mpg || self.class.default_mappings))
+	end
+
+	def start_server
+		EventMachine.run {
+			self.ethernet_connections.each do |econn|
+				raise "please provide a valid ethernet configuration with ip address" unless econn[:server_ip]
+				raise "please provide a valid ethernet configuration with port" unless econn[:server_port]
+				EventMachine::start_server econn[:server_ip], econn[:server_port], SiemensDimensionExlModule
+				self.class.log("Running ETHERNET  with configuration #{econn}")
+			end
+			self.serial_connections.each do |sconn|
+				raise "please provide a valid serial configuration with port address" unless sconn[:port_address]
+				raise "please provide a valid serial configuration with baud rate" unless sconn[:baud_rate]
+				raise "please provide a valid serial configuration with parity" unless sconn[:parity]
+				EventMachine.open_serial(sconn[:port_address], sconn[:baud_rate], sconn[:parity],SiemensDimensionExlModule)
+				puts "RUNNING SERIAL port with configuration : #{sconn}"
+			end
+
+		}
+	end	
+
+end

data/lib/ruby_astm/lab_interface.rb

@@ -60,7 +60,7 @@ module LabInterface
   #######################################################
   module ClassMethods
     def log(message)
-      puts "" + message
+      puts message
       $redis.zadd("ruby_astm_log",Time.now.to_i,message)
     end
 
@@ -267,8 +267,8 @@ module LabInterface
         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','d10_error.txt'),self.test_data_bytes.to_s)
+        #puts "root path #{root_path}"
+        #IO.write((File.join root_path,'../test','resources','d10_error.txt'),self.test_data_bytes.to_s)
         #puts self.test_data_bytes.flatten.to_s
         self.data_buffer = ''
         unless self.headers.blank?

data/lib/ruby_astm/usb_module.rb

@@ -34,16 +34,6 @@ module UsbModule
 
 		self.usb_response_bytes[-3] == 13
 	end	
-
-	def add_result_by_count?(barcode,result)
-		begin
-
-			
-		rescue => e
-			puts e.to_s
-			return true
-		end
-	end
 	## total times repeated, we can have that as max 3 times.
 	## so after that it wont add.
 	## so we keep a sorted set with the barcode and the count
@@ -76,14 +66,20 @@ module UsbModule
 	end
 
 	def parse_usb_response(string_data)
+		#puts "string data is:"
+		#puts string_data.to_s
 		string_data.bytes.to_a.each do |byte|
 			self.usb_response_bytes.push(byte)
 		end
-		#puts "self usb response bytes:"
-		#puts self.usb_response_bytes.to_s
+		parse_bytes
+		#puts self.usb_response_bytes.pack('c*')
+	end
+
+	def parse_bytes(bytes=nil)
+		self.usb_response_bytes ||= bytes
 		if interpret?
 			#puts "interpret"
-			barcodes = []
+			existing_barcodes = []
 			if kk = self.usb_response_bytes[13..-4]
 				## its going fresh -> old
 				## so if the barcode has already come
@@ -108,7 +104,7 @@ module UsbModule
 								order.id = bar_code
 								order.results = []
 								order.results << result
-								#puts "barcode: #{bar_code}, result : #{result.value}"
+								puts "barcode: #{bar_code}, result : #{result.value}"
 								patient.orders << order
 								if add_result?(bar_code,result.value,existing_barcodes)
 									#puts patient.to_json
@@ -125,7 +121,6 @@ module UsbModule
 		else
 			#puts "dont interpret"		
 		end
-
 	end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_astm
 version: !ruby/object:Gem::Version
-  version: 1.5.3
+  version: 1.5.4
 platform: ruby
 authors:
 - Bhargav Raut
@@ -164,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: retriable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
 description: This gem provides a server that can handle communication from medical
   instruments that send/receive information on the ASTM protocol.
 email: bhargav.r.raut@gmail.com
@@ -174,17 +188,23 @@ files:
 - lib/mappings.json
 - lib/publisher/adapter.rb
 - lib/publisher/google_lab_interface.rb
+- lib/publisher/pf_download_exception.rb
 - lib/publisher/pf_lab_interface.rb
+- lib/publisher/pf_update_exception.rb
 - lib/publisher/poller.rb
 - lib/publisher/real_time_db.rb
+- lib/publisher/stream_module.rb
 - lib/ruby_astm.rb
 - lib/ruby_astm/HL7/hl7_header.rb
 - lib/ruby_astm/HL7/hl7_observation.rb
 - lib/ruby_astm/HL7/hl7_order.rb
 - lib/ruby_astm/HL7/hl7_patient.rb
 - lib/ruby_astm/astm_server.rb
+- lib/ruby_astm/custom/esr.rb
 - lib/ruby_astm/custom/siemens_abg_electrolyte_module.rb
 - lib/ruby_astm/custom/siemens_abg_electrolyte_server.rb
+- lib/ruby_astm/custom/siemens_dimension_exl_module.rb
+- lib/ruby_astm/custom/siemens_dimension_exl_server.rb
 - lib/ruby_astm/frame.rb
 - lib/ruby_astm/header.rb
 - lib/ruby_astm/lab_interface.rb
@@ -214,7 +234,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14.4
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
 summary: A Ruby gem to interface with Medical instruments that work on the ASTM protocol