ruby_astm 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9583ca630b54cc83f9bffdb91b5094b7cc01145b
+  data.tar.gz: 7695f9fe20e298629f5eb5af67d8ea8f5c345616
+SHA512:
+  metadata.gz: ec25812e078a96cf28ecd54ed6cf2325ef84ce46e15087d49b55341ca9a9be8542e5848bc493933dd33fd856c2c5a958a9855e0ca7158d4cd579a439d604760d
+  data.tar.gz: 210f8f1ff0d433b688af770419592f4966dedac076499a0913193cd948ee71f7a545b185e007206ced54c3bb5642f780d5f53ead36c06e8575727cfbd0d1e631

data/lib/publisher/adapter.rb

@@ -0,0 +1,5 @@
+class Adapter
+
+
+
+end

data/lib/publisher/credentials.json

@@ -0,0 +1 @@
+{"installed":{"client_id":"555057029489-sel4u1t4tnv3qicdhsssp9phn3r8tvrj.apps.googleusercontent.com","project_id":"project-id-4907840994004404941","auth_uri":"https://accounts.google.com/o/oauth2/auth","token_uri":"https://www.googleapis.com/oauth2/v3/token","auth_provider_x509_cert_url":"https://www.googleapis.com/oauth2/v1/certs","client_secret":"L6DjrWGteAcwJwh7YdfzYwDp","redirect_uris":["urn:ietf:wg:oauth:2.0:oob","http://localhost"]}}

data/lib/publisher/google_lab_interface.rb

@@ -0,0 +1,135 @@
+require 'google/apis/script_v1'
+require 'googleauth'
+require 'googleauth/stores/file_token_store'
+require 'fileutils'
+require 'publisher/poller'
+
+class Google_Lab_Interface < Poller
+
+
+  OOB_URI = 'urn:ietf:wg:oauth:2.0:oob'.freeze
+  APPLICATION_NAME = 'Google Apps Script API Ruby Quickstart'.freeze
+  CREDENTIALS_PATH = 'credentials.json'.freeze
+  # The file token.yaml stores the user's access and refresh tokens, and is
+  # created automatically when the authorization flow completes for the first
+  # time.
+  TOKEN_PATH = 'token.yaml'.freeze
+  SCOPE = 'https://www.googleapis.com/auth/script.projects'.freeze
+
+  SCOPES = ["https://www.googleapis.com/auth/documents","https://www.googleapis.com/auth/drive","https://www.googleapis.com/auth/script.projects","https://www.googleapis.com/auth/spreadsheets"]
+
+  $service = nil
+  SCRIPT_ID = "M7JDg7zmo0Xldo4RTWFGCsI2yotVzKYhk"
+
+  
+  ##
+  # Ensure valid credentials, either by restoring from the saved credentials
+  # files or intitiating an OAuth2 authorization. If authorization is required,
+  # the user's default browser will be launched to approve the request.
+  #
+  # @return [Google::Auth::UserRefreshCredentials] OAuth2 credentials
+  def authorize
+
+    client_id = Google::Auth::ClientId.from_file(root_path + "/publisher/" + CREDENTIALS_PATH)
+    token_store = Google::Auth::Stores::FileTokenStore.new(file: (root_path + "/publisher/" + TOKEN_PATH))
+    authorizer = Google::Auth::UserAuthorizer.new(client_id, SCOPES, token_store)
+    user_id = 'default'
+    credentials = authorizer.get_credentials(user_id)
+    if credentials.nil?
+      url = authorizer.get_authorization_url(base_url: OOB_URI)
+      puts 'Open the following URL in the browser and enter the ' \
+           "resulting code after authorization:\n" + url
+      code = gets
+      credentials = authorizer.get_and_store_credentials_from_code(
+        user_id: user_id, code: code, base_url: OOB_URI
+      )
+    end
+    credentials
+  end
+
+  ## @param[String] mpg : path to mappings file. Defaults to nil.
+  def initialize(mpg=nil)
+    AstmServer.log("Initialized Google Lab Interface")
+    super(mpg)
+    $service = Google::Apis::ScriptV1::ScriptService.new
+    $service.client_options.application_name = APPLICATION_NAME
+    $service.authorization = authorize
+  end
+
+
+  def poll_LIS_for_requisition
+    
+    pre_poll_LIS
+     
+    AstmServer.log("polling LIS for new requisitions")
+    
+    epoch = (Time.now - 5.days).to_i*1000
+    
+    pp = {
+      :input => JSON.generate([epoch])
+    }
+
+    request = Google::Apis::ScriptV1::ExecutionRequest.new(
+      function: 'get_latest_test_information',
+      parameters: pp
+    )
+
+    begin 
+      resp = $service.run_script(SCRIPT_ID, request)
+      if resp.error
+        AstmServer.log("Response Error polling LIS for requisitions: #{resp.error.message}: #{resp.error.code}")
+      else
+        process_LIS_response(resp.response["result"])
+        AstmServer.log("Successfully polled lis for requisitions: #{resp.response}")
+      end
+    rescue => e
+      AstmServer.log("Rescue Error polling LIS for requisitions: #{e.to_s}")
+      AstmServer.log("Error backtrace")
+      AstmServer.log(e.backtrace.to_s)
+    ensure
+      post_poll_LIS
+    end
+
+  end
+
+
+  # method overriden from adapter.
+  # data should be an array of objects.
+  # see adapter for the recommended structure.
+  def update(data)
+
+    orders = JSON.generate(data)
+
+    pp = {
+      :input => orders
+    }
+
+    request = Google::Apis::ScriptV1::ExecutionRequest.new(
+      function: 'update_report',
+      parameters: pp
+    )
+
+    begin
+      AstmServer.log("updating following results to LIS")
+      AstmServer.log(request.parameters.to_s)
+      resp = $service.run_script(SCRIPT_ID, request)
+      if resp.error
+        AstmServer.log("Error updating results to LIS, message follows")
+        AstmServer.log("error: #{resp.error.message} : code: #{resp.error.code}")
+        #puts "there was an error."
+      else
+        AstmServer.log("Updating results to LIS successfull")
+      end
+    rescue => e
+      AstmServer.log("Error updating results to LIS, backtrace follows")
+      AstmServer.log(e.backtrace.to_s)
+    end
+
+  end
+
+
+  def poll
+    super
+  end
+
+end

data/lib/publisher/poller.rb

@@ -0,0 +1,339 @@
+require 'rufus-scheduler'
+require 'time'
+require 'redis'
+
+class Poller
+	#############################################################################3
+	##
+	##
+	## require the file that implements the Adapter class.
+	##
+	##
+	##############################################################################
+	EDTA = "EDTA"
+  	SERUM = "SERUM"
+  	PLASMA = "PLASMA"
+  	FLUORIDE = "FLUORIDE"
+  	ESR = "ESR"
+  	URINE = "URINE"
+  	REQUISITIONS_SORTED_SET = "requisitions_sorted_set"
+  	REQUISITIONS_HASH = "requisitions_hash"
+	POLL_STATUS_KEY = "ruby_astm_lis_poller"
+	LAST_REQUEST_AT = "last_request_at"
+	LAST_REQUEST_STATUS = "last_request_status"
+	RUNNING = "running"
+	COMPLETED = "completed"
+
+	def initialize(mpg=nil)
+		$redis = Redis.new
+		## this mapping is from MACHINE CODE AS THE KEY
+	    $mappings = JSON.parse(IO.read(mpg || ("mappings.json")))
+	    ## INVERTING THE MAPPINGS, GIVES US THE LIS CODE AS THE KEY.
+	    $inverted_mappings = Hash[$mappings.values.map{|c| c = c["LIS_CODE"]}.zip($mappings.keys)]
+	end
+
+	def root_path
+    	File.dirname __dir__
+  	end
+
+
+	def prepare_redis
+		if ($redis.exists "processing") == 0
+			$redis.lpush("processing",JSON.generate([]))
+		end
+	end
+
+	def pre_poll_LIS
+	    previous_requisition_request_status = nil
+	    
+	    if previous_requisition_request_status = $redis.get(POLL_STATUS_KEY)
+
+	      last_request_at = previous_requisition_request_status[LAST_REQUEST_AT]
+	      
+	      last_request_status = previous_requisition_request_status[LAST_REQUEST_STATUS]  
+	    end
+
+	    running_time = Time.now.to_i
+
+	    $redis.watch(POLL_STATUS_KEY) do
+
+	      if $redis.get(POLL_STATUS_KEY) == previous_requisition_request_status
+	        if ((last_request_status != RUNNING) || ((Time.now.to_i - last_request_at) > 600))
+	          $redis.multi do |multi|
+	            multi.set(POLL_STATUS_KEY, JSON.generate({LAST_REQUEST_STATUS => RUNNING, LAST_REQUEST_AT => running_time}))
+	          end
+	          AstmServer.log("pre poll lis status set to running")
+	        end
+	      else
+	      	AstmServer.log("pre poll lis status check interrupted by another client, so exiting here")
+	        $redis.unwatch
+	        return
+	      end
+	    end
+	end
+
+	## uses redis CAS to ensure that two requests don't overlap.
+	## will update to the requisitions hash the specimen id -> and the 
+	## now lets test this.
+	## how to stub it out ?
+	## first we call it direct.
+	def post_poll_LIS
+    
+	    requisition_status = JSON.parse($redis.get(POLL_STATUS_KEY))
+	    
+	    if (requisition_status[LAST_REQUEST_STATUS] == RUNNING)
+
+	      $redis.watch(POLL_STATUS_KEY) do
+
+	        if $redis.get(POLL_STATUS_KEY) == JSON.generate(requisition_status)
+
+	          $redis.multi do |multi|
+	            multi.set(POLL_STATUS_KEY,JSON.generate({LAST_REQUEST_STATUS => COMPLETED, LAST_REQUEST_AT => requisition_status[LAST_REQUEST_AT]}))
+	          end
+	          AstmServer.log("post poll LIS status set to completed")
+	        else
+	          AstmServer.log("post poll LIS was was interrupted by another client , so exited this thread")
+	          $redis.unwatch(POLL_STATUS_KEY)
+	          return
+	        end
+
+	      end
+
+	    else
+	    	AstmServer.log("post poll LIS was not in running state")
+	    end
+
+  	end	
+
+  	def build_tests_hash(record)
+	    tests_hash = {}
+
+	    ## key -> TUBE_NAME : eg: EDTA
+	    ## value -> its barcode id.
+	    tube_ids = {}
+	    ## assign.
+	    ## lavender -> index 28
+	    ## serum -> index 29
+	    ## plasm -> index 30
+	    ## fluoride -> index 31
+	    ## urine -> index 32
+	    ## esr -> index 33
+	    unless record[28].blank?
+	      tube_ids[EDTA] = record[28]
+	      tests_hash[EDTA + ":" + record[28]] = []
+	    end
+
+	    unless record[29].blank?
+	      tube_ids[SERUM] = record[29]
+	      tests_hash[SERUM + ":" + record[29]] = []
+	    end
+
+	    unless record[30].blank?
+	      tube_ids[PLASMA] = record[30]
+	      tests_hash[PLASMA + ":" + record[30]] = []
+	    end
+
+	    unless record[31].blank?
+	      tube_ids[FLUORIDE] = record[31]
+	      tests_hash[FLUORIDE + ":" + record[31]] = []
+	    end
+
+	    unless record[32].blank?
+	      tube_ids[URINE] = record[32]
+	      tests_hash[URINE + ":" + record[32]] = []
+	    end
+
+	    unless record[33].blank?
+	      tube_ids[ESR] = record[33]
+	      tests_hash[ESR + ":" + record[33]] = []
+	    end
+
+
+	    tests = record[8].split(",")
+	    tests.each do |test|
+	      ## use the inverted mappings to 
+	      if machine_code = $inverted_mappings[test]
+	        ## now get its tube type
+	        ## mappings have to match the tubes defined in this file.
+	        tube = $mappings[machine_code]["TUBE"]
+	        ## now find the tests_hash which has this tube.
+	        ## and the machine code to its array.
+	        ## so how to find this.
+	        tube_key = tests_hash.keys.select{|c| c=~/#{tube}/ }[0] 
+	        tests_hash[tube_key] << machine_code   
+	      else
+	        AstmServer.log("ERROR: Test: #{test} does not have an LIS code")
+	      end 
+	    end
+	    AstmServer.log("tests hash generated")
+	    AstmServer.log(JSON.generate(tests_hash))
+	    tests_hash
+	end
+
+	## @param[Integer] epoch : the epoch at which these tests were requested.
+	## @param[Hash] tests : {"EDTA:barcode" => [MCV,MCH,MCHC...]}
+	def merge_with_requisitions_hash(epoch,tests)
+	    ## so we basically now add this to the epoch ?
+	    ## or a sorted set ?
+	    ## key -> TUBE:specimen_id
+	    ## value -> array of tests as json
+	    ## score -> time.
+	    $redis.multi do |multi|
+	      $redis.zadd REQUISITIONS_SORTED_SET, epoch, JSON.generate(tests)
+	      tests.keys.each do |tube_barcode|
+	        $redis.hset REQUISITIONS_HASH, tube_barcode, JSON.generate(tests[tube_barcode])
+	      end  
+	    end
+	end
+
+
+  	## @param[String] json_response : contains the response from the LIS
+  	## it should be the jsonified version of a hash that is structured as follows: 
+=begin
+  	{
+    	"epoch" => [
+      	[index_8 : list_of_LIS_TEST_CODES_seperated_by_commas, index 28 => lavender, index 29 => serum, index 30 => plasma, index 31 => fluoride, index 32 => urine, index 33 => esr]
+  	}
+=end
+  	## @return[nil]
+  	def process_LIS_response(json_response)
+	    lab_results = JSON.parse(json_response)
+	    AstmServer.log("requisitions downloaded from LIS")
+	    AstmServer.log(JSON.generate(lab_results))
+	    lab_results.keys.each do |epoch|
+	      merge_with_requisitions_hash(epoch,build_tests_hash(lab_results[epoch][0]))
+	    end
+  	end
+
+  	## override to define how the data is updated.
+  	def update(data)
+  	
+  	end
+
+	##@param[Array] data : array of objects.
+	##@return[Boolean] true/false : depending on whether it was successfully updated or not.
+	## recommended structure for data.
+=begin
+    data = [
+      {
+        :id => "ARUBA",
+        :results => [
+          {
+            :name => "TLCparam",
+            :value => 10
+          },
+          {
+            :name => "Nparam",
+            :value => 23
+          },
+          {
+            :name => "ANCparam",
+            :value => 25
+          },
+          {
+            :name => "Lparam",
+            :value => 10
+          },
+          {
+            :name => "ALCparam",
+            :value => 44
+          },
+          {
+            :name => "Mparam",
+            :value => 55
+          },
+          {
+            :name => "AMCparam",
+            :value => 22
+          },
+          {
+            :name => "Eparam",
+            :value => 222
+          },
+          {
+            :name => "AECparam",
+            :value => 21
+          },
+          {
+            :name => "BASOparam",
+            :value => 222
+          },
+          {
+            :name => "ABCparam",
+            :value => 300
+          },
+          {
+            :name => "RBCparam",
+            :value => 2.22
+          },
+          {
+            :name => "HBparam",
+            :value => 19
+          },
+          {
+            :name => "HCTparam",
+            :value => 22
+          },
+          {
+            :name => "MCVparam",
+            :value => 222
+          },
+          {
+            :name => "MCHparam",
+            :value => 21
+          },
+          {
+            :name => "MCHCparam",
+            :value => 10
+          },
+          {
+            :name => "MCVparam",
+            :value => 222
+          },
+          {
+            :name => "RDWCVparam",
+            :value => 12
+          },
+          {
+            :name => "PCparam",
+            :value => 1.22322
+          }
+        ]
+      }
+    ]
+=end
+  	## pretty simple, if the value is not already there it will be updated, otherwise it won't be.
+	def update_LIS
+		prepare_redis
+		patients_to_process = $redis.llen("patients") > 0
+		while patients_to_process == true
+			if patient_results = $redis.rpoplpush("patients","processing")
+				patient_results = JSON.parse(patient_results)
+				update(patient_results)
+				patients_to_process = $redis.llen("patients") > 0
+			else
+				patients_to_process = false
+			end
+		end
+	end
+
+	## this method should be overriden.
+  	## will poll the lis, and store locally, in a redis sorted set the following:
+  	## key => specimen_id
+  	## value => tests designated for that specimen.
+  	## score => time of requisition of that specimen.
+  	## 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
+
+  	end
+
+  	def poll
+  		pre_poll_LIS
+  		poll_LIS_for_requisition
+  		update_LIS
+  		post_poll_LIS
+  	end
+
+end

data/lib/publisher/token.yaml

@@ -0,0 +1,2 @@
+---
+default: '{"client_id":"555057029489-sel4u1t4tnv3qicdhsssp9phn3r8tvrj.apps.googleusercontent.com","access_token":"ya29.GlxjBtK4IVi08eyrCDI6WaEgkZnjhNK7wvJIw8vd7PzzfLiMfuphIlZFk4t8UUMSROqQIsBw7RQXTifEXE2FDjvjdLoeEr-sDj1xHVifr53_V-ZcJlbOXBCUexjxTQ","refresh_token":"1/SPwjKXMExoiU43WCJxPJYPd2cj0Hhb1Ms2ONe3KgIIs","scope":["https://www.googleapis.com/auth/documents","https://www.googleapis.com/auth/drive","https://www.googleapis.com/auth/script.projects","https://www.googleapis.com/auth/spreadsheets"],"expiration_time_millis":1543480295000}'

data/lib/ruby_astm/astm_server.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'eventmachine'
+require 'em-rubyserial'
+require "active_support/all"
+require "json"
+require "redis"
+
+class AstmServer
+
+	include LabInterface
+
+	def self.log(message)
+		puts "" + message
+    	$redis.zadd("ruby_astm_log",Time.now.to_i,message)
+  	end
+
+	$ENQ = "[5]"
+	$start_text = "[2]"
+	$end_text = "[3]"
+	$record_end = "[13]"
+	$frame_end = "[10]"
+
+	def initialize(server_ip,server_port,mpg,respond_to_queries=false)
+		$redis = Redis.new
+		AstmServer.log("Initializing AstmServer")
+		self.server_ip = server_ip || "192.168.1.14"
+		self.server_port = server_port || 3000
+		self.respond_to_queries = respond_to_queries
+		$mappings = JSON.parse(IO.read(mpg || ("mappings.json")))
+	end
+
+	def start_server
+		EventMachine.run {
+			self.ethernet_server = EventMachine::start_server self.server_ip, self.server_port, LabInterface
+			AstmServer.log("Running ETHERNET SERVER on #{server_port}")
+			#serial = EventMachine.open_serial('/dev/ttyUSB0', 9600, 8)
+			#serial.on_data do |data|
+			#  	puts "got some data"
+			#  	puts data.to_s
+			#    serial.send_data("\X06")
+			#end
+		}
+	end	
+
+	## now we need to run the server and poller.
+	## thats what we need.
+	
+
+end

data/lib/ruby_astm/frame.rb

@@ -0,0 +1,25 @@
+class Frame
+  
+  attr_accessor :machine_model
+  attr_accessor :astm_version
+  attr_accessor :records
+
+  def initalize(args)
+  	self.records = []
+  	super(args)
+  end
+
+  def self.is_start_frame?(l)
+ 	line_without_control_char = l[1..-1]
+ 	return line_without_control_char =~ /\d+H/
+  #k = l[0].bytes
+	#if k.to_s == "[5]"
+	#	puts "ENQ"
+	#end
+  end
+
+  def self.is_end_frame?(line)
+  	
+  end
+
+end

data/lib/ruby_astm/header.rb

@@ -0,0 +1,47 @@
+class Header
+	attr_accessor :machine_name
+	attr_accessor :patients
+	attr_accessor :queries
+	attr_accessor :response_sent
+
+	def initialize(args)
+		if args[:line]
+			line = args[:line]
+			unless line.fields[4].empty?
+				fields = line.fields[4].split(/\^/)
+				self.machine_name = fields[0].strip
+			end
+		else
+			super
+		end
+		self.patients = []
+		self.queries = []
+		self.response_sent = false
+	end
+
+	## pushes each patient into a redis list called "patients"
+	def commit
+		self.patients.map{|patient| $redis.lpush("patients",patient.to_json)}
+		#puts JSON.pretty_generate(JSON.parse(self.to_json))
+	end
+
+	## used to respond to queries.
+	## @return[String] response_to_query : response to the header query.
+	def build_responses
+		responses = self.queries.map {|query|
+			header_response = "1H|\`^&||||||||||P|E 1394-97|#{Time.now.strftime("%Y%m%d%H%M%S")}\r"
+			query.response = header_response + query.build_response
+			query.response
+		}
+		responses
+	end
+
+	def to_json
+        hash = {}
+        self.instance_variables.each do |x|
+            hash[x] = self.instance_variable_get x
+        end
+        return hash.to_json
+    end
+
+end

data/lib/ruby_astm/lab_interface.rb

@@ -0,0 +1,160 @@
+require "active_support/all"
+
+module LabInterface
+
+	ACK = "\x06"
+  ENQ = "\x05"
+  STX = "\x02"
+  LF = "\x10"
+  CR = "\x13"
+  ETX = "\x03"
+  EOT = "\x04"
+
+  mattr_accessor :headers
+  mattr_accessor :ethernet_server
+  mattr_accessor :server_ip
+  mattr_accessor :server_port
+  mattr_accessor :mapping
+  mattr_accessor :respond_to_queries
+  
+
+  ## returns the root directory of the gem.
+  def root
+      File.dirname __dir__
+  end
+
+  ## can process a file which contains ASTM output.
+  ## this method is added so that you can load previously generated ASTM output into your database
+  ## it also simplifies testing.
+  def process_text_file(full_file_path)
+    #full_file_path ||= File.join root,'../test','resources','sysmex_550_sample.txt'
+    IO.read(full_file_path).each_line do |line|
+      process_text(line)
+    end
+  end
+
+  def terminator
+    "L|1|N\r"
+  end
+
+  def checksum(input)
+    strString = input
+    checksum = strString.sum
+    b = checksum.to_s(16)
+    strCksm = b[-2..-1]
+    if strCksm.length < 2 
+      for i in strString.length..1
+         strCksm = "0" + strCksm
+      end
+    end
+    strCksm.upcase
+  end
+
+	def receive_data(data)
+      
+      puts "incoming data bytes."
+
+      concat = ""
+      
+      
+      puts data.bytes.to_a.to_s
+
+      data.bytes.to_a.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
+      
+      #puts "concat is:"
+      puts concat.to_s
+      process_text(concat)      
+      
+      if data.bytes.to_a[0] == 4
+        puts "sent ENQ"
+        send_data(ENQ)
+      elsif data.bytes.to_a[0] == 6
+        ## so now the middle part has to be 
+=begin
+        response = STX + "1H|\`^&||||||||||P|E 1394-97|#{Time.now.strftime("%Y%m%d%H%M%S")}\r" + terminator + ETX + checksum("1H|\`^&||||||||||P|E 1394-97|#{Time.now.strftime("%Y%m%d%H%M%S")}\r" + terminator) + "\r"
+        response = response.bytes.to_a
+        response << 10
+        send_data(response.pack('c*'))
+=end
+        self.headers[-1].build_responses.each do |response|
+          message_checksum = checksum(response + terminator + ETX)
+          puts "Calculated checksum is: #{message_checksum}"
+          final_resp = STX + response + terminator + ETX + message_checksum + "\r" 
+          final_resp_arr = final_resp.bytes.to_a
+          final_resp_arr << 10
+          puts final_resp_arr.to_s
+          if (self.headers[-1].response_sent == false)
+            send_data(final_resp_arr.pack('c*')) 
+            self.headers[-1].response_sent = true
+          else
+            puts "response was already sent."
+            send_data(EOT)
+          end
+
+        end
+      else
+        ## send the header 
+        puts "--------- SENT ACK -----------"
+        send_data(ACK)
+      end
+  end
+
+  def send_enq
+    puts "enq as bytes is:"
+    puts ENQ.unpack('c*')
+    send_data(ENQ)
+  end
+
+  def process_text(text)
+      text.split("\n").each do |l|
+		    line = Line.new({:text => l})
+        process_type(line)
+      end
+  end
+
+  def process_type(line)
+      case line.type
+      when "Header"
+        header = Header.new({:line => line})
+        self.headers ||= []
+        self.headers << header
+      when "Query"
+        query = Query.new({:line => line})
+        self.headers[-1].queries << query
+      when "Patient"
+        patient = Patient.new({:line => line})
+        self.headers[-1].patients << patient
+      when "Order"
+        order = Order.new({:line => line})
+        self.headers[-1].patients[-1].orders << order
+      when "Result"
+        result = Result.new({:line => line})
+        self.headers[-1].patients[-1].orders[-1].results[result.name] = result
+      when "Terminator"
+        self.headers[-1].commit
+      end
+  end
+
+=begin
+1.STX + response + LF + ETX
+2.response
+3.STX + response + "L|1|N\r" + ETX 
+4.response + "L|1|N\r" 
+=end
+  def unbind
+     puts "-- someone disconnected from the echo server!"
+  end
+
+end

data/lib/ruby_astm/line.rb

@@ -0,0 +1,65 @@
+class Line
+
+	TYPES = {
+		"H" => "Header",
+		"P" => "Patient",
+		"Q" => "Query",
+		"O" => "Order",
+		"R" => "Result",
+		"L" => "Terminator"
+	}
+
+	attr_accessor :text
+	
+	attr_accessor :fields
+	
+	attr_accessor :type
+
+	########################################################
+	##
+	##
+	## HEADER ATTRIBUTES
+	##
+	##
+	########################################################
+
+	
+	
+	## sets the types, and fields
+	## we can have processing based on line.
+	def initialize(args)
+		self.fields = []
+		raise "no text provided" unless args[:text]
+		if args[:text]
+			args[:text].split(/\|/).each do |field|
+				self.fields << field
+			end
+		end
+		detect_type
+	end 
+
+	def detect_type
+		#puts "detecting line type: #{self.text}"
+		line_type = self.fields[0]
+		line_type.scan(/(?<ltype>[A-Z])/) { |ltype| 
+			#puts "got ltype as: #{ltype[0]}"
+			#puts Line::TYPES.to_s
+			if Line::TYPES[ltype[0]]
+				self.type = Line::TYPES[ltype[0]]
+				#puts "assigning type as: #{self.type}"
+			end
+		}		
+	
+=begin
+			if self.fields[0][1..-1] =~/#{type}/
+				puts "got type: #{Line::TYPES[type]}"
+				self.type = Line::TYPES[type]
+				break
+			end
+=end
+		
+	end
+
+	
+
+end

data/lib/ruby_astm/order.rb

@@ -0,0 +1,75 @@
+class Order
+	## => patient id.
+	## => should match the specimen id that comes into the query.
+	## index (2)
+	attr_accessor :id
+	
+	## this should be same as the one for patient.
+	## index (1)
+	attr_accessor :sequence_number
+	
+	## => key : result name.
+	## => value : result object
+	attr_accessor :results
+	
+	## the list of tests that need to be performed.
+	## each should be prefixed by three carets
+	## index (4)
+	attr_accessor :tests
+	## the specimen type.
+
+	## index (15)
+	attr_accessor :specimen_type
+
+
+	## the order type, like stat, routine etc.
+	## index (5)
+	attr_accessor :priority
+
+	## the date and time of collection
+	## index (7)
+	attr_accessor :date_time
+
+	## action code
+	## index (11)
+	attr_accessor :action_code
+
+	def initialize(args)
+		if args[:line]
+			line = args[:line]
+			if line.fields[2]
+				line.fields[2].strip.scan(/(?<specimen_id>[^\^]+)/) { |specimen_id|
+					self.id ||= specimen_id
+				}
+			elsif line.fields[3]
+				## for the sysmex xn-550 this is the regex.
+				line.fields[3].strip.scan(/(?<tube_rack>\d+\^)+(?<patient_id>.+)\^/) { |tube_rack,patient_id|  self.id = patient_id.strip}
+			end
+		else
+			self.sequence_number = args[:sequence_number]
+			self.tests = args[:tests]
+			self.id = args[:specimen_id]
+			self.specimen_type = args[:specimen_type]
+			self.tests = args[:tests]
+			self.date_time = args[:date_time]
+			self.priority = args[:priority]
+			self.action_code = args[:action_code]
+		end
+		self.results = {}
+	end
+
+	def build_response
+		
+		raise "provide a sequence number" if self.sequence_number.blank?
+		raise "provide a specimen id" if self.id.blank?
+		raise "provide a list of tests" if self.tests.blank?
+		raise "provide a test priority" if self.priority.blank?
+		
+		if self.specimen_type.blank?
+			#puts "no specimen type has been provided, sending SERUM"
+		end
+
+		"O|#{self.sequence_number}|#{self.id}^01||^^^#{self.tests.join('^^^')}|#{self.priority}||#{Time.now.strftime("%Y%m%d%H%M%S")}||||N||||#{self.specimen_type || 'SERUM'}\r"
+	end	
+
+end

data/lib/ruby_astm/patient.rb

@@ -0,0 +1,32 @@
+class Patient
+	
+	## sequence number can only be from 0 -- 9.
+	attr_accessor :sequence_number
+	attr_accessor :patient_id
+	attr_accessor :orders
+	
+	def initialize(args)
+		if args[:line]
+			line = args[:line]
+			self.sequence_number = line.fields[1].to_i
+			self.orders = []
+		else
+			self.sequence_number = args[:sequence_number]
+			self.patient_id = args[:patient_id]
+		end
+	end
+
+	## patient id.
+	def build_response
+		"P|#{self.sequence_number}|#{self.patient_id}|||||||||||||||\r"
+	end
+
+	def to_json
+        hash = {}
+        self.instance_variables.each do |x|
+            hash[x] = self.instance_variable_get x
+        end
+        return hash.to_json
+    end
+
+end

data/lib/ruby_astm/query.rb

@@ -0,0 +1,34 @@
+class Query
+	
+	attr_accessor :sample_id
+
+	attr_accessor :response
+
+	def initialize(args)
+		line = args[:line]
+		unless line.fields[2].empty?
+			fields = line.fields[2].split(/\^/)
+			self.sample_id = fields[1].strip
+		end
+	end
+
+	## each query will build one patient and one order inside it.
+	## the order can have many tests.
+	def build_response(variables=nil)
+		variables ||= {
+			:sequence_number => "0",
+			:patient_id => "abcde",
+			:specimen_id => self.sample_id,
+			:tests => ["TRIG"],
+			:priority => "R"
+		}
+
+		patient = Patient.new({:sequence_number => "0", :patient_id => "abcde"})
+		
+		order = Order.new({:sequence_number => patient.sequence_number, :specimen_id => variables[:specimen_id], :tests => variables[:tests], :priority => variables[:priority]})
+
+		return patient.build_response + order.build_response
+		
+	end
+
+end

data/lib/ruby_astm/result.rb

@@ -0,0 +1,34 @@
+class Result
+	attr_accessor :name
+	attr_accessor :value
+	attr_accessor :units
+	attr_accessor :flags
+	attr_accessor :timestamp
+	attr_accessor :reference_ranges
+	attr_accessor :dilution
+
+	## here will call mappings and check the result correlation
+	def initialize(args)
+		if args[:line]
+			line = args[:line]
+			line.fields[2].scan(/\^+(?<name>[A-Za-z0-9\%\#]+)\^?(?<dilution>\d+)?/) { |name,dilution|  
+				self.name = lookup_mapping(name)
+				self.dilution = dilution
+			}
+			self.value = line.fields[3].strip
+			self.reference_ranges = line.fields[5].strip
+			self.flags = line.fields[6].strip 
+			line.fields[12].strip.scan(/(?<year>\d{4})(?<month>\d{2})(?<day>\d{2})(?<hours>\d{2})(?<minutes>\d{2})(?<seconds>\d{2})/) {|year,month,day,hours,minutes,seconds|
+				self.timestamp = Time.new(year,month,day,hours,minutes,seconds)
+			}
+		else
+			super
+		end
+	end
+
+	## @return[String] the name defined in the mappings.json file, or the name that wqs passed in.
+	def lookup_mapping(name)
+		$mappings[name] ? $mappings[name]["LIS_CODE"] : name 
+	end
+
+end

data/lib/ruby_astm.rb

@@ -0,0 +1,12 @@
+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"

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: ruby_astm
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Bhargav Raut
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-rubyserial
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+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
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/publisher/adapter.rb
+- lib/publisher/credentials.json
+- lib/publisher/google_lab_interface.rb
+- lib/publisher/poller.rb
+- lib/publisher/token.yaml
+- lib/ruby_astm.rb
+- lib/ruby_astm/astm_server.rb
+- lib/ruby_astm/frame.rb
+- lib/ruby_astm/header.rb
+- lib/ruby_astm/lab_interface.rb
+- lib/ruby_astm/line.rb
+- lib/ruby_astm/order.rb
+- lib/ruby_astm/patient.rb
+- lib/ruby_astm/query.rb
+- lib/ruby_astm/result.rb
+homepage: https://www.github/com/wordjelly/ruby_astm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14.1
+signing_key: 
+specification_version: 4
+summary: A Ruby gem to interface with Medical instruments that work on the ASTM protocol
+test_files: []