qpid 0.1.2

data/History.txt

@@ -0,0 +1,20 @@
+=== 0.1.2 2010-09-09
+
+* 1 bug fix:
+  * Changed updatestatus so that it recognizes a NEW patient from QPID, and returns a nil time.
+
+=== 0.1.1 2010-07-19
+
+* 1 minor enhancement:
+  * Small changes for Ruby 1.9 compatibility (but we're not there yet)
+
+=== 0.1.0 2010-07-19
+
+* 1 major enhancement:
+  * Library implemented
+  * Tests implemented
+
+=== 0.0.1 2009-10-21
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,16 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+lib/qpid.rb
+script/console
+test/test_helper.rb
+test/test_qpid.rb
+test/content/3000888_report_pat_4313382_1.xml
+test/content/3000888_report_rad_63580395.xml
+test/content/3000888_search_type.xml
+test/content/3000888_search_type_fromdate.xml
+test/content/3000888_search_type_rad.xml
+test/mock_http_client.rb
+test/qpid.yml
+test/qpid_test_data.yml

data/README.rdoc

@@ -0,0 +1,61 @@
+= qpid
+
+* http://github.com/talkasab/qpid
+
+== DESCRIPTION:
+
+Interface to QPID, the Queriable Patient Inference Dossier system.
+
+== FEATURES/PROBLEMS:
+
+* Determine when the QPID system last updated a patient's information
+* Request a reload/reindexing of the patient's information, and find out when complete
+* Get a summary of search results
+* Get individual reports
+
+== SYNOPSIS:
+
+  qpid = Qpid.new(YAML.load_file('qpid.yml'))
+  qpid.timeout_interval = 50
+  qpid.query_interval = 4.5
+
+  mrn = "654321"
+  # Reload the QPID index for the data
+  qpid.reload(mrn)
+  # Do a search for items of type "Endoscopy" with title "Colonoscopy" done after Jan 1, 2008
+  results = qpid.search(mrn, Qpid.type(:NDO), 
+    Qpid.title("Colonoscopy"), Qpid.fromdate(Date.new(2008,1,1)))
+
+== REQUIREMENTS:
+
+* httpclient (to go talk to the QPID server)
+* happymapper (to map XML to objects)
+
+== INSTALL:
+
+* sudo gem install qpid
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Tarik Alkasab, MD, PhD
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/qpid'
+
+Hoe.plugin :newgem
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'qpid' do
+  self.developer 'Tarik K. Alkasab, MD, PhD', 'talkasab@partners.org'
+  self.rubyforge_name       = self.name # TODO this is default value
+  self.extra_deps         = [['happymapper','>= 0.3.0'], ['httpclient', '>= 2.1.5.2']]
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/lib/qpid.rb

@@ -0,0 +1,186 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'httpclient'
+require 'cgi'
+require 'happymapper'
+
+class Qpid
+  VERSION = '0.1.2'
+  
+  class SearchItem
+    include HappyMapper
+    tag 'searchitem'
+    element :type, String
+    element :mid, String, :tag => "MID"
+    element :date, Date, :tag => "Scheduledate"
+    element :site, String
+    element :status, String
+    element :desc, String
+    element :context, String
+  end
+  
+  DEF_PORT = 80
+  DEF_TIMEOUT_INTERVAL = 300
+  DEF_QUERY_INTERVAL = 9.5
+  DEF_ERROR_TOLERANCE = 2
+
+  class NoPatientError < RuntimeError
+    def initialize(mrn)
+      super("QPID cannot find patient with MRN #{mrn}")
+    end
+  end
+  
+  class BadContentError < RuntimeError
+    def initialize(task, resp, err=nil)
+      super("While #{task}, got unexpected data: #{ resp ? resp : 'nil' }" +  (err ? " (Underlying error: #{err})" : ''))
+    end
+  end
+  
+  class TimeoutError < RuntimeError
+    def initialize(task, err=nil)
+      super("While #{task}, timed out waiting for a resopnse" + (err ? " (Underlying error: #{err})" : ''))
+    end
+  end
+  
+  attr_accessor :host, :path, :user, :port, :timeout_interval, :query_interval, :error_tolerance
+  attr_reader :client
+  
+  def initialize(params = {})
+    missing_params = []
+    @user = params[:user] || params['user'] || missing_params << 'user' 
+    @host = params[:host] || params['host'] || missing_params << 'host'
+    @path = params[:path] || params['path'] || missing_params << 'path'
+    if missing_params.length > 0
+      raise ArgumentError, "Did not specify #{missing_params.join(', ')} to initialize QPID object"
+    end
+    @port = params[:port] || DEF_PORT
+    @timeout_interval = params[:timeout_interval] || params['timeout_interval'] || DEF_TIMEOUT_INTERVAL
+    @query_interval = params[:query_interval] || params['query_interval'] || DEF_QUERY_INTERVAL
+    @error_tolerance = params[:error_tolerance] || params['error_tolerance'] || DEF_ERROR_TOLERANCE
+    @client = params[:client] || params['client'] || HTTPClient.new
+    if (params[:http_user] && params[:http_password])
+      client.set_auth(nil, params[:http_user], params[:http_password])
+    elsif (params['http_user'] && params['http_password'])
+      client.set_auth(nil, params['http_user'], params['http_password'])
+    end
+  end
+
+  def function_uri(function, mrn, params = {})
+    query = query({:function => function, :MRN => mrn}.merge(params))
+    URI::HTTP.build(:host => host, :port => port, :path => path, :query => query )
+  end
+
+  def query(params = {})
+    params[:USER] = user
+    params[:xml] ||= 1
+    params.map { |p| "#{CGI.escape(p[0].to_s)}=#{CGI.escape(p[1].to_s)}" }.join('&')
+  end
+  
+  # Get the time a patient's record was last updated in QPID
+  def updatestatus(mrn)
+    case xml = client.get_content(function_uri(:updatestatus, mrn)) 
+    when /<message>NO PATIENT<\/message>/
+      raise Qpid::NoPatientError.new(mrn)
+    when /<message>NEW<\/message>/
+      nil
+    when /<lastupdate>(.+)<\/lastupdate>/
+      begin
+        DateTime.parse($1)      
+      rescue Exception => e
+        raise Qpid::BadContentError.new("parsing time in update status for MRN #{mrn}", xml, e.inspect)
+      end
+    else
+      raise Qpid::BadContentError.new("getting update status for MRN #{mrn}", xml)
+    end
+  end
+
+  # Causes QPID to re-update the patient's record. Returns true when done, or false if
+  # the attempt times out. 
+  def reload(mrn)
+    start_time = Time.now
+    error_count = error_tolerance
+    task_description = "reloading patient #{mrn}"
+    while true
+      case resp = client.get_content(function_uri(:reload, mrn))
+      when /<message>OK<\/message>/
+        return true
+      when /<message>(NEW|UPDATING|STALE)<\/message>/
+        return false if Time.now - start_time > timeout_interval
+        sleep query_interval
+      when /<message>NO PATIENT<\/message>/
+        raise Qpid::NoPatientError.new(mrn)
+      else
+        error_count = error_count - 1
+        if error_count > 0
+          sleep query_interval/2
+        else
+          raise Qpid::BadContentError.new(task_description, resp)
+        end
+      end
+    end
+  end
+
+  # Does a search in the patient's medical record (as of the last time they were updated)
+  # and returns an array of Qpid::SearchItem objects which match the search
+  def search(mrn, *search_terms)
+    search_string = search_terms.join(' and ')
+    task_description = "searching MRN #{mrn} with [#{search_string}]"
+    case resp = client.get_content(function_uri(:search, mrn, :search => search_string))
+    when /<message>NO PATIENT<\/message>/
+      raise Qpid::NoPatientError.new(mrn)
+    when /<searchlist>/
+      begin
+        SearchItem.parse(resp)
+      rescue Exception => e
+        raise Qpid::BadContentError.new(task_description, resp, e.inspect)
+      end
+    else
+      raise Qpid::BadContentError.new(task_description, resp)
+    end
+  end
+  
+  @@report_re = /<pre>(.+)<\/pre>/m
+
+  # Actually get the report for a given patient (specified by MRN) referred to by the
+  # given Qpid::SearchItem object.
+  def report(mrn, search_item)
+    case data = client.get_content(function_uri(:report, mrn, :type => search_item.type, :MID => search_item.mid))
+    when /<message>NO PATIENT<\/message>/
+      raise Qpid::NoPatientError.new(mrn)
+    when /<table id=\"report\">/
+      match = @@report_re.match(data)
+      match[1]
+    else
+      raise Qpid::BadContentError.new("getting report for MRN #{mrn}, item [#{search_item.inspect}]", data)
+    end
+  end
+  
+  def self.type(type)
+    "type:#{type.to_s.upcase}"
+  end
+
+  def self.todate(date)
+    "todate:" + date.strftime("\"%m/%d/%Y\"")
+  end
+  
+  def self.fromdate(date)
+    "fromdate:" + date.strftime("\"%m/%d/%Y\"")
+  end
+  
+  def self.last(num_items)
+    "last:#{num_items}"
+  end
+  
+  def self.daysago(num_days)
+    "daysago:#{num_days}"
+  end
+  
+  def self.title(string)
+    "title:#{string}"
+  end
+  
+  def self.ondate(date)
+    todate(date) + " AND " + fromdate(date)
+  end
+end

data/script/console

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/qpid.rb'}"
+if File.exist?(File.join(File.dirname(__FILE__), '..', 'qpid.yml'))
+  puts "qpid = Qpid.new(YAML.load_file('qpid.yml'))"
+end
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'stringio'
+require 'test/unit'
+require 'rubygems'
+require File.dirname(__FILE__) + '/../lib/qpid'

data/test/test_qpid.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+require File.join(File.dirname(__FILE__), 'mock_http_client.rb')
+
+class TestQpid < Test::Unit::TestCase
+
+  def setup
+    m=MockHttpClient.new(File.join(File.dirname(__FILE__), '/qpid_test_data.yml'), 
+      Logger.new(File.join(File.dirname(__FILE__), 'test.log')))
+    @qpid = Qpid.new(YAML.load_file('test/qpid.yml').merge(:client => m))
+  end
+  
+  def test_updatestatus_known
+    updatetime = @qpid.updatestatus("3000888")
+    assert_not_nil updatetime, "Should get a non-nil object from updatestatus()"
+    assert_kind_of DateTime, updatetime, "Should get a DateTime object from updatestatus()"
+    assert updatetime == @qpid.client.updatetimes["3000888"], "Time from updatestatus() should be same as set in mock client"
+  end
+  
+  def test_updatestatus_unknown
+    assert_raise(Qpid::NoPatientError) { @qpid.updatestatus("3000999") }
+  end
+  
+  def test_updatestatus_now_nil
+    assert_raise(Qpid::BadContentError) { 
+      @qpid.client.next_response_nil = 1
+      @qpid.updatestatus("3000888")
+    }
+  end
+  
+  def test_reload
+    @qpid.timeout_interval = 5.0
+    expected_delay = @qpid.client.delays["3000888"] + 1.0
+    start = Time.now
+    assert @qpid.reload("3000888"), "Should get true from reloading evenutally"
+    delay = Time.now - start
+    assert delay < expected_delay, "Took #{delay} to get the response; expected less than #{expected_delay}"
+  end
+  
+  def test_reload_unknown
+    assert_raise(Qpid::NoPatientError) { @qpid.reload("3000999") }
+  end
+  
+  def test_reload_error_tolerable
+    @qpid.client.next_response_nil = 1
+    assert_nothing_raised(Qpid::BadContentError) { @qpid.reload("3000888") }
+  end
+  
+  def test_reload_error_nontolerable
+    @qpid.client.next_response_nil = 3
+    assert_raise(Qpid::BadContentError) { @qpid.reload("3000888") }
+  end
+  
+  def test_reload_timeout
+    @qpid.client.delays["3000888"] = 10.0
+    @qpid.timeout_interval = 5.0
+    assert @qpid.reload("3000888") == false, "Should get false from reload() because we timed out."
+  end
+  
+  def test_search
+    check_search_items 3, @qpid.search("3000888", Qpid.type(:PAT))
+    check_search_items 1, @qpid.search("3000888", Qpid.type(:RAD))
+    check_search_items 1, @qpid.search("3000888", Qpid.type(:PAT), Qpid.fromdate(Date.new(2007, 7, 1)))
+  end
+  
+  def check_search_items(expected_length, items)
+    assert_equal expected_length, items.length, "Should have gotten a list of #{expected_length} SearchItem(s)"
+    items.each {|i| assert_kind_of Qpid::SearchItem, i, "Items returned from search should be of kind Qpid::SearchItem" }    
+  end
+
+  def test_search_unknown
+    assert_raise(Qpid::NoPatientError) { @qpid.search("3000999", Qpid.type(:PAT)) }
+  end
+  
+  def test_report
+    searchitem = @qpid.search("3000888", Qpid.type(:PAT), Qpid.fromdate(Date.new(2007, 7, 1)))[0]
+    report = @qpid.report("3000888", searchitem)
+    assert_not_nil report, "Should not get a nil report when have a valid response"
+    assert_match(/CASE: BS-07-W17636/, report, "We should see the expected text in the report")
+    assert_no_match(/(<\/?tr>|<\/?td>|<\/?pre>)/, report, "Should not see tags in the returned report")
+  end
+  
+  def test_other_report
+    searchitem = @qpid.search("3000888", Qpid.type(:RAD))[0]
+    report = @qpid.report("3000888", searchitem)
+    assert_not_nil report, "Should not get a nil report when have a valid response"
+    assert_match(/Exam Number:  301654345/, report, "We should see the expected text in the report")
+    assert_no_match(/(<\/?tr>|<\/?td>|<\/?pre>)/, report, "Should not see tags in the returned report")
+  end
+  
+  def test_report_unknown
+    searchitem = @qpid.search("3000888", Qpid.type(:PAT), Qpid.fromdate(Date.new(2007, 7, 1)))[0]
+    assert_raise(Qpid::NoPatientError) { @qpid.report("3000999", searchitem) }
+  end
+
+  def test_report_now_nil
+    assert_raise(Qpid::BadContentError) { 
+      @qpid.client.next_response_nil = 1
+      searchitem = @qpid.search("3000888", Qpid.type(:RAD))[0]
+      @qpid.report("3000888", searchitem)
+    }
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification 
+name: qpid
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
+platform: ruby
+authors: 
+- Tarik K. Alkasab
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-21 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: happymapper
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 3
+        - 0
+        version: 0.3.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: httpclient
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 119
+        segments: 
+        - 2
+        - 1
+        - 5
+        - 2
+        version: 2.1.5.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 3
+        - 3
+        version: 2.3.3
+  type: :development
+  version_requirements: *id003
+description: The QPID (Queriable Patient Inference Dossier, developed at Massachusetts General Hospital) aggregates and permits semantic searching of electronic medical record systems. The Qpid gem provides a ruby interface to the web service which QPID-based systems offer for searching and accessing medical record information.
+email: 
+- tarik.alkasab@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/qpid.rb
+- script/console
+- script/destroy
+- script/generate
+- test/test_helper.rb
+- test/test_qpid.rb
+has_rdoc: true
+homepage: http://github.com/talkasab/qpid
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: qpid
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Interface to medical record search systems based on the QPID (Queriable Patient Inference Dossier) system.
+test_files: 
+- test/test_helper.rb
+- test/test_qpid.rb