quickbooks 0.0.5 → 0.0.7

data/lib/qbxml/response.rb

@@ -0,0 +1,197 @@
+require 'qbxml/support'
+require 'formatted_string'
+
+module Qbxml
+  # module ResponseSetArrayExt
+  # end
+
+  class ResponseSet
+    include Enumerable
+    def set
+      unless @set.is_a?(Array)
+        @set = []
+        # @set.extend(Qbxml::ResponseSetArrayExt)
+      end
+      @set
+    end
+    delegate_methods [:each, :length, :first, :last, :[], :map, :join] => :set
+    def <<(qbxml_response)
+      if qbxml_response.is_a?(Qbxml::Response)
+        set << qbxml_response
+      elsif qbxml_response.respond_to?(:each)
+        qbxml_response.each do |response|
+          self << response
+        end
+      else
+        raise ArgumentError, "Cannot add object of type #{qbxml_response.class.name} to a Qbxml::ResponseSet"
+      end
+    end
+
+    def initialize(xml_or_hash)
+      if(xml_or_hash.is_a?(Hash))
+        self.append_from_hash(xml_or_hash)
+      elsif(xml_or_hash.is_a?(String))
+        self.append_from_xml(xml_or_hash)
+      else
+        raise ArgumentError, "Qbxml::ResponseSet must be initialized with either a Hash or an xml-formatted String."
+      end
+    end
+
+    def append_from_xml(xml)
+      # puts "ResponseXML:"
+      # puts xml
+      self.append_from_hash(xml.formatted(:xml).to_hash)
+    end
+    def append_from_hash(hsh)
+      to_append = []
+      hsh = hsh['QBXML'] if hsh.has_key?('QBXML')
+      hsh = hsh['QBXMLMsgsRs'] if hsh.has_key?('QBXMLMsgsRs')
+      # responses will contain one or more keys.
+      hsh.each_key do |name|
+        # response_type is either a single response object, or an array of response objects. Force it into an array:
+        responses = hsh[name].is_a?(Array) ? hsh[name] : [hsh[name]]
+        responses.each { |response| to_append << Response.new(name => response) }
+      end
+      self << to_append
+    end
+
+    class << self
+      def from_xml(xml)
+        new.append_from_xml(xml)
+      end
+      def from_hash(hsh)
+        new.append_from_hash(hsh)
+      end
+    end
+  end
+
+  class Response
+    attr_accessor :response_type, :status, :message, :severity, :ret_items
+    # For Development purposes:
+    attr_accessor :raw_response
+
+    def initialize(xml_or_hash)
+      if(xml_or_hash.is_a?(Hash))
+        self.import_from_hash(xml_or_hash)
+      elsif(xml_or_hash.is_a?(String))
+        self.import_from_xml(xml_or_hash)
+      else
+        raise ArgumentError, "Qbxml::ResponseSet must be initialized with either a Hash or an xml-formatted String."
+      end
+    end
+
+    def import_from_xml(xml)
+      self.import_from_hash(xml.formatted(:xml).to_hash)
+      self
+    end
+    def import_from_hash(hsh)
+      raise ArgumentError, "Hash passed to Qbxml::Response.from_hash must contain only one top-level key" unless hsh.keys.length == 1
+      name = hsh.keys.first
+      # for development
+      self.raw_response = hsh
+      # * * * *
+      hsh = hsh[name]
+
+      self.status = hsh['statusCode'].to_i
+      self.severity = hsh['statusSeverity']
+      self.message = hsh['statusMessage']
+      # if self.status == 0 # Status is good, proceed with eating the request.
+      # <ListDeletedQueryRs requestID="5" statusCode="0" statusSeverity="Info" statusMessage="Status OK">
+      #   <ListDeletedRet>
+      #     <ListDelType>Customer</ListDelType>
+      #     <ListID>80000030-1203622308</ListID>
+      #     <TimeCreated>2008-02-21T14:31:48-05:00</TimeCreated>
+      #     <TimeDeleted>2008-03-18T17:31:12-05:00</TimeDeleted>
+      #     <FullName>Rachel Parker</FullName>
+      #   </ListDeletedRet>
+      # </ListDeletedQueryRs>
+        if m = name.match(/^(List|Txn)Del(etedQuery)?Rs$/)
+          # (List|Txn)DelRs, or (List|Txn)DeletedQueryRs - both return just a few attributes, like ListID / TxnID and TimeDeleted
+          list_or_txn = m[1]
+          long_name = m[1]+'Del'+m[2].to_s
+          ret_key = long_name.gsub(/Query$/,'')+'Ret'
+          self.ret_items = hsh[ret_key].is_a?(Array) ? hsh[ret_key] : [hsh[ret_key]].compact # Force to be an array - it's return items!
+          self.response_type = self.ret_items.empty? ? m[1] : self.ret_items[0][list_or_txn+'DelType']
+        elsif m = name.match(/^((?:[A-Za-z][a-z]+)+)(Query|Mod|Add)Rs$/)
+          self.response_type = m[1]
+          self.ret_items = hsh[self.response_type+'Ret']
+        else
+          raise "Could not read this response:\n#{self.raw_response.inspect}"
+        end
+      # else # Status is bad.
+        
+      # end
+      # puts self.inspect
+      self
+    end
+
+
+    class << self
+      def from_xml(xml)
+        new.import_from_xml(xml)
+      end
+      def from_hash(hsh)
+        new.import_from_hash(hsh)
+      end
+    end
+
+    def instantiatable? # Just checks to see if it can create an object of this type, and if there is actually data to instantiate
+      self.response_type ? (Quickbooks.const_defined?(self.response_type) && self.ret_items.is_a?(Hash) || (self.ret_items.is_a?(Array) && self.ret_items[0].is_a?(Hash))) : false
+    end
+    def success?
+      self.status == 0
+    end
+    def error?
+      !success?
+    end
+
+    def instantiate(reinstantiate=nil)
+      objs = []
+      (self.ret_items.is_a?(Array) ? self.ret_items : [self.ret_items]).each do |ret_item|
+        obj = reinstantiate if reinstantiate
+        if instantiatable?
+          if self.status == 0
+            if obj.nil?
+              obj = "Quickbooks::#{self.response_type}".constantize.instantiate(ret_item)
+            else
+              obj.class.instantiate(obj, ret_item)
+            end
+          else
+            # Instantiatable, but some error status. For any error status
+            if obj.nil? # Must be a new object. Just as well, create a new object WITHOUT any original_attributes.
+              obj = "Quickbooks::#{self.response_type}".constantize.new(ret_item)
+            else # An existing object. Must be an update or delete request. Update object's original_attributes.
+              updated = []
+              ret_item.each do |k,v|
+                k = k.underscore
+                if obj.original_values[k] != v
+                  updated << k
+                  if obj.class.instance_variable_get('@object_properties').has_key?(k.to_sym)
+                    obj.original_values[k] = obj.class.instance_variable_get('@object_properties')[k.to_sym].new(v)
+                  else
+                    obj.original_values[k] = v
+                  end
+                end
+              end
+              # Update object's 'read-only' attributes (as well as in the original_values):
+              obj.class.read_only.stringify_values.camelize_values.each do |k|
+                obj.send(k.underscore + '=', ret_item[k]) if ret_item.has_key?(k) && obj.respond_to?(k.underscore + '=')
+              end
+              self.message = self.message + " Other properties were out of date: [" + updated.join(', ') + '].'
+            end
+            obj.errors << {:code => self.status, :message => self.message, :response => self}
+          end
+        else
+          if self.status == 0
+            obj.errors << {:code => nil, :message => "Cannot instantiate object of type #{self.response_type}!", :response => self}
+          else
+            obj.errors << {:code => self.status, :message => self.message, :response => self}
+          end
+        end
+        obj.response_log << self unless obj.nil?
+        objs << obj
+      end
+      objs.length > 1 ? objs : objs[0] # Single or nil if not more than one.
+    end
+  end
+end

data/lib/qbxml/support.rb

@@ -0,0 +1,130 @@
+gem 'formattedstring'
+gem 'builder'
+require 'quickbooks/structure'
+
+class Object
+  # This allows one to effectively 'proxy' specific methods to be called on the return value of one of its methods.
+  # For example, obj.length could be delegated to do the same thing as obj.full_text.length
+  def delegate_methods(hsh)
+    raise ArgumentError, "delegate_methods should be called like: delegate_methods [:method1, :method2] => :delegated_to_method" unless hsh.keys.first.is_a?(Array)
+    methods = hsh.keys.first
+    delegate_to = hsh[methods]
+    methods.each do |method|
+      self.send(:eval, <<-ddddddd
+        def #{method}(*args, &block)
+          block_given? ? self.#{delegate_to}.#{method}(*args, &block) : self.#{delegate_to}.#{method}(*args)
+        end
+      ddddddd
+      )
+    end
+  end
+
+  # Normally one would say, "if [:a, :b, :c].include?(:a)" -- which is backward thinking, instead you should use this magic:
+  # ":a.is_one_of?(:a, :b, :c)", or :a.is_one_of?([:a, :b, :c]).
+  def is_one_of?(*ary)
+    raise ArgumentError, "exists_in? requires an array to be passed" unless ary.is_a?(Array)
+    ary.flatten.include?(self)
+  end
+end
+
+class Class
+  def lone_name
+    name.gsub(/.*::/, '')
+  end
+end
+
+class String
+  def constantize
+    Object.module_eval("::#{self}", __FILE__, __LINE__)
+  end
+
+  def underscore
+    gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+  end
+
+  def camelize
+    gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+end
+
+class Array
+  def camelize_values(specials={})
+    self.dup.camelize_values!(specials)
+  end
+  def camelize_values!(specials={})
+    self.each_with_index do |v,i|
+      self[i] = specials.has_key?(v) ? specials[v] : (v.is_a?(Symbol) ? v.to_s.camelize.to_sym : v.camelize)
+    end
+    self
+  end
+
+  def stringify_values
+    self.dup.stringify_values!
+  end
+  def stringify_values!
+    self.each_with_index { |v,i| self[i] = v.to_s }
+    self
+  end
+
+  def only(*values)
+    self.dup.only!(*values)
+  end
+  def only!(*values)
+    values.flatten!
+    i = 0
+    while i <= length-1 do
+      self[i].is_one_of?(values) ? i += 1 : self.slice!(i)
+    end
+    self
+  end
+
+  def order(*ordered)
+    self.dup.order!(*ordered)
+  end
+  def order!(*ordered)
+    self.replace(ordered.flatten!.only!(self))
+  end
+end
+
+class Hash
+  # Transform all the keys in the hash to CamelCase format.
+  def camelize_keys(specials={})
+    self.dup.camelize_keys!(specials)
+  end
+  def camelize_keys!(specials={})
+    self.each_key do |k|
+      self[specials.has_key?(k) ? specials[k] : k.camelize] = self.delete(k)
+    end
+    self
+  end
+
+  def stringify_keys(specials={})
+    self.dup.stringify_keys!(specials)
+  end
+  def stringify_keys!(specials={})
+    self.each_key do |k|
+      self[specials.has_key?(k) ? specials[k] : k.to_s] = self.delete(k)
+    end
+    self
+  end
+
+  def only(*keys)
+    self.dup.only!(*keys)
+  end
+  def only!(*keys)
+    keys = keys.flatten
+    self.keys.each { |k| self.delete(k) unless keys.include?(k) }
+    self
+  end
+
+  def transform_keys(trans_hash)
+    self.dup.transform_keys!(trans_hash)
+  end
+  def transform_keys!(trans_hash)
+    raise ArgumentError, "transform_keys takes a single hash argument" unless trans_hash.is_a?(Hash)
+    self.each_key do |k|
+      self[trans_hash.has_key?(k) ? trans_hash[k] : k] = self.delete(k)
+    end
+    self
+  end
+end

data/lib/quickbooks.rb

@@ -1,7 +1,6 @@
-require 'rubygems'
-require 'quickbooks/connection'
 require 'quickbooks/base'
 require 'quickbooks/models/list_item'
 require 'quickbooks/models/transaction'
 
 require 'quickbooks/models/customer'
+require 'quickbooks/models/deleted'

data/lib/quickbooks/adapters/ole_adapter.rb

@@ -0,0 +1,148 @@
+require 'win32ole'
+
+module Quickbooks
+  # Connection is used internally by Quickbooks::Base to automatically manage a the communication with quickbooks.
+  # Currently the only connection mode supported is WIN32OlE, which means your application must be running on the
+  # same computer as 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
+      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 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)
+      end
+    end
+
+    class Connection
+      class << self #:nodoc: all
+        def connections
+          @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
+          end
+        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 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)
+        @quickbooks.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
+
+      # 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
+        end
+      end
+
+      # Begin a session to Quickbooks.
+      def session
+        @session || begin
+          @session = connection.BeginSession(@file,@connection_mode)
+        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
+        end
+      end
+
+      # Close the connection to Quickbooks. Automatically ends the session, if there is one.
+      def close
+        end_session
+        if connected? && connection.CloseConnection
+          @connected = false
+          @connection = nil
+          Quickbooks::Connection.connections = Quickbooks::Connection.connections - [self]
+        end
+        return !@connected # Returns false if CloseConnection failed.
+      end
+    end
+  end
+end