allscripts_unity_client 1.0.3

data/lib/allscripts_unity_client/client_driver.rb

@@ -0,0 +1,95 @@
+require 'logger'
+
+module AllscriptsUnityClient
+  class ClientDriver
+    LOG_FILE = "logs/unity_client.log"
+
+    attr_accessor :username, :password, :appname, :base_unity_url, :proxy, :security_token, :timezone, :logger, :log
+
+    def initialize(base_unity_url, username, password, appname, proxy = nil, timezone = nil, logger = nil, log = true)
+      raise ArgumentError, "base_unity_url can not be nil" if base_unity_url.nil?
+      raise ArgumentError, "username can not be nil" if username.nil?
+      raise ArgumentError, "password can not be nil" if password.nil?
+      raise ArgumentError, "appname can not be nil" if appname.nil?
+
+      @base_unity_url = base_unity_url.gsub /\/$/, ""
+      @username = username
+      @password = password
+      @appname = appname
+      @proxy = proxy
+      @log = log
+
+      if logger.nil?
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::INFO
+      else
+        @logger = logger
+      end
+
+      unless timezone.nil?
+        @timezone = Timezone.new(timezone)
+      else
+        @timezone = Timezone.new("UTC")
+      end
+    end
+
+    def security_token?
+      return !@security_token.nil?
+    end
+
+    def log?
+      return @log
+    end
+
+    def client_type
+      return :none
+    end
+
+    def magic(parameters = {})
+      raise NotImplementedError, "magic not implemented"
+    end
+
+    def get_security_token!(parameters = {})
+      raise NotImplementedError, "get_security_token! not implemented"
+    end
+
+    def retire_security_token!(parameters = {})
+      raise NotImplementedError, "retire_security_token! not implemented"
+    end
+
+    protected
+
+    def log_get_security_token
+      message = "Unity API GetSecurityToken request to #{@base_unity_url}"
+      log_info(message)
+    end
+
+    def log_retire_security_token
+      message = "Unity API RetireSecurityToken request to #{@base_unity_url}"
+      log_info(message)
+    end
+
+    def log_magic(request)
+      raise ArgumentError, "request can not be nil" if request.nil?
+      message = "Unity API Magic request to #{@base_unity_url} [#{request.parameters[:action]}]"
+      log_info(message)
+    end
+
+    def log_info(message)
+      if log? && !logger.nil? && !message.nil?
+        message += " #{@timer} seconds" unless @timer.nil?
+        @timer = nil
+        logger.info(message)
+      end
+    end
+
+    def start_timer
+      @start_time = Time.now.utc
+    end
+
+    def end_timer
+      @end_time = Time.now.utc
+      @timer = @end_time - @start_time
+    end
+  end
+end

data/lib/allscripts_unity_client/json_client_driver.rb

@@ -0,0 +1,110 @@
+require "json"
+require "httpi"
+
+module AllscriptsUnityClient
+  class JSONClientDriver < ClientDriver
+    attr_accessor :json_base_url
+
+    UNITY_JSON_ENDPOINT = "/Unity/UnityService.svc/json"
+
+    def initialize(base_unity_url, username, password, appname, proxy = nil, timezone = nil, logger = nil, log = true)
+      super
+
+      # Disable HTTPI logging
+      HTTPI.log = false
+
+      @json_base_url = "#{@base_unity_url}#{UNITY_JSON_ENDPOINT}"
+    end
+
+    def client_type
+      return :json
+    end
+
+    def magic(parameters = {})
+      request_data = JSONUnityRequest.new(parameters, @timezone, @appname, @security_token)
+      request = create_httpi_request("#{@json_base_url}/MagicJson", request_data.to_hash)
+
+      start_timer
+      response = HTTPI.post(request)
+      end_timer
+
+      response = JSON.parse(response.body)
+
+      raise_if_response_error(response)
+      log_magic(request_data)
+
+      response = JSONUnityResponse.new(response, @timezone)
+      response.to_hash
+    end
+
+    def get_security_token!(parameters = {})
+      username = parameters[:username] || @username
+      password = parameters[:password] || @password
+      appname = parameters[:appname] || @appname
+
+      request_data = {
+        "Username" => username,
+        "Password" => password,
+        "Appname" => appname
+      }
+      request = create_httpi_request("#{@json_base_url}/GetToken", request_data)
+
+      start_timer
+      response = HTTPI.post(request, :net_http_persistent)
+      end_timer
+
+      raise_if_response_error(response.body)
+      log_get_security_token
+
+      @security_token = response.body
+    end
+
+    def retire_security_token!(parameters = {})
+      token = parameters[:token] || @security_token
+      appname = parameters[:appname] || @appname
+
+      request_data = {
+        "Token" => token,
+        "Appname" => appname
+      }
+      request = create_httpi_request("#{@json_base_url}/RetireSecurityToken", request_data)
+
+      start_timer
+      response = HTTPI.post(request, :net_http_persistent)
+      end_timer
+
+      raise_if_response_error(response.body)
+      log_retire_security_token
+
+      @security_token = nil
+    end
+
+    private
+
+    def create_httpi_request(url, data)
+      request = HTTPI::Request.new
+      request.url = url
+      request.headers = {
+        "Accept-Encoding" => "gzip,deflate",
+        "Content-type" => "application/json;charset=utf-8"
+      }
+      request.body = JSON.generate(data)
+
+      unless @proxy.nil?
+        request.proxy = @proxy
+      end
+
+      request
+    end
+
+    def raise_if_response_error(response)
+      if response.nil?
+        raise APIError, "Response was empty"
+      elsif response.is_a?(Array) && !response[0]["Error"].nil?
+        raise APIError, response[0]["Error"]
+      elsif response.is_a?(String) && response.include?("error:")
+        raise APIError, response
+      end
+    end
+  end
+end

data/lib/allscripts_unity_client/json_unity_request.rb

@@ -0,0 +1,33 @@
+module AllscriptsUnityClient
+  class JSONUnityRequest < UnityRequest
+    def to_hash
+      action = @parameters[:action]
+      userid = @parameters[:userid]
+      appname = @parameters[:appname] || @appname
+      patientid = @parameters[:patientid]
+      token = @parameters[:token] || @security_token
+      parameter1 = process_date(@parameters[:parameter1]) || ""
+      parameter2 = process_date(@parameters[:parameter2]) || ""
+      parameter3 = process_date(@parameters[:parameter3]) || ""
+      parameter4 = process_date(@parameters[:parameter4]) || ""
+      parameter5 = process_date(@parameters[:parameter5]) || ""
+      parameter6 = process_date(@parameters[:parameter6]) || ""
+      data = Utilities::encode_data(@parameters[:data]) || ""
+
+      return {
+        "Action" => action,
+        "AppUserID" => userid,
+        "Appname" => appname,
+        "PatientID" => patientid,
+        "Token" => token,
+        "Parameter1" => parameter1,
+        "Parameter2" => parameter2,
+        "Parameter3" => parameter3,
+        "Parameter4" => parameter4,
+        "Parameter5" => parameter5,
+        "Parameter6" => parameter6,
+        "Data" => data
+      }
+    end
+  end
+end

data/lib/allscripts_unity_client/json_unity_response.rb

@@ -0,0 +1,27 @@
+require "json"
+
+module AllscriptsUnityClient
+  class JSONUnityResponse < UnityResponse
+    def to_hash
+      result = @response
+
+      # All JSON magic responses are an array with one item
+      result = result.first
+
+      # All JSON magic results contain one key on their object named
+      # actioninfo
+      result = result.values.first
+
+      # The data in a JSON magic result is always an array. If that array
+      # only has a single item, then just return that as the result. This is
+      # a compromise as some actions that should always return arrays
+      # (i.e. GetProviders) may return a single hash.
+      if result.count == 1
+        result = result.first
+      end
+
+      result = convert_dates_to_utc(result)
+      Utilities::recursively_symbolize_keys(result)
+    end
+  end
+end

data/lib/allscripts_unity_client/soap_client_driver.rb

@@ -0,0 +1,128 @@
+require "savon"
+
+module AllscriptsUnityClient
+  class SOAPClientDriver < ClientDriver
+    attr_accessor :savon_client
+
+    UNITY_SOAP_ENDPOINT = "/Unity/UnityService.svc/unityservice"
+    UNITY_ENDPOINT_NAMESPACE = "http://www.allscripts.com/Unity/IUnityService"
+
+    def initialize(base_unity_url, username, password, appname, proxy = nil, timezone = nil, logger = nil, log = true)
+      super
+
+      client_proxy = @proxy
+      base_unity_url = "#{@base_unity_url}#{UNITY_SOAP_ENDPOINT}"
+
+      @savon_client = Savon.client do
+        # Removes the wsdl: namespace from body elements in the SOAP
+        # request. Unity doesn't recognize elements otherwise.
+        namespace_identifier nil
+
+        # Manually registers SOAP endpoint since Unity WSDL is not very
+        # good.
+        endpoint base_unity_url
+
+        # Manually register SOAP namespace. This URL isn't live, but the
+        # internal SOAP endpoints expect it.
+        namespace "http://www.allscripts.com/Unity"
+
+        # Register proxy with Savon if one was given.
+        unless client_proxy.nil?
+          proxy client_proxy
+        end
+
+        # Unity expects the SOAP envelop to be namespaced with soap:
+        env_namespace :soap
+
+        # Unity uses Microsoft style CamelCase for keys. Only really useful when using
+        # symbol keyed hashes.
+        convert_request_keys_to :camelcase
+
+        # Enable gzip on HTTP responses. Unity does not currently support this
+        # as of Born On 10/7/2013, but it doesn't hurt to future-proof. If gzip
+        # is ever enabled, this library will get a speed bump for free.
+        headers({ "Accept-Encoding" => "gzip,deflate" })
+
+        # Disable Savon logs
+        log false
+      end
+    end
+
+    def client_type
+      return :soap
+    end
+
+    def magic(parameters = {})
+      request_data = UnityRequest.new(parameters, @timezone,  @appname, @security_token)
+      call_data = {
+        :message => request_data.to_hash,
+        :soap_action => "#{UNITY_ENDPOINT_NAMESPACE}/Magic"
+      }
+
+      begin
+        start_timer
+        response = @savon_client.call("Magic", call_data)
+        end_timer
+      rescue Savon::SOAPFault => e
+        raise APIError, e.message
+      end
+
+      log_magic(request_data)
+
+      response = UnityResponse.new(response.body, @timezone)
+      response.to_hash
+    end
+
+    def get_security_token!(parameters = {})
+      username = parameters[:username] || @username
+      password = parameters[:password] || @password
+      appname = parameters[:appname] || @appname
+
+      call_data = {
+        :message => {
+          "Username" => username,
+          "Password" => password,
+          "Appname" => appname
+        },
+        :soap_action => "#{UNITY_ENDPOINT_NAMESPACE}/GetSecurityToken"
+      }
+
+      begin
+        start_timer
+        response = @savon_client.call("GetSecurityToken", call_data)
+        end_timer
+      rescue Savon::SOAPFault => e
+        raise APIError, e.message
+      end
+
+      log_get_security_token
+
+      @security_token = response.body[:get_security_token_response][:get_security_token_result]
+    end
+
+    def retire_security_token!(parameters = {})
+      token = parameters[:token] || @security_token
+      appname = parameters[:appname] || @appname
+
+      call_data = {
+        :message => {
+          "Token" => token,
+          "Appname" => appname
+        },
+        :soap_action => "#{UNITY_ENDPOINT_NAMESPACE}/RetireSecurityToken"
+      }
+
+      begin
+        start_timer
+        @savon_client.call("RetireSecurityToken", call_data)
+        end_timer
+      rescue Savon::SOAPFault => e
+        raise APIError, e.message
+      end
+
+      log_retire_security_token
+
+      @security_token = nil
+    end
+  end
+end

data/lib/allscripts_unity_client/timezone.rb

@@ -0,0 +1,99 @@
+require "date"
+require "tzinfo"
+
+module AllscriptsUnityClient
+  class Timezone
+    attr_accessor :tzinfo
+
+    def initialize(zone_identifier)
+      raise ArgumentError, "zone_identifier can not be nil" if zone_identifier.nil?
+
+      @tzinfo = TZInfo::Timezone.get(zone_identifier)
+    end
+
+    # Use TZInfo to convert a given UTC datetime into
+    # a local
+    def local_to_utc(datetime)
+      convert_with_timezone(:local_to_utc, datetime)
+    end
+
+    def utc_to_local(datetime = nil)
+      convert_with_timezone(:utc_to_local, datetime)
+    end
+
+    private
+
+    # Direction can be :utc_to_local or :local_to_utc
+    def convert_with_timezone(direction, datetime = nil)
+      if datetime.nil?
+        return nil
+      end
+
+      # Dates have no time information and so timezone conversion
+      # doesn't make sense. Just return the date in this case.
+      if datetime.instance_of?(Date)
+        return datetime
+      end
+
+      if datetime.instance_of?(String)
+        datetime = DateTime.parse(datetime.to_s)
+      end
+
+      is_datetime = datetime.instance_of?(DateTime)
+
+      if direction == :local_to_utc
+        if is_datetime
+          # DateTime can do UTC conversions reliably, so use that instead of
+          # TZInfo
+          datetime = datetime.new_offset(0)
+        else
+          datetime = @tzinfo.local_to_utc(datetime)
+        end
+
+        if is_datetime
+          # Convert to a DateTime with a UTC offset
+          datetime = DateTime.parse("#{datetime.strftime("%FT%T")}Z")
+        end
+      end
+
+      if direction == :utc_to_local
+        datetime = @tzinfo.utc_to_local(datetime)
+
+        if is_datetime
+          # Convert to a DateTime with the correct timezone offset
+          datetime = DateTime.parse(iso8601_with_offset(datetime))
+        end
+      end
+
+      return datetime
+    end
+
+    # TZInfo does not correctly update a DateTime's
+    # offset, so we manually format a ISO8601 with
+    # the correct format
+    def iso8601_with_offset(datetime)
+      if datetime.nil?
+        return nil
+      end
+
+      offset = @tzinfo.current_period.utc_offset
+      negative_offset = false
+      datetime_string = datetime.strftime("%FT%T")
+
+      if offset < 0
+        offset *= -1
+        negative_offset = true
+      end
+
+      if offset == 0
+        offset_string = "Z"
+      else
+        offset_string = Time.at(offset).utc.strftime("%H:%M")
+        offset_string = "-" + offset_string if negative_offset
+        offset_string = "+" + offset_string unless negative_offset
+      end
+
+      "#{datetime_string}#{offset_string}"
+    end
+  end
+end