quickbooks 0.4.0 → 0.9.9

data/lib/quickbooks/adaptability.rb

@@ -0,0 +1,67 @@
+module Kernel
+  def try_retry(times, *exception_classes)
+    options = exception_classes.last.is_a?(Hash) ? exception_classes.pop : {}
+    raise ArgumentError unless block_given?
+    retried = 0
+    begin
+      yield
+    rescue *exception_classes => e
+      puts "Error: #{e.inspect}. Retrying..." if $DEBUG
+      options[:before_retry].call if options[:before_retry]
+      retried += 1
+      if retried < 2
+        retry
+      else
+        raise e, "(Retried once)"
+      end
+    end
+  end
+end
+
+module Quickbooks
+  module Adaptability
+    def self.extended(base)
+      base.send(:class_variable_set, :@@connection_adapter, nil)
+    end
+
+    def use_adapter(adapter, *args)
+      # Should complain if the adapter doesn't exist.
+      @@connection_adapter = try_retry(1, NameError, :before_retry => lambda {require "quickbooks/adapters/#{adapter.to_s}_adapter"}) {
+        Object.module_eval("::Quickbooks::Adapters::#{adapter.to_s.camel_case}Adapter::Connection", __FILE__, __LINE__)
+      }
+      @@connection ||= nil
+      @connection ||= nil
+      @@connection.close if @@connection
+      @connection.close if @connection
+      @@connection = @connection = nil
+      @@connection_args = args
+      return @@connection_adapter
+    end
+
+    # Establishes a connection to the Quickbooks API
+    def establish_connection(*args)
+      @@connection_adapter ||= use_adapter(:spew)
+      @@connection = @@connection_adapter.new(*args)
+    end
+
+    # Returns the current Connection
+    def connection
+      @@connection_args ||= []
+      (@connection ||= nil) || (@@connection ||= self.establish_connection(*(@@connection_args)))
+    end
+
+    # Sets the current Connection.
+    # 
+    # This is normally not needed, but in the case that you may want to connect a separate connection to Quickbooks,
+    # you can use this method to explicitly set the connection in a class that inherits from Quickbooks::Base.
+    #   Quickbooks::Base.connection = Quickbooks::Connection.new('My Test App', 'C:\\Some File.QBW', 'user', 'pass')
+    def connection=(conn)
+      raise ArgumentError, "Cannot set connection to anything but a (*)Adapter::Connection object" unless conn.class.name =~ /Adapter::Connection$/
+      @connection = conn
+    end
+
+    def connected?
+      @connection.nil? ? false : @connection.connected?
+    end
+  end
+end

data/lib/quickbooks/adapters/http_adapter.rb

@@ -0,0 +1,94 @@
+require 'net/http'
+require 'base64'
+
+module Kernel
+  def try_retry(times, *exception_classes)
+    options = exception_classes.last.is_a?(Hash) ? exception_classes.pop : {}
+    raise ArgumentError unless block_given?
+    retried = 0
+    begin
+      yield
+    rescue *exception_classes => e
+      puts "Error: #{e.inspect}. Retrying..." if $DEBUG
+      options[:before_retry].call if options[:before_retry]
+      retried += 1
+      if retried < 2
+        retry
+      else
+        raise e, "(Retried once)"
+      end
+    end
+  end
+end
+
+# This adapter sends QBXML via an HTTP connection which is kept open for each session, and expects intelligent real-time QB responses from the other end.
+module Quickbooks
+  module Adapters
+    module HttpAdapter
+      # Whatever we do here, we just have to be sure that decrypt(encrypt(data)) == data
+      module SimpleEncryption
+        def encrypt(data)
+          data
+        end
+
+        def decrypt(data)
+          data
+        end
+      end
+
+      class Connection
+        include SimpleEncryption
+        def initialize(host, username, password)
+          host, port = host.split(/:/,2) if host =~ /:/
+          port = nil if port == ''
+          @host = host
+          @port = port || 56225
+          @username = username
+          @password = password
+        end
+
+        # Returns true if there is an open connection to Quickbooks, false if not. Use session? to determine an open session.
+        def connected?
+          (@connection ||= new_connection).started?
+        end
+
+        def close
+          @connection.finish rescue nil
+        end
+
+        # Sends a request to Quickbooks. This request should be a valid QBXML request. Use Qbxml::Request to generate valid requests.
+        def send_xml(xml)
+          # TODO: request.basic_auth url.user, url.password
+          res = try_retry(1, EOFError, :before_retry => lambda {@connection.finish}) {
+            connection.post('/ProcessRequest', encrypt(xml), {'Content-Type' => 'application/xml', 'Authorization' => "Basic #{Base64.encode64(@username+':'+@password).gsub(/\n/,'')}"})
+          }
+          response = decrypt(res.body)
+          return response
+        # rescue => e
+          # Rescue from the error: I guess we have to return a pretend response that says the network failed.
+          # raise "Failsafe not yet implemented!: #{e.inspect}"
+        end
+
+        def qbxml_versions
+          res = try_retry(1, EOFError, :before_retry => lambda {@connection.finish}) { connection.get('/QBXMLVersionsForSession', {'Authorization' => "Basic #{Base64.encode64(@username+':'+@password).gsub(/\n/,'')}"}) }
+          response = decrypt(res.body)
+          return response.chomp.split(/,/)
+        end
+        def latest_qbxml_version
+          @latest_qbxml_version ||= qbxml_versions.sort.last
+        end
+
+        # Returns the active connection to Quickbooks, or creates a new one if none exists.
+        def connection
+          @connection.start unless connected?
+          @connection
+        end
+
+        private
+          def new_connection
+            Net::HTTP.new(@host, @port)
+          end
+      end
+    end
+  end
+end

data/lib/quickbooks/adapters/https_adapter.rb

@@ -0,0 +1,57 @@
+require 'net/https'
+require File.dirname(__FILE__) + '/http_adapter'
+
+module Quickbooks
+  module Adapters
+    module HttpsAdapter
+      # Whatever we do here, we just have to be sure that decrypt(encrypt(data)) == data
+      module SimpleEncryption
+        def encrypt(data)
+          data
+        end
+
+        def decrypt(data)
+          data
+        end
+      end
+
+      class Connection < HttpAdapter::Connection
+        private
+          def new_connection
+            root_ca_file = '/Users/daniel/Projects/qbonline/demoCA/cacert.pem'
+            http = Net::HTTP.new(@ip, @port)
+            http.use_ssl = true
+            if File.exist?(root_ca_file)
+              http.ca_file = root_ca_file
+              http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+              # http.verify_depth = 5
+              http.verify_depth = 5
+              http.enable_post_connection_check = false #true
+            else
+              http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            end
+            http
+          end
+      end
+    end
+  end
+end
+
+# Fixes the transfer-threading problem with net/http. I don't really need a timeout for this implementation.
+class ::Net::BufferedIO
+  private
+  def rbuf_fill
+    begin
+      @rbuf << @io.read_nonblock(4096)
+    rescue Errno::EWOULDBLOCK
+      if IO.select([@io], nil, nil, (@read_timeout ||= 5))
+        @rbuf << @io.read_nonblock(4096)
+      else
+        raise Timeout::TimeoutError
+      end
+    end
+  end
+end
+class ::OpenSSL::SSL::SSLSocket
+  alias :read_nonblock :readpartial
+end

data/lib/quickbooks/adapters/ole_adapter.rb

@@ -8,140 +8,171 @@ module Quickbooks
   # Quickbooks does not allow the user to close the company or exit the program until all outside applications are
   # disconnected from its API. Therefore, this class includes an at_exit hook that automatically closes all open
   # connections for you when your program exits.
-  module OleAdapter
-    class Ole
-      # Simply holds the actual OLE object.
-      attr_reader :ole
-
-      # Pass in the OLE name of the application you want connected to, and the name of a type library, if you need one.
-      def initialize(ole_app, type_library=nil)
-        @ole_app = ole_app
-        @type_library = type_library
-        @ole = WIN32OLE.new(ole_app)
-        self.classes
+  module Adapters
+    module OleAdapter
+      def self.debug!
+        @debug = true
       end
+      def self.debug?
+        @debug ||= false
+      end
+
+      class Ole
+        # Simply holds the actual OLE object.
+        attr_reader :ole
 
-      # Finds an OLE variable in the OLE type library, if you specified one in new().
-      # This navigates the OLE classes and constants for you and returns the variable that matches the _var_name_ you specify.
-      # This is used with Quickbooks to get the qbFileOpenDoNotCare parameter to pass to the OpenConnection2 method:
-      #   @quickbooks = Ole.new('QBXMLRP2.RequestProcessor', 'QBXMLRP2 1.0 Type Library')
-      #   @quickbooks.OpenConnection2('','Sample Application',@quickbooks.get_variable('localQBD'))
-      #   @session = @quickbooks.BeginSession('',@quickbooks.get_variable('qbFileOpenDoNotCare'))
-      #   ...
-      def get_variable(var_name)
-        return nil unless @type_library
-        self.classes.each do |class_name|
-          found = self.constant_for(class_name.name).variables.find {|var| var.name == var_name}
-          return found if found
+        # Pass in the OLE name of the application you want connected to, and the name of a type library, if you need one.
+        def initialize(ole_app, type_library=nil)
+          @ole_app = ole_app
+          @type_library = type_library
+          @ole = WIN32OLE.new(ole_app)
+          self.classes
         end
-      end
 
-      def classes #:nodoc:
-        return nil unless @type_library
-        @classes ||= WIN32OLE_TYPE.ole_classes(@type_library)
-      end
+        # Finds an OLE variable in the OLE type library, if you specified one in new().
+        # This navigates the OLE classes and constants for you and returns the variable that matches the _var_name_ you specify.
+        # This is used with Quickbooks to get the qbFileOpenDoNotCare parameter to pass to the OpenConnection2 method:
+        #   @quickbooks = Ole.new('QBXMLRP2.RequestProcessor', 'QBXMLRP2 1.0 Type Library')
+        #   @quickbooks.OpenConnection2('','Sample Application',@quickbooks.get_variable('localQBD'))
+        #   @session = @quickbooks.BeginSession('',@quickbooks.get_variable('qbFileOpenDoNotCare'))
+        #   ...
+        def get_variable(var_name)
+          return nil unless @type_library
+          self.classes.each do |class_name|
+            found = self.constant_for(class_name.name).variables.find {|var| var.name == var_name}
+            return found if found
+          end
+        end
 
-      def constant_for(class_name) #:nodoc:
-        return nil unless @type_library
-        @constant_for ||= {}
-        @constant_for[class_name] ||= WIN32OLE_TYPE.new(@type_library, class_name)
-      end
+        def classes #:nodoc:
+          return nil unless @type_library
+          @classes ||= WIN32OLE_TYPE.ole_classes(@type_library)
+        end
+
+        def constant_for(class_name) #:nodoc:
+          return nil unless @type_library
+          @constant_for ||= {}
+          @constant_for[class_name] ||= WIN32OLE_TYPE.new(@type_library, class_name)
+        end
 
-      # method_missing sends all other methods to the OLE object, so you can treat this object as your OLE object.
-      def method_missing(method_name, *args)
-        @ole.send(method_name, *args)
+        # method_missing sends all other methods to the OLE object, so you can treat this object as your OLE object.
+        def method_missing(method_name, *args)
+          @ole.send(method_name, *args)
+        end
       end
-    end
 
-    class Connection
-      class << self #:nodoc: all
-        def connections
-          @connections || (@connections = [])
+      class Connection
+        class << self #:nodoc: all
+          def connections
+            @connections ||= []
+          end
+          def connections=(v)
+            # raise ArgumentError, "Quickbooks::Connection.connections can only contain Quickbooks::Connection objects, but contains #{v.collect {|c| c.class.name}.uniq.join(', ')} objects" unless v.collect {|c| c.class.name}.uniq == ['Quickbooks::Connection']
+            @connections = v
+          end
+
+          at_exit do
+            Connection.connections.each do |conn|
+              conn.close rescue nil
+            end
+          end
         end
-        def connections=(v)
-          # raise ArgumentError, "Quickbooks::Connection.connections can only contain Quickbooks::Connection objects, but contains #{v.collect {|c| c.class.name}.uniq.join(', ')} objects" unless v.collect {|c| c.class.name}.uniq == ['Quickbooks::Connection']
-          @connections = v
+
+        # Initializes an instance of Quickbooks::Connection.
+        # - _application_name_ is required.
+        # - _file_ is optional, in which case the connection will be made to the currently open company file in the Quickbooks application.
+        # - _user_ and _password_ may be required if you have specified a specific file to open.
+        # - _connection_type_ can be one of: ['unknown', 'localQBD', 'remoteQBD', 'localQBDLaunchUI', 'remoteQBOE']
+        # - _connection_mode_ can be one of: ['SingleUser', 'MultiUser', 'DoNotCare']
+        def initialize(application_name='RubyApplication', file='', connection_type='localQBD', connection_mode='DoNotCare')
+          @file = file
+          @application_name = application_name
+          @quickbooks = Ole.new('QBXMLRP2.RequestProcessor', 'QBXMLRP2 1.0 Type Library')
+          @connection_type = @quickbooks.get_variable(connection_type)
+          @connection_mode = @quickbooks.get_variable('qbFileOpen'+connection_mode)
         end
 
-        at_exit do
-          Connection.connections.each do |conn|
-            conn.close
-          end
+        # Sets up the login to the QuickBooks company file.
+        def login(username, password)
+          @user = username
+          @password = password
         end
-      end
 
-      # Initializes an instance of Quickbooks::Connection.
-      # - _application_name_ is required.
-      # - _file_ is optional, in which case the connection will be made to the currently open company file in the Quickbooks application.
-      # - _user_ and _password_ may be required if you have specified a specific file to open.
-      # - _connection_type_ can be one of: ['unknown', 'localQBD', 'remoteQBD', 'localQBDLaunchUI', 'remoteQBOE']
-      # - _connection_mode_ can be one of: ['SingleUser', 'MultiUser', 'DoNotCare']
-      def initialize(application_name='RubyApplication', file='', user='', password='', connection_type='localQBD', connection_mode='DoNotCare')
-        @file = file
-        @user = user
-        @password = password
-        @application_name = application_name
-        @quickbooks = Ole.new('QBXMLRP2.RequestProcessor', 'QBXMLRP2 1.0 Type Library')
-        @connection_type = @quickbooks.get_variable(connection_type)
-        @connection_mode = @quickbooks.get_variable('qbFileOpen'+connection_mode)
-      end
+        # Returns true if there is an open connection to Quickbooks, false if not. Use session? to determine an open session.
+        def connected?
+          @connected ||= false
+        end
 
-      # Returns true if there is an open connection to Quickbooks, false if not. Use session? to determine an open session.
-      def connected?
-        @connected ||= false
-      end
+        # Close the connection to Quickbooks. Automatically ends the session, if there is one.
+        def close
+          end_session
+          if connected? && connection.CloseConnection.nil?
+            @connected = false
+            @connection = nil
+            Connection.connections = Connection.connections - [self]
+          end
+          return !@connected # Returns false if CloseConnection failed.
+        end
 
-      # Returns true if there is an active session. Use connected? to determine whether you are connected or not.
-      def session?
-        !@session.nil?
-      end
+        # Returns true if there is an active session. Use connected? to determine whether you are connected or not.
+        def session?
+          !@session.nil?
+        end
 
-      # Sends a request to Quickbooks. This request should be a valid QBXML request. Use Qbxml::Request to generate valid requests.
-      def send_xml(xml)
-        connection.ProcessRequest(session, xml)
-      rescue => e
-        warn "ERROR processing request:\n#{xml}"
-        raise # Reraises the original error, only this way we got the xml output
-      end
+        # Sends a request to Quickbooks. This request should be a valid QBXML request. Use Qbxml::Request to generate valid requests.
+        def send_xml(xml)
+          warn "Sending XML:\n#{xml}" if OleAdapter.debug?
+          connection.ProcessRequest(session, xml)
+        rescue => e
+          raise e, "ERROR processing request:\n#{xml}\n -> #{e.inspect}" # Reraises the original error, only this way we got the xml output
+        end
 
-      # Returns the active connection to Quickbooks, or creates a new one if none exists.
-      def connection
-        @connection || begin
-          @connection = @quickbooks.ole
-          @connection.OpenConnection2('',@application_name,@connection_type)
-          Connection.connections << self
-          @connected = true
-          @connection
+        # Check the version of QB
+        def qbxml_versions
+          connection.QBXMLVersionsForSession(session)
+        end
+        def latest_qbxml_version
+          @latest_qbxml_version ||= qbxml_versions.sort.last
         end
-      end
 
-      # Begin a session to Quickbooks.
-      def session
-        @session || begin
-          @session = connection.BeginSession(@file,@connection_mode)
+        # Returns the active connection to Quickbooks, or creates a new one if none exists.
+        def connection
+          (@connection ||= nil) || begin
+            @connection = @quickbooks.ole
+            begin
+              @connection.OpenConnection2('123',@application_name,@connection_type)
+            rescue WIN32OLERuntimeError => e
+              if e.inspect =~ /unknown property or method `OpenConnection2'/
+                @connection.OpenConnection('123',@application_name)
+              else
+                raise e
+              end
+            end
+            Connection.connections << self
+            @connected = true
+            @connection
+          end
         end
-      end
 
-      # End the current Quickbooks session. After ending a session, a new session may be reopened if desired.
-      def end_session
-        if !@session.nil?
-          connection.EndSession(@session)
-          @session = nil
-          true
-        else
-          false
+        # Begin a session to Quickbooks.
+        def session
+          (@session ||= nil) || begin
+            # Should set personal-data-pref to pdpNotNeeded by default, so that it doesn't ask.
+            # connection.PutPersonalDataPref(@quickbooks.get_variable('pdpNotNeeded'))
+            @session = connection.BeginSession(@file,@connection_mode)
+          end
         end
-      end
 
-      # Close the connection to Quickbooks. Automatically ends the session, if there is one.
-      def close
-        end_session
-        if connected? && connection.CloseConnection.nil?
-          @connected = false
-          @connection = nil
-          Connection.connections = Connection.connections - [self]
+        # End the current Quickbooks session. After ending a session, a new session may be reopened if desired.
+        def end_session
+          if !@session.nil?
+            connection.EndSession(@session)
+            @session = nil
+            true
+          else
+            false
+          end
         end
-        return !@connected # Returns false if CloseConnection failed.
       end
     end
   end