vistarpc4r 0.1.1 → 0.2.0

data/README.rdoc

@@ -1,6 +1,16 @@
-= vistarpc4r
+= VistaRPC4r
+VistaRPC4r provides a Ruby interface to the Veterans Administration's almost opensource electronic health record called VistA.
+The VistA architecture is old school client/server.  The typical client is a Windows based GUI.  The typical server is an Linux or Windows based server.  The server is primarily written in MUMPS or M.  
+VistA provides an RPC-style interface to its core functions using TCP sockets and a custom message format
+VistaRPC4r implements the socket layer and message format and provides methods which can initiate RPC requests and returns the RPC output.
+The VistA server requires each connection to have a username/password authentication.  
 
-Description goes here.
+This gem has been tested with Medsphere's OpenVista server distribution.
+
+Future topics for this document
+* More detail on how to use
+* Detailed examples
+* links to more information
 
 == Contributing to vistarpc4r
  

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/examples/test.rb

@@ -1,20 +1,20 @@
-require 'rpc_broker_connection'
+require './../lib/vistarpc4r/rpc_response'
+require './../lib/vistarpc4r/vista_rpc'
+require './../lib/vistarpc4r/rpc_broker_connection'
 
 #broker = RPCBrokerConnection.new('192.168.1.20', 9270, 'sys.admin', 'vista!123')
-broker = RPCBrokerConnection.new('openvista.medsphere.org', 9201, 'PU1234', 'PU1234!!')
+broker = VistaRPC4r::RPCBrokerConnection.new('openvista.medsphere.org', 9201, 'PU1234', 'PU1234!!')
 
 broker.connect
 broker.setContext('OR CPRS GUI CHART')
 
-wardsrpc = VistaRPC.new("ORQPT WARDS", RPCResponse::ARRAY)
-wardsresponse = broker.execute(wardsrpc)
-wardsresponse.value.each do |ward|
+patient_ien = "4"
+wardsarray = broker.call_a("ORQPT WARDS")
+wardsarray.each do |ward|
   a = ward.split("^")
   puts "Ward:" + a[1]
-  wardrpc = VistaRPC.new("ORQPT WARD PATIENTS", RPCResponse::ARRAY)
-  wardrpc.params[0]=a[0] #ward ien
-  wardresponse = broker.execute(wardrpc)
-  wardresponse.value.each do |patient|
+  wardarray = broker.call_a("ORQPT WARD PATIENTS", [a[0]])  # ward ien
+  wardarray.each do |patient|
     b = patient.split("^")
     puts b[0] + ":" + b[1]
   end
@@ -22,63 +22,49 @@ end
 
 # Problem list
 puts "Problem list-------------------------------------"
-patientrpc = VistaRPC.new("ORQQPL LIST", RPCResponse::ARRAY)
-patientrpc.params[0]="4" #patient ien
-patientrpc.params[1]="A" #patient ien
-patientresponse = broker.execute(patientrpc)
-patientresponse.value.each do |d|
+patientarray = broker.call_a("ORQQPL LIST", [patient_ien, "A"])
+patientarray.each do |d|
   puts d
 end
 
 # Medications
 puts "Medications-------------------------------------"
-patientrpc = VistaRPC.new("ORWPS COVER", RPCResponse::ARRAY)
-patientrpc.params[0]="4" #patient ien
-patientresponse = broker.execute(patientrpc)
-patientresponse.value.each do |d|
+patientarray = broker.call_a("ORWPS COVER", [patient_ien])
+patientarray.each do |d|
   puts d
 end
 
 #Labs
 puts "Labs-------------------------------------"
-patientrpc = VistaRPC.new("ORWCV LAB", RPCResponse::ARRAY)
-patientrpc.params[0]="4" #patient ien
-patientresponse = broker.execute(patientrpc)
-patientresponse.value.each do |d|
+patientarray = broker.call_a("ORWCV LAB", [patient_ien])
+patientarray.each do |d|
   puts d
 end
 
 # Vitals
 puts "Vitals-------------------------------------"
-patientrpc = VistaRPC.new("ORQQVI VITALS", RPCResponse::ARRAY)
-patientrpc.params[0]="4" #patient ien
-patientresponse = broker.execute(patientrpc)
-patientresponse.value.each do |d|
+patientarray = broker.call_a("ORQQVI VITALS", [patient_ien])
+patientarray.each do |d|
   puts d
 end
 
 # Demo
 puts "Demographics-------------------------------------"
-patientrpc = VistaRPC.new("ORWPT PTINQ", RPCResponse::ARRAY)
-patientrpc.params[0]="4" #patient ien
-patientresponse = broker.execute(patientrpc)
-patientresponse.value.each do |d|
+patientarray = broker.call_a("ORWPT PTINQ", [patient_ien])
+patientarray.each do |d|
   puts d
 end
 
 #visits
 puts "Visits-------------------------------------"
-patientrpc = VistaRPC.new("ORWCV VST", RPCResponse::ARRAY)
-patientrpc.params[0]="4" #patient ien
-patientresponse = broker.execute(patientrpc)
-patientresponse.value.each do |d|
+patientarray = broker.call_a("ORWCV VST", [patient_ien])
+patientarray.each do |d|
   puts d
 end
 
 #providers
 puts "Providers---------------------------------"
-patientrpc = VistaRPC.new("ORQPT PROVIDERS", RPCResponse::ARRAY)
-patientresponse = broker.execute(patientrpc)
-patientresponse.value.each do |d|
+patientarray = broker.call_a("ORQPT PROVIDERS")
+patientarray.each do |d|
   puts d
 end

data/lib/vistarpc4r/rpc_broker_connection.rb

@@ -3,427 +3,476 @@ require 'socket'
 #require 'vista_rpc'
 
 module VistaRPC4r
-class RPCBrokerConnection
-  # Header chunk types
-  CHUNK_TYPE_HEADER = "1"
-  CHUNK_TYPE_RPC = "2"
-  CHUNK_TYPE_SECURITY = "3"
-  CHUNK_TYPE_COMMAND = "4"
-  CHUNK_TYPE_DATA = "5"
-  XWB_HEADER = "[XWB]"
-  # Header and protocol info
-  VISTA_RPC_VERSION = "1"
-  VISTA_RPC_TYPE_CMD = "0"
-  VISTA_RPC_TYPE_RPC = "1"
-  VISTA_RPC_LENV = 3
-  VISTA_RPC_LENV_STR = "3"
-  VISTA_RPC_RETURN_DATA = "0"
-  VISTA_RPC_NO_RETURN_DATA = "1"
-  END_MARKER = 4
-  # Parameter types
-  PARAM_LITERAL_MARKER = "0"
-  PARAM_REFERENCE_MARKER = "1"
-  PARAM_LIST_MARKER = "2"
-  PARAM_GLOBAL_MARKER = "3"
-  PARAM_EMPTY_MARKER = "4"
-  
-  def initialize(host, port, access, verify, debug=FALSE)
-    @sentConnect = false
-    @signedOn = false
-    @host=host
-    @port=port
-    @access=access
-    @verify=verify
-    @debug=debug
-    @token=nil
-    @socket = nil
-    @encryptedAV = nil
-    @writeBuffer = String.new
-    @duz = "0"
-    @currentContext = nil
-  end
-  
-  def connect
-    retVal = true
-    if isConnected()
-      puts " already connected, closing first"
-      close
+  class RPCBrokerConnection
+    # Header chunk types
+    CHUNK_TYPE_HEADER = "1"
+    CHUNK_TYPE_RPC = "2"
+    CHUNK_TYPE_SECURITY = "3"
+    CHUNK_TYPE_COMMAND = "4"
+    CHUNK_TYPE_DATA = "5"
+    XWB_HEADER = "[XWB]"
+    # Header and protocol info
+    VISTA_RPC_VERSION = "1"
+    VISTA_RPC_TYPE_CMD = "0"
+    VISTA_RPC_TYPE_RPC = "1"
+    VISTA_RPC_LENV = 3
+    VISTA_RPC_LENV_STR = "3"
+    VISTA_RPC_RETURN_DATA = "0"
+    VISTA_RPC_NO_RETURN_DATA = "1"
+    END_MARKER = 4
+    # Parameter types
+    PARAM_LITERAL_MARKER = "0"
+    PARAM_REFERENCE_MARKER = "1"
+    PARAM_LIST_MARKER = "2"
+    PARAM_GLOBAL_MARKER = "3"
+    PARAM_EMPTY_MARKER = "4"
+    
+    public
+    
+    def initialize(host, port, access, verify, debug=FALSE)
+      @sentConnect = false
+      @signedOn = false
+      @host=host
+      @port=port
+      @access=access
+      @verify=verify
+      @debug=debug
+      @token=nil
+      @socket = nil
+      @encryptedAV = nil
+      @writeBuffer = String.new
+      @duz = "0"
+      @currentContext = nil
     end
-    @socket = TCPSocket.open(@host, @port)    # Connect
-    #            socket.setTcpNoDelay(true)
-    tcpConnect = VistaRPC.new("TCPConnect", RPCResponse::SINGLE_VALUE, true)
-    tcpConnect.params[0]= @socket.addr[4]  # local IP address
-    tcpConnect.params[1]= "0" # callback port ?
-    tcpConnect.params[2]= "OVID"
-    connectResponse = execute(tcpConnect)
-    if (connectResponse == nil || connectResponse.value == nil || connectResponse.value == "reject")
-      puts "Handshake error"
+    
+    def connect
+      retVal = true
+      if isConnected()
+        puts " already connected, closing first"
+        close
+      end
+      @socket = TCPSocket.open(@host, @port)    # Connect
+      #            socket.setTcpNoDelay(true)
+      tcpConnect = VistaRPC.new("TCPConnect", RPCResponse::SINGLE_VALUE, true)
+      tcpConnect.params[0]= @socket.addr[4]  # local IP address
+      tcpConnect.params[1]= "0" # callback port ?
+      tcpConnect.params[2]= "OVID"
+      connectResponse = execute(tcpConnect)
+      if (connectResponse == nil || connectResponse.value == nil || connectResponse.value == "reject")
+        puts "Handshake error"
+      end
+      if (connectResponse.error_message != nil)
+        puts "RPC Error: " + connectResponse.error_message
+      end
+      @sentConnect = true
+      
+      signOn()
+      retVal = logIn()
+      return retVal
     end
-    if (connectResponse.error_message != nil)
-      puts "RPC Error: " + connectResponse.error_message
+    
+    def close()
+      if isConnected()
+        if @sentConnect
+          @sentConnect = false
+          bye = VistaRPC.new("#BYE#", RPCResponse::SINGLE_VALUE, true)
+          execute(bye)
+          @socket.close()
+          @socket = nil
+        end
+      end
     end
-    @sentConnect = true
     
-    signOn()
-    retVal = logIn()
-    return retVal
-  end
-  
-  def signOn() 
-    signonResponse = execute(VistaRPC.new("XUS SIGNON SETUP", RPCResponse::ARRAY))
-    if (signonResponse == nil || signonResponse.error_message != nil)
-      puts "XUS SIGNON SETUP failed"
+    def isConnected()
+      return @socket != nil
     end
-    @signedOn = true
-  end
-  
-  def logIn()
-    xusAvCode = VistaRPC.new("XUS AV CODE", RPCResponse::ARRAY)
-    @duz = "0"
     
-    if (@encryptedAV == nil) 
-      if (@token != nil)
-        @encryptedAV = @token
-      else 
-        @encryptedAV = xusAvCode.encrypt(@access + ";" + @verify)
+    def execute(rpc)
+      retVal = executeOnce(rpc)
+      if (retVal == nil && @signedOn) 
+        #reconnect
+        if (rpc.name == "#BYE#")
+          # We're disconnecting anyway
+          return nil
+        end
+        # attempt to log back on
+        if (connect())
+          if (@currentContext != nil) 
+            context = !currentContext
+            @currentContext = nil
+            setContext(context)
+          end
+          retVal = executeOnce(rpc)
+        end
       end
-      
-    end
-    xusAvCode.params[0]= @encryptedAV
-    response = execute(xusAvCode)
-    if (response == nil) 
-      return false
+      if (retVal == nil)
+        puts "Lost connection to server"
+      end
+      return retVal
     end
-    hasErrors = (response.error_message != nil)
-    answer = response.value
-    if (!hasErrors) 
-      if (answer.length == 0) 
-        hasErrors = true
-      else 
-        hasErrors = answer[0]== "0"
+
+    # Call the RPC function
+    #  rpcname = String containing name of RPC
+    #  args = Array of arguments 0-based
+    #  response type = one of the types in RPCResponse
+    #  returns RPCResponse
+    def call(rpcname, responsetype, args=nil)
+      rpc = VistaRPC.new(rpcname, responsetype)
+      if !args.nil?
+        rpc.params = args
       end
+      rpcresponse = execute(rpc)
+      return rpcresponse
     end
-    if (hasErrors) 
-      brokerInfo = extractBrokerErrorInfo(response)
-      puts("Access denied: " + brokerInfo)
-    else
-      duz = answer[0]
+
+    # Call the RPC function expecting to receive a string or SINGLE_VALUE
+    #  rpcname = String containing name of RPC
+    #  args = Array of arguments 0-based
+    #  returns String
+    def call_s(rpcname, args=nil)
+      rpc = VistaRPC.new(rpcname, RPCResponse::SINGLE_VALUE)
+      if !args.nil?
+        rpc.params = args
+      end
+      rpcresponse = execute(rpc)
+      return rpcresponse.value
     end
-    return true
-  end
 
-  
-  def extractBrokerErrorInfo(response)
-    sb = String.new
-    #    if (response != nil && response.getArray() != nil)
-    #      response.getArray.each do |answer|
-    #        if (answer != nil && answer.length > 0 && !answer.matches("^(\\d+)$"))
-    #          if (sb.length() != 0) # sb is Stringbuilder
-    #            sb.append(" : ")
-    #            sb.append(answer)
-    #          end
-    #        end
-    #      end
-    #    end
-    return sb
-  end
-  
-  def close()
-    if isConnected()
-      if @sentConnect
-        @sentConnect = false
-        bye = VistaRPC.new("#BYE#", RPCResponse::SINGLE_VALUE, true)
-        execute(bye)
-        @socket.close()
-        @socket = nil
+    # Call the RPC function expecting to receive a array of string ARRAY
+    #  rpcname = String containing name of RPC
+    #  args = Array of arguments 0-based
+    #  returns Array
+    def call_a(rpcname, args=nil)
+      rpc = VistaRPC.new(rpcname, RPCResponse::ARRAY)
+      if !args.nil?
+        rpc.params = args
       end
+      rpcresponse = execute(rpc)
+      return rpcresponse.value
     end
-  end
-  
-  def isConnected()
-    return @socket != nil
-  end
-  
-  #    public String buildSubscript(String string) {
-  #        return /* "\r" + */ string
-  #    }
-  
-  def executeOnce(rpc)
-    retVal = nil
-    writeProtocol()
-    writeCommand(rpc)
-    writeParams(rpc)
-    write(END_MARKER)
-    if (flush())
-      retVal = getResponse(rpc.type)
-      if @debug
-        puts "<Response> " + retVal.to_s + "</Response>"
+
+    
+    def setContext(context)
+      if (context == @currentContext)
+        puts "context is already set to " + context + "..."
+        return
       end
+      if (@currentContext != nil) 
+        puts "changing context from " + currentContext + " to " + context
+      end
+      
+      puts "Setting context to: " + context
+      xwbCreateContext = VistaRPC.new("XWB CREATE CONTEXT", RPCResponse::SINGLE_VALUE)
+      encryptedContext = xwbCreateContext.encrypt(context)
+      xwbCreateContext.params[0] = encryptedContext
+      response = execute(xwbCreateContext)
+      if (response == nil || response.error_message != nil)
+        puts "XWB CREATE CONTEXT failed: " + response.error_message
+      end
+      @currentContext = context
     end
-    return retVal
-  end
-  
-  def write(data)
-    @writeBuffer << data
-  end
-  
-  def writeProtocol
-    write(XWB_HEADER + VISTA_RPC_VERSION + VISTA_RPC_TYPE_RPC + VISTA_RPC_LENV_STR + VISTA_RPC_RETURN_DATA)
-  end
-  
-  def writeCommand(rpc)  
-    if (rpc.isCommand)
-      write(CHUNK_TYPE_COMMAND)
-    else
-      write(CHUNK_TYPE_RPC)
-      writeSPack(VISTA_RPC_VERSION)
+    
+    
+    def getDUZ
+      return @duz
     end
-    writeSPack(rpc.name)
-  end
-  
-  def writeSPack(value)
-    write(value.length)  # integer
-    write(value)
-  end
-  
-  def writeLPack(string)
-    len = sprintf("%03i", string.length)  # 0-padded 3 place string of integer
-    #Integer.toString(string.length())
-    #    while (len.length() < VISTA_RPC_LENV) {
-    #        len = "0" + len
-    #    }
-    write(len)  # "003"
-    write(string)
-  end
-  
-  def writeParams(rpc)
-    write(CHUNK_TYPE_DATA)
-    
-    params = rpc.params  # Hash integer => object
-    if (!params.empty?)
-      params.each do |param|
-        if param.nil?
-          writeEmptyParam()
-        elsif param.class == String
-          writeStringParam(param)
-        elsif param.class == Array
-          writeArrayParam(param)
-        else
-          writeEmptyParam()
-        end
+    
+    
+    
+    private  
+    
+    def signOn() 
+      signonResponse = execute(VistaRPC.new("XUS SIGNON SETUP", RPCResponse::ARRAY))
+      if (signonResponse == nil || signonResponse.error_message != nil)
+        puts "XUS SIGNON SETUP failed"
       end
-    else
-      writeEmptyParam()
+      @signedOn = true
     end
-    #No end marker. Chunk 5 is assumed to be the last.
-  end
-  
-  def writeArrayParam(paramarray)
-    write(PARAM_LIST_MARKER)
-    size = paramarray.size
-    index = 0
-    paramarray.each do |v|
-      writeLPack(v[0])
-      writeLPack(v[1])
-      index += 1
-      if index !=size # looks like don't write a 't' after the last entry
-        write("t")
+    
+    def logIn()
+      xusAvCode = VistaRPC.new("XUS AV CODE", RPCResponse::ARRAY)
+      @duz = "0"
+      
+      if (@encryptedAV == nil) 
+        if (@token != nil)
+          @encryptedAV = @token
+        else 
+          @encryptedAV = xusAvCode.encrypt(@access + ";" + @verify)
+        end
+        
+      end
+      xusAvCode.params[0]= @encryptedAV
+      response = execute(xusAvCode)
+      if (response == nil) 
+        return false
       end
+      hasErrors = (response.error_message != nil)
+      answer = response.value
+      if (!hasErrors) 
+        if (answer.length == 0) 
+          hasErrors = true
+        else 
+          hasErrors = answer[0]== "0"
+        end
+      end
+      if (hasErrors) 
+        brokerInfo = extractBrokerErrorInfo(response)
+        puts("Access denied: " + brokerInfo)
+      else
+        @duz = answer[0]
+      end
+      return true
     end
-    write("f")  
-  end
-  
-  def writeStringParam(string)
-    write(PARAM_LITERAL_MARKER)
-    writeLPack(string)
-    write("f")
-  end
-  
-  def writeEmptyParam() 
-    write(PARAM_EMPTY_MARKER)
-    write("f")
-  end
-  
-  def flush()
-    retVal = false
-    if (isConnected() || connect()) 
-      if @debug
-        puts "<Request>" + @writeBuffer + "</Request>"
-      end
-      @socket.write(@writeBuffer)
-      @socket.flush
-      @writeBuffer = String.new
-      retVal = true
+    
+    
+    def extractBrokerErrorInfo(response)
+      sb = String.new
+      #    if (response != nil && response.getArray() != nil)
+      #      response.getArray.each do |answer|
+      #        if (answer != nil && answer.length > 0 && !answer.matches("^(\\d+)$"))
+      #          if (sb.length() != 0) # sb is Stringbuilder
+      #            sb.append(" : ")
+      #            sb.append(answer)
+      #          end
+      #        end
+      #      end
+      #    end
+      return sb
     end
-    return retVal
-  end
+    
   
-  def getResponse(rpcType)
-    hadError = Array.new  # for passing around boolean by reference
-    hadError[0]=false
-    securityError = readSPack(hadError)
-    #puts "<SecurityError>" + securityError + "</SecurityError>"
-    if (hadError[0])
-      return nil
-    end
-    if (securityError.empty?)
-      securityError = nil
+    #    public String buildSubscript(String string) {
+    #        return /* "\r" + */ string
+    #    }
+    
+    def executeOnce(rpc)
+      retVal = nil
+      writeProtocol()
+      writeCommand(rpc)
+      writeParams(rpc)
+      write(END_MARKER)
+      if (flush())
+        retVal = getResponse(rpc.type)
+        if @debug
+          puts "<Response> " + retVal.to_s + "</Response>"
+        end
+      end
+      return retVal
     end
     
-    otherError = readSPack(hadError)
-    if (hadError[0])
-      return nil
+    def write(data)
+      @writeBuffer << data
     end
-    if (otherError.empty?)
-      otherError = nil
+    
+    def writeProtocol
+      write(XWB_HEADER + VISTA_RPC_VERSION + VISTA_RPC_TYPE_RPC + VISTA_RPC_LENV_STR + VISTA_RPC_RETURN_DATA)
     end
     
-    retVal = nil
-    if (rpcType == RPCResponse::SINGLE_VALUE or rpcType == RPCResponse::GLOBAL_INSTANCE)
-      retVal = RPCResponse.new(readString(nil, hadError))
-      if (hadError[0])
-        return nil
-      end
-    elsif (rpcType == RPCResponse::GLOBAL_ARRAY or rpcType == RPCResponse::WORD_PROCESSING or rpcType == RPCResponse::ARRAY)
-      retVal = RPCResponse.new(readArray(hadError))
-      if (hadError[0]) 
-        return nil
+    def writeCommand(rpc)  
+      if (rpc.isCommand)
+        write(CHUNK_TYPE_COMMAND)
+      else
+        write(CHUNK_TYPE_RPC)
+        writeSPack(VISTA_RPC_VERSION)
       end
+      writeSPack(rpc.name)
     end
     
-    if (retVal != nil && (otherError != nil || securityError != nil))
-      if (otherError != nil && securityError != nil)
-        retVal.error_message = otherError + "^" + securityError
-      elsif (otherError != nil) 
-        retVal.error_message = otherError
-      else 
-        retVal.error_message = securityError
-      end
+    def writeSPack(value)
+      write(value.length)  # integer
+      write(value)
     end
-    return retVal
-  end
-  
-  # returns array of string
-  def readArray(hadError)
-    if (hadError != nil)
-      hadError[0] = false
+    
+    def writeLPack(string)
+      len = sprintf("%03i", string.length)  # 0-padded 3 place string of integer
+      #Integer.toString(string.length())
+      #    while (len.length() < VISTA_RPC_LENV) {
+      #        len = "0" + len
+      #    }
+      write(len)  # "003"
+      write(string)
     end
-    arrayList = Array.new
-    endMarker = Array.new
-    endMarker[0] = false
-    while true
-      newString = readString(endMarker, hadError)
-      if (newString == nil)
-        if (hadError != nil) 
-          hadError[0] = true
+    
+    def writeParams(rpc)
+      write(CHUNK_TYPE_DATA)
+      
+      params = rpc.params  # Hash integer => object
+      if (!params.empty?)
+        params.each do |param|
+          if param.nil?
+            writeEmptyParam()
+          elsif param.class == String
+            writeStringParam(param)
+          elsif param.class == Array
+            writeArrayParam(param)
+          else
+            writeEmptyParam()
+          end
         end
-        break
+      else
+        writeEmptyParam()
       end
-      if (endMarker[0])
-        break
-      end
-      arrayList << newString
+      #No end marker. Chunk 5 is assumed to be the last.
     end
-    return arrayList
-  end
-  
-  
-  # readString uses array argument so can pass values back
-  def readString(endMarker, hadError) # returns...string!
-    if (endMarker != nil) 
-      endMarker[0] = !isConnected()
+    
+    def writeArrayParam(paramarray)
+      write(PARAM_LIST_MARKER)
+      size = paramarray.size
+      index = 0
+      paramarray.each do |v|
+        writeLPack(v[0])
+        writeLPack(v[1])
+        index += 1
+        if index !=size # looks like don't write a 't' after the last entry
+          write("t")
+        end
+      end
+      write("f")  
     end
-    if (hadError != nil) 
-      hadError[0] = !isConnected()
+    
+    def writeStringParam(string)
+      write(PARAM_LITERAL_MARKER)
+      writeLPack(string)
+      write("f")
     end
-    if (!isConnected())
-      return nil
+    
+    def writeEmptyParam() 
+      write(PARAM_EMPTY_MARKER)
+      write("f")
     end
-    buffer = String.new
-    gotCR = false
-    while true
-      byte = @socket.readbyte  # read one byte
-      if (byte == END_MARKER)
-        if (endMarker != nil) 
-          endMarker[0] = true
+    
+    def flush()
+      retVal = false
+      if (isConnected() || connect()) 
+        if @debug
+          puts "<Request>" + @writeBuffer + "</Request>"
         end
-        break
+        @socket.write(@writeBuffer)
+        @socket.flush
+        @writeBuffer = String.new
+        retVal = true
       end
-      if (gotCR && byte == 10)   # CR-LF
-        break
+      return retVal
+    end
+    
+    def getResponse(rpcType)
+      hadError = Array.new  # for passing around boolean by reference
+      hadError[0]=false
+      securityError = readSPack(hadError)
+      #puts "<SecurityError>" + securityError + "</SecurityError>"
+      if (hadError[0])
+        return nil
       end
-      if (byte == 13) 
-        gotCR = true
-      else 
-        if (gotCR) 
-          buffer << 13  # we got a CR without a LF, so keep it in.
-          gotCR = false
+      if (securityError.empty?)
+        securityError = nil
+      end
+      
+      otherError = readSPack(hadError)
+      if (hadError[0])
+        return nil
+      end
+      if (otherError.empty?)
+        otherError = nil
+      end
+      
+      retVal = nil
+      if (rpcType == RPCResponse::SINGLE_VALUE or rpcType == RPCResponse::GLOBAL_INSTANCE)
+        retVal = RPCResponse.new(readString(nil, hadError))
+        if (hadError[0])
+          return nil
+        end
+      elsif (rpcType == RPCResponse::GLOBAL_ARRAY or rpcType == RPCResponse::WORD_PROCESSING or rpcType == RPCResponse::ARRAY)
+        retVal = RPCResponse.new(readArray(hadError))
+        if (hadError[0]) 
+          return nil
         end
-        buffer << byte
       end
+      
+      if (retVal != nil && (otherError != nil || securityError != nil))
+        if (otherError != nil && securityError != nil)
+          retVal.error_message = otherError + "^" + securityError
+        elsif (otherError != nil) 
+          retVal.error_message = otherError
+        else 
+          retVal.error_message = securityError
+        end
+      end
+      return retVal
     end
-
-    retVal = buffer
-    return retVal
-  end
-
-  def readSPack(hadError)
-    if (hadError != nil) 
-      hadError[0] = false
+    
+    # returns array of string
+    def readArray(hadError)
+      if (hadError != nil)
+        hadError[0] = false
+      end
+      arrayList = Array.new
+      endMarker = Array.new
+      endMarker[0] = false
+      while true
+        newString = readString(endMarker, hadError)
+        if (newString == nil)
+          if (hadError != nil) 
+            hadError[0] = true
+          end
+          break
+        end
+        if (endMarker[0])
+          break
+        end
+        arrayList << newString
+      end
+      return arrayList
     end
-    len = @socket.readbyte  # read one byte into a fixnum
-    data = String.new
-    data = @socket.read(len)
-    return data
-  end
-
-  def execute(rpc)
-    retVal = executeOnce(rpc)
-    if (retVal == nil && @signedOn) 
-      #reconnect
-      if (rpc.name == "#BYE#")
-        # We're disconnecting anyway
+    
+    
+    # readString uses array argument so can pass values back
+    def readString(endMarker, hadError) # returns...string!
+      if (endMarker != nil) 
+        endMarker[0] = !isConnected()
+      end
+      if (hadError != nil) 
+        hadError[0] = !isConnected()
+      end
+      if (!isConnected())
         return nil
       end
-      # attempt to log back on
-      if (connect())
-        if (@currentContext != nil) 
-          context = !currentContext
-          @currentContext = nil
-          setContext(context)
+      buffer = String.new
+      gotCR = false
+      while true
+        byte = @socket.readbyte  # read one byte
+        if (byte == END_MARKER)
+          if (endMarker != nil) 
+            endMarker[0] = true
+          end
+          break
+        end
+        if (gotCR && byte == 10)   # CR-LF
+          break
+        end
+        if (byte == 13) 
+          gotCR = true
+        else 
+          if (gotCR) 
+            buffer << 13  # we got a CR without a LF, so keep it in.
+            gotCR = false
+          end
+          buffer << byte
         end
-        retVal = executeOnce(rpc)
       end
-    end
-    if (retVal == nil)
-      puts "Lost connection to server"
-    end
-    return retVal
-  end
-
-  def setContext(context)
-    if (context == @currentContext)
-      puts "context is already set to " + context + "..."
-      return
-    end
-    if (@currentContext != nil) 
-      puts "changing context from " + currentContext + " to " + context
+      
+      retVal = buffer
+      return retVal
     end
     
-    puts "Setting context to: " + context
-    xwbCreateContext = VistaRPC.new("XWB CREATE CONTEXT", RPCResponse::SINGLE_VALUE)
-    encryptedContext = xwbCreateContext.encrypt(context)
-    xwbCreateContext.params[0] = encryptedContext
-    response = execute(xwbCreateContext)
-    if (response == nil || response.error_message != nil)
-      puts "XWB CREATE CONTEXT failed: " + response.error_message
+    def readSPack(hadError)
+      if (hadError != nil) 
+        hadError[0] = false
+      end
+      len = @socket.readbyte  # read one byte into a fixnum
+      data = String.new
+      data = @socket.read(len)
+      return data
     end
-    @currentContext = context
-  end
-  
-  def getDUZ
-    return duz
+    
   end
-  
-end
 end

data/lib/vistarpc4r/rpc_response.rb

@@ -1,46 +1,55 @@
 module VistaRPC4r
-class RPCResponse
-  attr_accessor :type, :value, :error_message
-
-  SINGLE_VALUE = 1
-  GLOBAL_INSTANCE = 2
-  ARRAY = 3
-  GLOBAL_ARRAY=4
-  WORD_PROCESSING=5
-
-  def initialize(value=nil, type=nil)
-    if value.nil?
-      @type = SINGLE_VALUE
-      @value = nil
-    elsif value.class == String
-      @value = value
-      @type = SINGLE_VALUE
-    elsif value.class == Array
-      @value = value
-      @type = ARRAY
-    elsif !type.nil?
+  
+  #  Response object from RPC call
+  #  type = one of the constant types
+  #  value = String or Array of Strings representing the actual response
+  class RPCResponse
+    attr_accessor :type, :value, :error_message
+    
+    # Single string response
+    SINGLE_VALUE = 1
+    # Not sure, but is usually a string response
+    GLOBAL_INSTANCE = 2
+    #  Array of string response
+    ARRAY = 3
+    # Array of string response
+    GLOBAL_ARRAY=4
+    # Array of string response
+    WORD_PROCESSING=5
+    
+    def initialize(value=nil, type=nil)
+      if value.nil?
+        @type = SINGLE_VALUE
+        @value = nil
+      elsif value.class == String
+        @value = value
+        @type = SINGLE_VALUE
+      elsif value.class == Array
       @value = value
-      @type = type
+        @type = ARRAY
+      elsif !type.nil?
+        @value = value
+        @type = type
+      end
+      @error_message = nil
     end
-    @error_message = nil
-  end
-  
-  def to_s
-    sb = String.new
-    if !@error_message.nil?
-      sb << "ERROR: "
-      sb << @error_message
-    elsif @value.nil?
-      sb << "No value or error"
-    elsif @value.class == Array 
-      sb = "ARRAY:" + value.join("|")
-    elsif @value.class == String
-      sb = "STRING:" + value.to_s
-    else 
-      sb << "Unknown value type"
+    
+    def to_s
+      sb = String.new
+      if !@error_message.nil?
+        sb << "ERROR: "
+        sb << @error_message
+      elsif @value.nil?
+        sb << "No value or error"
+      elsif @value.class == Array 
+        sb = "ARRAY:" + value.join("|")
+      elsif @value.class == String
+        sb = "STRING:" + value.to_s
+      else 
+        sb << "Unknown value type"
+      end
+      return sb
     end
-    return sb
   end
-end
 
 end

data/lib/vistarpc4r/vista_rpc.rb

@@ -1,36 +1,42 @@
 # the 'Request' of the RPC request/response.  Stores the command or api call, and arguments
 module VistaRPC4r
-class VistaRPC 
-    attr_accessor :name, :type, :isCommand, :params
 
+  # Request object for the RPC call.  It contains:
+  # name = string containing name of the RPC
+  # type = The response type from RPCResponse
+  # param = Array of parameters - This is 0-based.  Delphi and Ovid code refer to 1-based
+  # isCommand = Is this a command, usually false
+  class VistaRPC 
+    attr_accessor :name, :type, :isCommand, :params
+    
     def initialize(name, type=RPCResponse::SINGLE_VALUE, isCommand=false)
       @name=name  # string
       @type=type # response type
       @params=Array.new #  params = new TreeMap<Integer, Object>();
       @isCommand=isCommand # boolean
       @cipher = [
-        "wkEo-ZJt!dG)49K{nX1BS$vH<&:Myf*>Ae0jQW=;|#PsO`'%+rmb[gpqN,l6/hFC@DcUa ]z~R}\"V\\iIxu?872.(TYL5_3",
-        "rKv`R;M/9BqAF%&tSs#Vh)dO1DZP> *fX'u[.4lY=-mg_ci802N7LTG<]!CWo:3?{+,5Q}(@jaExn$~p\\IyHwzU\"|k6Jeb",
-        "\\pV(ZJk\"WQmCn!Y,y@1d+~8s?[lNMxgHEt=uw|X:qSLjAI*}6zoF{T3#;ca)/h5%`P4$r]G'9e2if_>UDKb7<v0&- RBO.",
-        "depjt3g4W)qD0V~NJar\\B \"?OYhcu[<Ms%Z`RIL_6:]AX-zG.#}$@vk7/5x&*m;(yb2Fn+l'PwUof1K{9,|EQi>H=CT8S!",
-        "NZW:1}K$byP;jk)7'`x90B|cq@iSsEnu,(l-hf.&Y_?J#R]+voQXU8mrV[!p4tg~OMez CAaGFD6H53%L/dT2<*>\"{\\wI=",
-        "vCiJ<oZ9|phXVNn)m K`t/SI%]A5qOWe\\&?;jT~M!fz1l>[D_0xR32c*4.P\"G{r7}E8wUgyudF+6-:B=$(sY,LkbHa#'@Q",
-        "hvMX,'4Ty;[a8/{6l~F_V\"}qLI\\!@x(D7bRmUH]W15J%N0BYPkrs&9:$)Zj>u|zwQ=ieC-oGA.#?tfdcO3gp`S+En K2*<",
-        "jd!W5[];4'<C$/&x|rZ(k{>?ghBzIFN}fAK\"#`p_TqtD*1E37XGVs@0nmSe+Y6Qyo-aUu%i8c=H2vJ\\) R:MLb.9,wlO~P",
-        "2ThtjEM+!=xXb)7,ZV{*ci3\"8@_l-HS69L>]\\AUF/Q%:qD?1~m(yvO0e'<#o$p4dnIzKP|`NrkaGg.ufCRB[; sJYwW}5&",
-        "vB\\5/zl-9y:Pj|=(R'7QJI *&CTX\"p0]_3.idcuOefVU#omwNZ`$Fs?L+1Sk<,b)hM4A6[Y%aDrg@~KqEW8t>H};n!2xG{",
-        "sFz0Bo@_HfnK>LR}qWXV+D6`Y28=4Cm~G/7-5A\\b9!a#rP.l&M$hc3ijQk;),TvUd<[:I\"u1'NZSOw]*gxtE{eJp|y (?%",
-        "M@,D}|LJyGO8`$*ZqH .j>c~h<d=fimszv[#-53F!+a;NC'6T91IV?(0x&/{B)w\"]Q\\YUWprk4:ol%g2nE7teRKbAPuS_X",
-        ".mjY#_0*H<B=Q+FML6]s;r2:e8R}[ic&KA 1w{)vV5d,$u\"~xD/Pg?IyfthO@CzWp%!`N4Z'3-(o|J9XUE7k\\TlqSb>anG",
-        "xVa1']_GU<X`|\\NgM?LS9{\"jT%s$}y[nvtlefB2RKJW~(/cIDCPow4,>#zm+:5b@06O3Ap8=*7ZFY!H-uEQk; .q)i&rhd",
-        "I]Jz7AG@QX.\"%3Lq>METUo{Pp_ |a6<0dYVSv8:b)~W9NK`(r'4fs&wim\\kReC2hg=HOj$1B*/nxt,;c#y+![?lFuZ-5D}",
-        "Rr(Ge6F Hx>q$m&C%M~Tn,:\"o'tX/*yP.{lZ!YkiVhuw_<KE5a[;}W0gjsz3]@7cI2\\QN?f#4p|vb1OUBD9)=-LJA+d`S8",
-        "I~k>y|m};d)-7DZ\"Fe/Y<B:xwojR,Vh]O0Sc[`$sg8GXE!1&Qrzp._W%TNK(=J 3i*2abuHA4C'?Mv\\Pq{n#56LftUl@9+",
-        "~A*>9 WidFN,1KsmwQ)GJM{I4:C%}#Ep(?HB/r;t.&U8o|l['Lg\"2hRDyZ5`nbf]qjc0!zS-TkYO<_=76a\\X@$Pe3+xVvu",
-        "yYgjf\"5VdHc#uA,W1i+v'6|@pr{n;DJ!8(btPGaQM.LT3oe?NB/&9>Z`-}02*%x<7lsqz4OS ~E$\\R]KI[:UwC_=h)kXmF",
-        "5:iar.{YU7mBZR@-K|2 \"+~`M%8sq4JhPo<_X\\Sg3WC;Tuxz,fvEQ1p9=w}FAI&j/keD0c?)LN6OHV]lGy'$*>nd[(tb!#" ]
+                 "wkEo-ZJt!dG)49K{nX1BS$vH<&:Myf*>Ae0jQW=;|#PsO`'%+rmb[gpqN,l6/hFC@DcUa ]z~R}\"V\\iIxu?872.(TYL5_3",
+                 "rKv`R;M/9BqAF%&tSs#Vh)dO1DZP> *fX'u[.4lY=-mg_ci802N7LTG<]!CWo:3?{+,5Q}(@jaExn$~p\\IyHwzU\"|k6Jeb",
+                 "\\pV(ZJk\"WQmCn!Y,y@1d+~8s?[lNMxgHEt=uw|X:qSLjAI*}6zoF{T3#;ca)/h5%`P4$r]G'9e2if_>UDKb7<v0&- RBO.",
+                 "depjt3g4W)qD0V~NJar\\B \"?OYhcu[<Ms%Z`RIL_6:]AX-zG.#}$@vk7/5x&*m;(yb2Fn+l'PwUof1K{9,|EQi>H=CT8S!",
+                 "NZW:1}K$byP;jk)7'`x90B|cq@iSsEnu,(l-hf.&Y_?J#R]+voQXU8mrV[!p4tg~OMez CAaGFD6H53%L/dT2<*>\"{\\wI=",
+                 "vCiJ<oZ9|phXVNn)m K`t/SI%]A5qOWe\\&?;jT~M!fz1l>[D_0xR32c*4.P\"G{r7}E8wUgyudF+6-:B=$(sY,LkbHa#'@Q",
+                 "hvMX,'4Ty;[a8/{6l~F_V\"}qLI\\!@x(D7bRmUH]W15J%N0BYPkrs&9:$)Zj>u|zwQ=ieC-oGA.#?tfdcO3gp`S+En K2*<",
+                 "jd!W5[];4'<C$/&x|rZ(k{>?ghBzIFN}fAK\"#`p_TqtD*1E37XGVs@0nmSe+Y6Qyo-aUu%i8c=H2vJ\\) R:MLb.9,wlO~P",
+                 "2ThtjEM+!=xXb)7,ZV{*ci3\"8@_l-HS69L>]\\AUF/Q%:qD?1~m(yvO0e'<#o$p4dnIzKP|`NrkaGg.ufCRB[; sJYwW}5&",
+                 "vB\\5/zl-9y:Pj|=(R'7QJI *&CTX\"p0]_3.idcuOefVU#omwNZ`$Fs?L+1Sk<,b)hM4A6[Y%aDrg@~KqEW8t>H};n!2xG{",
+                 "sFz0Bo@_HfnK>LR}qWXV+D6`Y28=4Cm~G/7-5A\\b9!a#rP.l&M$hc3ijQk;),TvUd<[:I\"u1'NZSOw]*gxtE{eJp|y (?%",
+                 "M@,D}|LJyGO8`$*ZqH .j>c~h<d=fimszv[#-53F!+a;NC'6T91IV?(0x&/{B)w\"]Q\\YUWprk4:ol%g2nE7teRKbAPuS_X",
+                 ".mjY#_0*H<B=Q+FML6]s;r2:e8R}[ic&KA 1w{)vV5d,$u\"~xD/Pg?IyfthO@CzWp%!`N4Z'3-(o|J9XUE7k\\TlqSb>anG",
+                 "xVa1']_GU<X`|\\NgM?LS9{\"jT%s$}y[nvtlefB2RKJW~(/cIDCPow4,>#zm+:5b@06O3Ap8=*7ZFY!H-uEQk; .q)i&rhd",
+                 "I]Jz7AG@QX.\"%3Lq>METUo{Pp_ |a6<0dYVSv8:b)~W9NK`(r'4fs&wim\\kReC2hg=HOj$1B*/nxt,;c#y+![?lFuZ-5D}",
+                 "Rr(Ge6F Hx>q$m&C%M~Tn,:\"o'tX/*yP.{lZ!YkiVhuw_<KE5a[;}W0gjsz3]@7cI2\\QN?f#4p|vb1OUBD9)=-LJA+d`S8",
+                 "I~k>y|m};d)-7DZ\"Fe/Y<B:xwojR,Vh]O0Sc[`$sg8GXE!1&Qrzp._W%TNK(=J 3i*2abuHA4C'?Mv\\Pq{n#56LftUl@9+",
+                 "~A*>9 WidFN,1KsmwQ)GJM{I4:C%}#Ep(?HB/r;t.&U8o|l['Lg\"2hRDyZ5`nbf]qjc0!zS-TkYO<_=76a\\X@$Pe3+xVvu",
+                 "yYgjf\"5VdHc#uA,W1i+v'6|@pr{n;DJ!8(btPGaQM.LT3oe?NB/&9>Z`-}02*%x<7lsqz4OS ~E$\\R]KI[:UwC_=h)kXmF",
+                 "5:iar.{YU7mBZR@-K|2 \"+~`M%8sq4JhPo<_X\\Sg3WC;Tuxz,fvEQ1p9=w}FAI&j/keD0c?)LN6OHV]lGy'$*>nd[(tb!#" ]
     end
-
+    
     def encrypt(orig_string)
       ra = rand(19)
       rb = rand(19)
@@ -41,7 +47,7 @@ class VistaRPC
       cb = @cipher[rb]
       len = orig_string.length
       pos = 0;
-
+      
       buffer = String.new
       buffer << ra+32
       for i in 0..(len-1)
@@ -56,44 +62,44 @@ class VistaRPC
       buffer << rb + 32
       return buffer
     end
-
+    
     def to_s
       sb = String.new
       sb << @name + ":"
       sb << @params.to_s
       return sb
     end
-
-#    @Override
+    
+    #    @Override
 #    public boolean equals(Object obj) {
-#        if (obj == null) {
-#            return false;
-#        }
-#        if (getClass() != obj.getClass()) {
-#            return false;
-#        }
+    #        if (obj == null) {
+    #            return false;
+    #        }
+    #        if (getClass() != obj.getClass()) {
+    #            return false;
+    #        }
 #        final VistaRPC other = (VistaRPC) obj;
-#        if ((this.name == null) ? (other.name != null) : !this.name.equals(other.name)) {
-#            return false;
-#        }
-#        if (this.type != other.type) {
-#            return false;
-#        }
-#        if (this.params != other.params && (this.params == null || !this.params.equals(other.params))) {
+    #        if ((this.name == null) ? (other.name != null) : !this.name.equals(other.name)) {
+    #            return false;
+    #        }
+    #        if (this.type != other.type) {
 #            return false;
+    #        }
+    #        if (this.params != other.params && (this.params == null || !this.params.equals(other.params))) {
+    #            return false;
 #        }
-#        return true;
-#    }
-
-#    @Override
-#    public int hashCode() {
+    #        return true;
+    #    }
+    
+    #    @Override
+    #    public int hashCode() {
 #        int hash = 3;
-#        hash = 29 * hash + (this.name != null ? this.name.hashCode() : 0);
-#        hash = 29 * hash + (this.type != null ? this.type.hashCode() : 0);
-#        hash = 29 * hash + (this.params != null ? this.params.hashCode() : 0);
-#        return hash;
-#    }
+    #        hash = 29 * hash + (this.name != null ? this.name.hashCode() : 0);
+    #        hash = 29 * hash + (this.type != null ? this.type.hashCode() : 0);
+    #        hash = 29 * hash + (this.params != null ? this.params.hashCode() : 0);
+    #        return hash;
+    #    }
 
-
-end
+    
+  end
 end

data/vistarpc4r.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{vistarpc4r}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mike Cham"]
-  s.date = %q{2011-05-26}
+  s.date = %q{2011-05-27}
   s.description = %q{more}
   s.email = %q{mike@blenderhouse.com}
   s.extra_rdoc_files = [

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: vistarpc4r
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Mike Cham
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-26 00:00:00 -04:00
+date: 2011-05-27 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency