quickbooks 0.0.2 → 0.0.3

data/lib/quickbooks/models/customer.rb

@@ -0,0 +1,71 @@
+module Quickbooks
+  class Customer < ListItem
+    properties  :parent_ref,
+                :sublevel,
+
+                :name,
+                :salutation,
+                :first_name,
+                :middle_name,
+                :last_name,
+                :suffix,
+                :company_name,
+
+                :phone,
+                :mobile,
+                :alt_phone,
+                :pager,
+                :fax,
+                :email,
+                :contact,
+                :alt_contact,
+                :bill_address,
+                :ship_address,
+
+                :notes,
+
+                :account_number,
+                :credit_card_info,
+                :credit_limit,
+                :balance,
+                :open_balance,
+                :open_balance_date,
+                :total_balance,
+                :preferred_payment_method_ref,
+
+                :job_status,
+                :job_start_date,
+                :job_projected_end_date,
+                :job_end_date,
+                :job_desc,
+                :job_type_ref,
+
+                :print_as,
+                :customer_type_ref,
+                :delivery_method,
+                :price_level_ref,
+                :terms_ref,
+                :sales_rep_ref,
+                :sales_tax_code_ref,
+                :item_sales_tax_ref,
+                :resale_nmber,
+                :is_statement_with_parent,
+                :data_ext_ref
+
+    # def initialize
+    #   @parent_ref = ListItem.new
+    #   @bill_address = Address.new
+    #   @terms_ref = ListItem.new
+    #   @sales_rep_ref = ListItem.new
+    #   @sales_tax_code_ref = ListItem.new
+    #   @item_sales_tax_ref = ListItem.new
+    #   @preferred_payment_method_ref = ListItem.new
+    #   @job_type_ref = ListItem.new
+    #   @price_live_ref = ListItem.new
+    #   @data_ext_ref = ListItem.new
+    #   @ship_address = Address.new
+    #   @customer_type_ref = ListItem.new
+    #   @credit_card_info = CreditCardInfo.new
+    # end
+  end
+end

data/lib/quickbooks/models/list_item.rb

@@ -0,0 +1,22 @@
+class Quickbooks::ListItem < Quickbooks::Base
+  attr_accessor :list_id, :full_name, :edit_sequence, :time_created, :time_modified, :is_active
+
+  class << self
+    def child_types
+      [ "Account", "Account List", "BillingRate",
+        "Class", "Currency", "Customer",
+        "CustomerMessage", "CustomerType",
+        "DateDrivenTerms", "Employee", "ItemDiscount",
+        "ItemFixedAsset", "ItemGroup", "ItemInventory",
+        "ItemInventoryAssembly", "ItemNonInventory",
+        "ItemOtherCharge", "ItemPayment", "ItemSalesTax",
+        "ItemSalesTaxGroup", "ItemService", "ItemSubtotal",
+        "JobType", "OtherName", "PaymentMethod",
+        "PayrollItemNonWage", "PayrollItemWage", "PriceLevel",
+        "SalesRep", "SalesTaxCode", "ShipMethod",
+        "StandardTerms", "TaxCode", "Template", "ToDo",
+        "Vehicle", "Vendor", "VendorType"
+      ]
+    end
+  end
+end

data/lib/quickbooks/models/transaction.rb

@@ -0,0 +1,40 @@
+class Quickbooks::Transaction < Quickbooks::Base
+  # attr_accessor :id, :ref_number
+  attr_accessor :list_id, :full_name, :edit_sequence, :time_created, :time_modified, :is_active
+
+  # Currently, the following transaction types can be modified: 
+  # • Bill
+  # • BillPaymentCheck
+  # • BuildAssembly
+  # • Charge
+  # • Check
+  # • CreditCardCharge
+  # • CreditCardCredit
+  # • CreditMemo
+  # • Deposit
+  # • Estimate
+  # • Invoice
+  # • JournalEntry
+  # • ItemReceipt
+  # • PriceLevel
+  # • PurchaseOrder
+  # • ReceivePayment
+  # • SalesOrder
+  # • SalesReceipt
+  # • StatementCharge
+  # • TimeTracking
+
+  class << self
+    def child_types
+      [ "Bill", "BillPaymentCheck", "BillPaymentCreditCard",
+        "BuildAssembly", "Charge", "Check", "CreditCardCharge",
+        "CreditCardCredit", "CreditCardRefund", "CreditMemo",
+        "Deposit", "Estimate", "InventoryAdjustment",
+        "Invoice", "ItemReceipt", "JournalEntry",
+        "PurchaseOrder", "ReceivePayment", "SalesOrder",
+        "SalesReceipt", "SalesTaxPaymentCheck", "TimeTracking",
+        "VehicleMileage", "VendorCredit"
+      ]
+    end
+  end
+end

data/lib/quickbooks/ole_helper.rb

@@ -0,0 +1,47 @@
+# QBHelpers::Ole is a simple helper class that wraps an OLE object and provides methods that make it easier to deal with certain things that OLE makes complicated.
+
+module QBHelpers
+  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
+end

data/lib/quickbooks/qbxml/error.rb

@@ -0,0 +1,20 @@
+module Quickbooks
+  module Qbxml
+    # This class exists simply to wrap errors in an object similar in structure to a Quickbooks::Base-inherited object, so the error can be extracted, etc.
+    class Error
+      # Stores a log of Quickbooks::Qbxml::Response objects that were a result of methods performed on this object.
+      attr_accessor :response_log
+      def response_log #:nodoc:
+        @response_log || (@response_log = [])
+      end
+
+      # Returns success (true/false) status of the last quickbooks communication called from this object.
+      def success?
+        @response_log.last.success?
+      end
+      def inspect #:nodoc:
+        "#<#{self.class.name}:#{self.object_id} #{instance_variables.reject {|i| i.is_one_of?('@response_log', '@original_values')}.map {|i| "#{i}=#{instance_variable_get(i).inspect}"}.join(' ')}>"
+      end
+    end
+  end
+end

data/lib/quickbooks/qbxml/request.rb

@@ -0,0 +1,120 @@
+require 'quickbooks/ruby_magic'
+require 'builder'
+
+module Quickbooks
+  module Qbxml
+    VERSION = '6.0'
+    class RequestSet
+      include Enumerable
+      def set
+        unless @set.is_a?(Array)
+          @set = []
+          @set.extend(Quickbooks::Qbxml::RequestSetArrayExt)
+        end
+        @set
+      end
+      delegate_methods [:each, :length, :first, :last, :[], :map, :join] => :set
+      def <<(qbxml_request)
+        if qbxml_request.is_a?(Quickbooks::Qbxml::Request)
+          set << qbxml_request
+        elsif qbxml_request.respond_to?(:each)
+          qbxml_request.each do |request|
+            self << request
+          end
+        else
+          raise ArgumentError, "Cannot add object of type #{qbxml_request.class.name} to a Quickbooks::Qbxml::RequestSet"
+        end
+      end
+
+      def initialize(*requests)
+        self << requests
+      end
+
+      def to_xml
+        pre = <<-thequickbooks_qbxmlrequestsetxml
+<?xml version="1.0" ?>
+<?qbxml version="#{Quickbooks::Qbxml::VERSION}" ?>
+<QBXML>
+<QBXMLMsgsRq onError="stopOnError">
+thequickbooks_qbxmlrequestsetxml
+        requests = map {|x| x.to_xml(false)}.join
+        post = <<-thequickbooks_qbxmlrequestsetxml
+</QBXMLMsgsRq>
+</QBXML>
+thequickbooks_qbxmlrequestsetxml
+# puts pre + requests + post
+        pre + requests + post
+      end
+    end
+
+    class Request
+      # @type = there are four types of queries...
+        # 1) List queries (:query)
+        # 2) Object-specific transaction query (:transaction)
+        # 3) Generic transaction query (:any_transaction)
+        # 4) Reports (:report)
+      # ...and then there are Mod requests...
+      # # 1) Mod request (:mod)
+      def initialize(object, type, options={})
+        @type = type
+        raise ArgumentError, "Quickbooks::Qbxml::Requests can only be of one of the following types: :query, :transaction, :any_transaction, :mod, :add, :delete, or :report" unless @type.is_one_of?(:query, :transaction, :any_transaction, :mod, :report, :add, :delete)
+        @object = object
+        @filters = options if @type.is_one_of?(:query, :transaction, :any_transaction, :report)
+        @attributes = options.stringify_keys! if @type.is_one_of?(:mod, :add, :delete)
+        # puts self.inspect
+      end
+
+      def self.next_request_id
+        @request_id ||= 5000
+        @request_id += 1
+      end
+
+      # This is where the magic happens to convert a request object into xml worthy of sending off to quickbooks.
+      def to_xml(as_set=true)
+        return (RequestSet.new(self)).to_xml if as_set # Simple call yields xml as a single request in a request set. However, if the xml for the lone request is required, pass false.
+        req = Builder::XmlMarkup.new(:indent => 2)
+        case
+        when @type.is_one_of?(:query)
+          request_root = "#{@object}QueryRq"
+          container = nil
+        when @type == :mod
+          request_root = "#{@object}ModRq"
+          container = "#{@object}Mod"
+        when @type == :add
+          request_root = "#{@object}AddRq"
+          container = "#{@object}Add"
+        when @type == :delete
+          # request_root = "#{@object}DelRq"
+          request_root = Quickbooks::ListItem.child_types.include?(@object) ? 'ListDelRq' : 'TxnDelRq'
+          container = nil
+          # container = Quickbooks::ListItem.child_types.include?(@object) ? 'ListDelType' : 'TxnDelType'
+          @attributes.merge!((Quickbooks::ListItem.child_types.include?(@object) ? 'ListDelType' : 'TxnDelType') => @object)
+        else
+          raise RuntimeError, "Could not convert this request to qbxml!\n#{self.inspect}"
+        end
+        inner_stuff = lambda {
+          ['ListDelType', 'TxnDelType', 'ListID', 'TxnID', 'EditSequence'].each do |key|
+            req.tag!(key, @attributes.delete(key)) if @attributes.has_key?(key)
+          end if @attributes
+          (@filters || @attributes).each do |key,value|
+            req.tag!(key, value)
+          end
+        }
+        req.tag!(request_root, :requestID => self.class.next_request_id) {
+          if container
+            req.tag!(container) {
+              inner_stuff.call
+            }
+          else
+            inner_stuff.call
+          end
+        }
+        # puts req.target!
+        req.target!
+      end
+    end
+
+    module RequestSetArrayExt
+    end
+  end
+end

data/lib/quickbooks/qbxml/response.rb

@@ -0,0 +1,176 @@
+require 'quickbooks/ruby_magic'
+require 'quickbooks/qbxml/error'
+
+module Quickbooks
+  module Qbxml
+    class ResponseSet
+      include Enumerable
+      def set
+        unless @set.is_a?(Array)
+          @set = []
+          @set.extend(Quickbooks::Qbxml::ResponseSetArrayExt)
+        end
+        @set
+      end
+      delegate_methods [:each, :length, :first, :last, :[], :map, :join] => :set
+      def <<(qbxml_response)
+        if qbxml_response.is_a?(Quickbooks::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 Quickbooks::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, "Quickbooks::Qbxml::ResponseSet must be initialized with either a Hash or an xml-formatted String."
+        end
+      end
+
+      def append_from_xml(xml)
+        self.append_from_hash(Hash.from_xml(xml))
+      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, "Quickbooks::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(Hash.from_xml(xml))
+        self
+      end
+      def import_from_hash(hsh)
+        raise ArgumentError, "Hash passed to Quickbooks::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.
+          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
+            self.response_type = hsh.delete(m[1]+'DelType')
+            # self.ret_items = ResponseObject.new(self.response_type, hsh.dup)
+            self.ret_items = hsh.dup
+          elsif m = name.match(/^([A-Za-z][a-z]+)(Query|Mod|Add)Rs$/)
+            self.response_type = m[1]
+            # self.ret_items = ResponseObject.new(self.response_type, hsh[self.response_type+'Ret'])
+            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(obj=nil)
+        objs = []
+        (self.ret_items.is_a?(Array) ? self.ret_items : [self.ret_items]).each do |ret_item|
+          if instantiatable?
+            if self.status == 0
+              if obj.nil?
+                obj = "Quickbooks::#{self.response_type}".constantize.instantiate(self.ret_items)
+              else
+                obj.class.instantiate(obj, self.ret_items)
+              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(self.ret_items)
+              else # An existing object. Must be an update or delete request. Update object's original_attributes.
+                updated = []
+                self.ret_items.each do |k,v|
+                  k = k.underscore
+                  if obj.original_values[k] != v
+                    updated << k
+                    obj.original_values[k] = v
+                  end
+                end
+                ['EditSequence', 'TimeModified', 'TimeCreated'].each do |k|
+                  obj.send(k.underscore + '=', self.ret_items[k]) if self.ret_items.has_key?(k) && obj.respond_to?(k.underscore + '=')
+                end
+                self.message = self.message + " Other properties were out of date: [" + updated.join(', ') + '].'
+              end
+            end
+          else
+            obj = Quickbooks::Qbxml::Error.new(self) # If not instantiatable, use this 'Error' object just as a wrapper for the response_log to convey the error response.
+          end
+          obj.response_log << self
+          objs << obj
+        end
+        objs.length > 1 ? objs : objs[0] # Single or nil if not more than one.
+      end
+    end
+
+    module ResponseSetArrayExt
+    end
+  end
+end