qbfc 0.1.0-x86-mswin32-60 → 0.2.0-x86-mswin32-60

data/README

@@ -5,7 +5,29 @@ allowing more or less direct access to the actual COM object.
 
 Obviously, test before using on your production data...
 
-==Examples
+==Find
+
+QBFC-Ruby supports +find+ queries with options, which utitilize QBFC's Query
+Requests. See QBFC::Element.find for details and options.
+
+  QBFC::session do | qb |
+    checks = qb.checks.find(:first, :conditions => {:entity => 'ABC Supplies'})
+  end
+
+==Relationships
+
+QBFC-Ruby supports loading of related records. These are records
+represented by "*Ref" in the QBFC documentation. For example, a Check
+has, among others, a PayeeEntityRef and an AccountRef. These can be
+accessed via, respectively, <tt>check.payee</tt> and <tt>check.account</tt>.
+
+<tt>check.payee.name</tt> returns the name of the payee.
+
+You can also access the *ID and Name fields of referenced records.
+Example: for the payee of a Check, <tt>check.payee_id</tt> and
+<tt>check.payee_name</tt>.
+
+==General Examples
 
   # A very simple example, finding a single Customer by name
   QBFC::session do | qb |
@@ -37,5 +59,27 @@ Obviously, test before using on your production data...
     first_customer = customer_set.Detail[0]
     puts first_customer.full_name
   end
+  
+==Alternatives
+
+[QuickBooks for Ruby]
+  (docs: http://quickbooks.rubyforge.org,
+  homepage: http://rubyforge.org/projects/quickbooks)
+
+  This is a project with similar goals to QBFC-Ruby. I believe the approach
+  is creating Ruby classes that mirror the QuickBooks types and generate / parse
+  qbXML. In my opinion, this approach is more stable and flexible than what I'm
+  doing with QBFC-Ruby, but at the cost of slower development. (As in, QBFC-Ruby
+  was intended as a collection of quick and dirty shortcuts; QuickBooks for Ruby
+  seems to be intended as a much more *complete* project)
+
+[QBFC/qbXML COM Objects]
+  Using the SDK directly is an option. Unless you need to use QBWC (QuickBooks
+  Web Connector) or have some other reason for *wanting* to us qbXML, I suggest
+  using QBFC. The SDK documents (see http://developer.intuit.com/ ) are pretty
+  easy to use and navigate.
+
+There are some other libraries on rubyforge in early stages which I haven't
+really explored.
 
 Copyright (c) 2008 Jared E. Morgan, released under the MIT license

data/Rakefile

@@ -63,7 +63,7 @@ require 'rake/gempackagetask'
 
 spec = Gem::Specification.new do |s|
   s.name = "qbfc"
-  s.version = "0.1.0"
+  s.version = "0.2.0"
   s.author = "Jared Morgan"
   s.email = "jmorgan@morgancreative.net"
   s.homepage = "http://rubyforge.org/projects/qbfc/"

data/lib/qbfc/element.rb

@@ -50,10 +50,74 @@ module QBFC
       # The options hash accepts the following:
       # - <tt>:owner_id</tt>: One or more OwnerIDs, used in accessing
       #   custom fields (aka private data extensions).
+      # - <tt>:limit</tt>: The maximum number of records to be returned.
+      # - <tt>:include</tt>: Elements to include (see below for details)
+      # - <tt>:conditions</tt>: A hash of conditions (generally 'Filters' in
+      #   QuickBooks SDK. See below:
       # 
       # Additional options are planned, but not really supported in this version.
       # Passing a Request object is the current recommended way of applying
-      # Filters or other options to the Query Request.
+      # unsupported conditions (Filters) or other options to the Query Request.
+      # 
+      # ==Include
+      # 
+      # The :include option accepts an Array of elements to include in the
+      # return of the Query. The array may include either or both of elements
+      # that are additional to normal returns (such as Line Items, Linked
+      # Transactions) or elements that are normally included (to be added to the
+      # IncludeRetElementList).
+      # 
+      # If elements are given that would be added to IncludeRetElementList, this
+      # limits the elements returned to *only* those included in the array.
+      # 
+      # Another option is to give :all as the argument, which will always return
+      # as many elements as possible.
+      # 
+      #   @sess.checks.find(:all, :include => [:linked_txns]) -> Include linked transactions
+      #   @sess.checks.find(:all, :include => [:txn_id]) -> Include +only+ TxnID
+      #   @sess.checks.find(:all, :include => :all) ->
+      #     Includes all elements, including LinkedTxns and LineItems.
+      #     
+      # ==Conditions
+      # 
+      # Conditions are dependent on the particular Request. See the QuickBooks
+      # SDK documentation for applicable filters for each Query Request. Note
+      # that not all Filters are supported.
+      # 
+      # Typically the condition is given as :filter_name => value where
+      # +filter_name+ is the name of the filter less the word 'Filter' (see
+      # examples below).
+      # 
+      # Here are some general rules:
+      # 
+      # [List filters]
+      #   These are filters that end in List. They take an Array of values.
+      #   
+      #     :ref_number_list => ["1001", "1003", "1003a"]
+      #     :txn_id_list => ["123-456"]
+      # 
+      # [Range Filters]
+      #   Filters which take a range of values. These accept any
+      #   object which responds to +first+ and +last+, such as a Range or Array.
+      #   +first+ is used to set the From value, +last+ sets the To value. If a
+      #   scalar value is given (or a single element Array), To is set and From
+      #   is left empty. nil can also be given for either value.
+      # 
+      #     :txn_date_range => ['2008-01', nil]
+      #     :txn_date_range => ['2008-01']
+      #     :txn_date_range => '2008-01'
+      #     
+      #     :ref_number_range => "1001".."1003"
+      #     :ref_number_range => ["1001", "1003"]
+      #   
+      # [Reference Filters]
+      #   Filters which reference another object (belongs to
+      #   filters). These current only accept Name arguments, as a single value
+      #   or an Array.
+      # 
+      #     :account => 'Checking'
+      #     :entity => ['ABC Supplies', 'CompuStuff']
+      # 
       def find(sess, what, *args)
         
         if what.kind_of?(String) # Single FullName or ListID
@@ -63,12 +127,13 @@ module QBFC
         # Setup q, options and base_options arguments
         q, options, base_options = parse_find_args(*args)
         q ||= create_query(sess)
+        
         q.apply_options(options)
         
         # QuickBooks only needs to return one record if .find is
         # only returning a single record.
         if what == :first && q.filter_available?
-          q.filter.max_returned = 1
+          q.add_limit(1)
         end
         
         # Send the query so far to base_class_find if this is
@@ -106,9 +171,11 @@ module QBFC
         else
           ary = (0..(list.Count - 1)).collect { |i|
             element = list.GetAt(i)
-            ret_name = element.ole_methods.detect{ |m| m.to_s =~ /(.*)Ret\Z/ }.to_s
+            ret_name = element.ole_methods.detect { |m|
+              m.to_s =~ /(.*)Ret\Z/ && element.send(m.to_s)
+            }.to_s
             ret_class = QBFC::const_get($1)
-            ret_class.find(sess, element.send(ret_name).send(ret_class::ID_NAME), options.dup)
+            ret_class.find(sess, element.send(ret_name).send(ret_class::ID_NAME).GetValue, options.dup)
           }
           
           if what == :all
@@ -119,7 +186,7 @@ module QBFC
         end
       end
       
-      private :base_class_find
+      private :base_class_find, :is_base_class
 
     end
     

data/lib/qbfc/item.rb

@@ -1,6 +1,25 @@
 module QBFC
   class Item < List
     is_base_class
+    
+    class << self
+      
+      # Adds a SpecialItem.
+      # 
+      # +item_type+ should be a constent, for example:
+      # 
+      #   Account.add_special(sess, QBFC_CONST::SitFinanceCharge)
+      #   
+      # See SDK docs for SpecialItemAdd for more details.
+      def add_special(sess, item_type)
+        rq = QBFC::Request.new(sess, "SpecialItemAdd")
+        rq.special_item_type = item_type
+        
+        # Insofar as I never actually plan to use this method, just return
+        # response.
+        return rq.response
+      end
+    end
   end
 end
 

data/lib/qbfc/lists/account.rb

@@ -0,0 +1,24 @@
+module QBFC
+  class Account < List
+    include Modifiable
+    
+    class << self
+      
+      # Adds a SpecialAccount, per SDK documentation:
+      # "An account normally created automatically as needed within the 
+      # QuickBooks UI, or in the SDK via the SpecialAccountAdd request."
+      # 
+      # +account_type+ should be a constent, for example:
+      # 
+      #   Account.add_special(sess, QBFC_CONST::SatAccountsPayable)
+      #   
+      # See SDK docs for SpecialAccountAdd for more details.
+      def add_special(sess, account_type)
+        rq = QBFC::Request.new(sess, "SpecialAccountAdd")
+        rq.special_account_type = account_type
+        
+        new(sess, rq.response)
+      end
+    end
+  end
+end

data/lib/qbfc/lists/generated.rb

@@ -1,15 +1,15 @@
 module QBFC
 
   # Generated List types that will inherit directly from QBFC::List
-  LIST_TYPES = %w{Account BillingRate CustomerMsg CustomerType JobType  PaymentMethod
-      PayrollItemNonWage PayrollItemWage PriceLevel SalesRep SalesTaxCode ShipMethod ToDo
-      Vehicle VendorType}
+  LIST_TYPES = %w{ BillingRate CustomerMsg CustomerType JobType  PaymentMethod
+      PayrollItemNonWage PayrollItemWage PriceLevel SalesRep SalesTaxCode
+      ShipMethod ToDo Vehicle VendorType}
   
-  # Generated List types that do not accept Mod Requests
-  LIST_NO_MOD_TYPES = %w{ BillingRate CustomerMsg CustomerType JobType PaymentMethod
-      PayrollItemWage SalesTaxCode ShipMethod ToDo VendorType}
+  # Generated List types that do accept Mod Requests
+  # (most direct subclasses of List do not)
+  LIST_MOD_TYPES = %w{ PriceLevel SalesRep Vehicle }
   
   # Generate List subclasses
-  generate(LIST_TYPES, List, {Modifiable => LIST_TYPES - LIST_NO_MOD_TYPES})
+  generate(LIST_TYPES, List, {Modifiable => LIST_MOD_TYPES})
   
 end

data/lib/qbfc/ole_wrapper.rb

@@ -103,6 +103,7 @@ module QBFC
       obj = @ole_object.send(ole_method_name)
 
       if detect_ole_method?(obj, "SetValue")
+        params[0] = params[0].strftime("%Y-%m-%d") if params[0].kind_of?(Date)
         obj.SetValue(*params)
         if @setter && detect_ole_method?(@setter, ole_method_name)
           @setter.send(ole_method_name).SetValue(*params)

data/lib/qbfc/qb_types.rb

@@ -1,34 +1,21 @@
 # This file sets up the classes for QuickBooks entities, transactions and reports.
 
-# Types that allow Query and Delete only
-QBFC_DELETE_ONLY = %w{PayrollItemNonWage DataEventRecoveryInfo}
-
 # Report types return an IReportRet
-QBFC_REPORT_TYPES = %w{AgingReport BudgetSummaryReport CustomDetailReport CustomSummaryReport
-                      GeneralDetailReport GeneralSummaryReport JobReport PayrollDetailReport PayrollSummaryReport TimeReport }
-
-# Types that allow Special adds (Pre-defined and normally added automatically by QuickBooks)
-QBFC_HAS_SPECIAL_ADD = %w{Account Item}
+QBFC_REPORT_TYPES = %w{AgingReport BudgetSummaryReport CustomDetailReport
+    CustomSummaryReport GeneralDetailReport GeneralSummaryReport JobReport
+    PayrollDetailReport PayrollSummaryReport TimeReport }
 
-# TODO: Here and below arrays I haven't yet formed any approach to dealing with.
-# I leave them here as a reminder.
-ELEMENTS_ADD_MOD = %w{ DataExt }         
-                    
-ELEMENTS_ADD_MOD_QUERY = %w{ DataExtDef }
-                    
-# Types that have their own DelRq
-ELEMENT_DEL_TYPES = %w{DataEventRecoveryInfo DataExt DataExtDef}
+# Very non-standard elements.  I haven't yet formed an approach to dealing
+# with these; I leave them here as a reminder.
+QBFC_NON_STANDARD_TYPES = %w{ DataExt DataExtDef DataEventRecoveryInfo ItemAssembliesCanBuild}
 
 # Query types support Query requests only and return an itemized list of some sort;
 # most of these may be integrated as special finders for their types.
 QBFC_QUERY_TYPES =  %w{BillToPay ListDeleted ReceivePaymentToDeposit Template TxnDeleted SalesTaxPaymentCheck}
 
-QBFC_ANOTHER_TO_INTEGRATE_SOMEWHERE = %w{ ItemAssembliesCanBuild }
-
-
 module QBFC
   # Create QBElement classes
-  (QBFC_REPORT_TYPES + QBFC_DELETE_ONLY + %w{DataExt DataExtDef}).uniq.each do | qb_element_name |
+  (QBFC_REPORT_TYPES + QBFC_NON_STANDARD_TYPES + QBFC_QUERY_TYPES).uniq.each do | qb_element_name |
     const_set(qb_element_name, Class.new(Base))
   end
 end

data/lib/qbfc/request.rb

@@ -75,45 +75,58 @@ module QBFC
       self.query.ole_object.ortype == -1 ||
         self.query.ole_object.ortype == 2
     end
-    
-    # Applies options from a Hash. This method is primarily experimental
-    # (and proof of concept) at this time.
+       
+    # Applies options from a Hash. This method is generally used by find methods
+    # (see Element.find for details)
     def apply_options(options)      
       if options.kind_of? Hash
-        filters = options[:conditions]
-        if filters
-          if filters[:txn_date]
-            txn_date_filter = q.ORTxnQuery.TxnFilter.ORDateRangeFilter.TxnDateRangeFilter.ORTxnDateRangeFilter.TxnDateFilter
-            txn_date_filter.FromTxnDate.SetValue( filters[:txn_date][0] ) if filters[:txn_date][0]
-            txn_date_filter.ToTxnDate.SetValue( filters[:txn_date][1] ) if filters[:txn_date][1]
-            filters.delete(:txn_date)
-          end
+        conditions = options.delete(:conditions) || {}
+        
+        conditions.each do | c_name, c_value |
+          c_name = c_name.to_s
           
-          if filters[:ref_number]
-            ref_num_filter = q.send("OR#{self.qb_name}Query").send("#{self.qb_name}Filter").
-                             ORRefNumberFilter.RefNumberRangeFilter
-            ref_num_filter.FromRefNumber.SetValue( filters[:ref_number][0] ) if filters[:ref_number][0]
-            ref_num_filter.ToRefNumber.SetValue( filters[:ref_number][1] ) if filters[:ref_number][1]
-            filters.delete(:ref_number)
-          end
-            
-          filters.each do |filter, value|
-            q.send("OR#{self.qb_name}Query").
-              send("#{self.qb_name}Filter").
-              send("#{filter}=", QBFC_CONST::PsNotPaidOnly)
+          case c_name
+          when /list\Z/i
+            # List filters
+            list = query.__send__(c_name.camelize)
+            c_value = [c_value] unless c_value.kind_of?(Array)
+            c_value.each { |i| list.Add(i) }
+          when /range\Z/i
+            # Range filters
+            c_value = parse_range_value(c_value)
+            range_filter = filter_for(c_name)
+            range_name = c_name.match(/(.*)_range\Z/i)[1]
+            if range_name == 'modified_date'
+              # Modified Date Range use the IQBDateTimeType which requires a\
+              # boolean 'asDateOnly' value.
+              range_filter.__send__("from_#{range_name}=", c_value.first, true) if c_value.first
+              range_filter.__send__("to_#{range_name}=", c_value.last, true) if c_value.last
+            else
+              range_filter.__send__("from_#{range_name}=", c_value.first) if c_value.first
+              range_filter.__send__("to_#{range_name}=", c_value.last) if c_value.last
+            end
+          when /status\Z/i
+            # Status filters
+            filter.__send__("#{c_name}=", c_value)
+          else
+            # Reference filters - Only using FullNameList for now
+            ref_filter = filter_for(c_name)
+            c_value = [c_value] unless c_value.respond_to?(:each)
+            c_value.each do | val |
+              ref_filter.FullNameList.Add(val)
+            end
           end
-            
-          options.delete(:conditions)
         end
           
         add_owner_ids(options.delete(:owner_id))
+        add_limit(options.delete(:limit))
+        add_includes(options.delete(:include))
 
         options.each do |key, value|
-          q.send(key.to_s.camelize).SetValue(value)
+          self.send(key.to_s.camelize).SetValue(value)
         end
       end
-    end
-    
+    end    
     
     # Add one or more OwnerIDs to the Request. Used in retrieving
     # custom fields (aka private data extensions).
@@ -127,6 +140,111 @@ module QBFC
       end
     end
     
+    # Set MaxReturned to limit the number of records returned.
+    def add_limit(limit)
+      filter.max_returned = limit if limit
+    end
+    
+    # add_includes accepts an Array of elements to include in the return of the
+    # Request. The array may include either or both of elements that are
+    # additional to normal returns (such as Line Items, Linked Transactions)
+    # or elements that are normally included (to be added to the
+    # IncludeRetElementList).
+    # 
+    # If elements are given that would be added to IncludeRetElementList, this
+    # limits the elements returned to *only* those included in the array.
+    # 
+    # Another option is to give :all as the argument, which will always return
+    # as many elements as possible.
+    # 
+    # add_includes is typically called by #apply_options, typically called
+    # from Element.find, as seen in the examples below:
+    # 
+    #   @sess.checks.find(:all, :include => [:linked_txns]) -> Include linked transactions
+    #   @sess.checks.find(:all, :include => [:txn_id]) -> Include +only+ TxnID
+    #   @sess.checks.find(:all, :include => :all) ->
+    #     Includes all elements, including LinkedTxns and LineItems.
+    def add_includes(inc)
+      return if inc.nil?
+      
+      inc = [inc] if (!inc.respond_to?(:each) || inc.kind_of?(String))
+      
+      if inc.include?(:all)
+        ole_methods.each do |m|
+          m = m.to_s
+          if m =~ /\AInclude/ && m != 'IncludeRetElementList'
+            @request.__send__("#{m.underscore}=", true)
+          end
+        end
+        return
+      end
+      
+      inc.each do |item|
+        cam_item = item.to_s.camelize.gsub(/Id/, "ID")
+        if @request.respond_to_ole?("Include#{cam_item}")
+          @request.__send__("include_#{item}=", true)
+        else
+          @request.IncludeRetElementList.Add(cam_item)
+        end
+      end
+    end
+    
+    # Parse a value for a range filter. This can be a Range, a one or more
+    # element Array or a single value. For a single value or one-element array
+    # value#last should return nil. The calling method (#apply_options) will
+    # call value#first and value#last to set the from and to values
+    # respectively.
+    def parse_range_value(value)
+      value << nil if value.kind_of?(Array) && value.length == 1
+      value = [value, nil] if (value.kind_of?(String) || !value.respond_to?(:first))
+      value
+    end
+    
+    # Determine and return the Filter object for the given filter name, dealing
+    # with OR's and other "weird" circumstances.
+    # NB: This method may well miss some situations. Hopefully, it will become
+    # more complete in time.
+    def filter_for(name)
+      name = name.camelize + "Filter"
+      f = nil
+      
+      # List queries place the modified_date_range directly in the filter
+      if name == 'ModifiedDateRangeFilter'
+        return filter if filter.respond_to_ole?('FromModifiedDate')
+      end
+      
+      # Try to get the filter directly
+      if filter.respond_to_ole?(name)
+        f = filter.send(name)
+      end
+      
+      # Check if this is within an 'OR'
+      if filter.respond_to_ole?("OR#{name}")
+        f = filter.send("OR#{name}").send(name)
+      elsif filter.respond_to_ole?("OR#{name.gsub(/Range/, '')}")
+        f = filter.send("OR#{name.gsub(/Range/, '')}").send(name)
+      end
+      
+      # DateRange OR's
+      if filter.respond_to_ole?("ORDateRangeFilter") && name =~ /DateRange/i
+        f = filter.send("ORDateRangeFilter").send(name)
+      end
+
+      # It might have a nested OR      
+      if f && f.respond_to_ole?("OR#{name}")
+        f = f.send("OR#{name}")
+      end
+      
+      # Ranges might have another step, with the 'Range' removed.
+      if f && f.respond_to_ole?(name.gsub(/Range/, ''))
+        f = f.send(name.gsub(/Range/, ''))
+      end
+      
+      return f
+    end
+    
+    private :parse_range_value, :filter_for
+    
     # Send missing methods to @ole_object (OLEWrapper)
     def method_missing(symbol, *params) #:nodoc:
       @request.qbfc_method_missing(@sess, symbol, *params)

data/lib/qbfc/session.rb

@@ -114,8 +114,12 @@ module QBFC
     def method_missing(symbol, *params) #:nodoc:
       if (('a'..'z') === symbol.to_s[0].chr && symbol.to_s[-1].chr != '=')
         camelized_method = symbol.to_s.camelize.to_sym
-        single_camelized_method = symbol.to_s.singularize.camelize.to_sym
-        if QBFC.const_defined?(camelized_method)
+        if camelized_method.to_s =~ /Terms\Z/
+          single_camelized_method = camelized_method
+        else
+          single_camelized_method = symbol.to_s.singularize.camelize.to_sym 
+        end
+        if QBFC.const_defined?(camelized_method) && camelized_method.to_s !~ /Terms\Z/
           if params[0]
             return QBFC::const_get(camelized_method).find_by_unique_id(self, params[0])
           else

data/lib/qbfc/transactions/generated.rb

@@ -1,18 +1,25 @@
 module QBFC
 
   # Generated Transaction types
-  TXN_TYPES = %w{ARRefundCreditCard Bill BillPaymentCheck BillPaymentCreditCard BuildAssembly Charge Check CreditCardCharge
-      CreditCardCredit CreditMemo Deposit Estimate InventoryAdjustment Invoice ItemReceipt JournalEntry PurchaseOrder
-      ReceivePayment SalesOrder SalesReceipt SalesTaxPaymentCheck TimeTracking VehicleMileage VendorCredit}
+  TXN_TYPES = %w{ARRefundCreditCard Bill BillPaymentCheck BillPaymentCreditCard
+      BuildAssembly Charge Check CreditCardCharge CreditCardCredit CreditMemo
+      Deposit Estimate InventoryAdjustment Invoice ItemReceipt JournalEntry
+      PurchaseOrder ReceivePayment SalesOrder SalesReceipt SalesTaxPaymentCheck 
+      TimeTracking VehicleMileage VendorCredit}
 
   # Generated Transaction types that support TxnVoid Request
-  TXN_VOIDABLE_TYPES = %w{ARRefundCreditCard Bill BillPaymentCheck BillPaymentCreditCard Charge Check CreditCardCharge CreditCardCredit
-      CreditMemo Deposit InventoryAdjustment Invoice ItemReceipt JournalEntry SalesReceipt VendorCredit}
+  TXN_VOIDABLE_TYPES = %w{ARRefundCreditCard Bill BillPaymentCheck
+      BillPaymentCreditCard Charge Check CreditCardCharge CreditCardCredit
+      CreditMemo Deposit InventoryAdjustment Invoice ItemReceipt JournalEntry
+      SalesReceipt VendorCredit}
   
   # Generated Transaction types that don't support Mod Requests
-  TXN_NO_MOD_TYPES = %w{ARRefundCreditCard BillPaymentCreditCard Deposit InventoryAdjustment VehicleMileage VendorCredit }
+  TXN_NO_MOD_TYPES = %w{ARRefundCreditCard BillPaymentCreditCard Deposit
+    InventoryAdjustment VehicleMileage VendorCredit }
   
   # Generate Transaction subclasses
-  generate(TXN_TYPES, Transaction, {Modifiable => (TXN_TYPES - TXN_NO_MOD_TYPES), Voidable => TXN_VOIDABLE_TYPES})
+  generate(TXN_TYPES, Transaction,
+    { Modifiable => (TXN_TYPES - TXN_NO_MOD_TYPES),
+      Voidable => TXN_VOIDABLE_TYPES })
   
 end

data/spec/spec_helper.rb

@@ -52,8 +52,9 @@ module QBFC
     
     def close
       @sess.close
+      sleep(1)
       unless @is_reader
-        sleep(5)
+        sleep(3)
         FileUtils.rm_rf(@dirname) 
       end
     end

data/spec/unit/element_finder_spec.rb

@@ -37,7 +37,7 @@ describe QBFC::Element do
     # Filter mock
     @filter = mock("QBFC::OLEWrapper#Filter")
     @request.stub!(:filter).and_return(@filter)
-    @filter.stub!(:max_returned=)
+    @request.stub!(:add_limit)
     @request.stub!(:filter_available?).and_return(true)
     @request.stub!(:apply_options)
   end
@@ -66,16 +66,15 @@ describe QBFC::Element do
     
     it "should set request#max_returned to 1 if :first" do
       setup_request
-      @request.should_receive(:filter).and_return(@filter)
+      @request.should_receive(:add_limit).with(1)
       @request.stub!(:filter_available?).and_return(true)
-      @filter.should_receive(:max_returned=).with(1)
       QBFC::Test::ElementFind::find(@sess, :first)
     end
 
     it "should not set request#max_returned if not request.filter_available?" do
       setup_request
       @request.stub!(:filter_available?).and_return(false)
-      @request.should_not_receive(:filter)
+      @request.should_not_receive(:add_limit)
       QBFC::Test::ElementFind::find(@sess, :first)
     end
 
@@ -97,9 +96,11 @@ describe QBFC::Element do
       QBFC::Test::ElementFind::find(@sess, :first).should be_nil
     end
     
-    it "can accept a Request object"
-    it "generates a Request object if not given one"
-    it "accepts conditions"
+    it "should call Base.parse_find_args" do
+      setup_request
+      QBFC::Test::ElementFind::should_receive(:parse_find_args).with({:option => true})
+      QBFC::Test::ElementFind::find(@sess, :all, {:option => true})
+    end
     
     it "applies options to request" do
       setup_request
@@ -107,8 +108,6 @@ describe QBFC::Element do
       QBFC::Test::ElementFind::find(@sess, :first, :owner_id => 0)
     end
     
-    it "passes additional arguments to Request"
-
     it "should get request#response" do
       setup_request
       @request.should_receive(:response).and_return(@response)    
@@ -138,9 +137,12 @@ describe QBFC::Element do
       @element = mock(QBFC::Test::ElementFind)
       @base_element = mock(QBFC::Test::BaseFind)
       @customer_ret = mock("CustomerRet")
-      @base_element.stub!(:ole_methods).and_return(["CustomerRet"])
+      @list_id = mock("ListID")
+      @base_element.stub!(:ole_methods).and_return(["VendorRet", "CustomerRet"])
+      @base_element.stub!(:VendorRet).and_return(nil)
       @base_element.stub!(:CustomerRet).and_return(@customer_ret)
-      @customer_ret.stub!(:ListID).and_return("123-456")
+      @customer_ret.stub!(:ListID).and_return(@list_id)
+      @list_id.stub!(:GetValue).and_return("123-456")
       QBFC::Customer.stub!(:find_by_id).and_return(@element)
 
       @response.stub!(:GetAt).and_return(@base_element)
@@ -154,7 +156,8 @@ describe QBFC::Element do
     
     it "should send class ChildList::find_by_id with ListID and find options for each" do
       @base_element.should_receive(:CustomerRet).at_least(:once).and_return(@customer_ret)
-      @customer_ret.should_receive(:ListID).at_least(:once).and_return("789-012")
+      @customer_ret.should_receive(:ListID).at_least(:once).and_return(@list_id)
+      @list_id.should_receive(:GetValue).at_least(:once).and_return("789-012")
       QBFC::Customer.should_receive(:find_by_id).at_least(:once).with(@sess, "789-012", {}).and_return(@element)
       QBFC::Test::BaseFind.find(@sess, :first, @request, {}).should be(@element)
     end

data/spec/unit/item_spec.rb

@@ -15,4 +15,19 @@ describe QBFC::Item do
     it "should return subclass objects"
   end
   
+  describe ".add_special" do
+    before(:each) do 
+      @request = mock("QBFC::Request")
+      @response = mock("QBFC::Request#response")
+    end
+    
+    it "should add a Special Account" do
+      QBFC::Request.should_receive(:new).with(@sess, "SpecialItemAdd").and_return(@request)
+      @request.should_receive(:special_item_type=).with(QBFC_CONST::SitFinanceCharge)
+      @request.should_receive(:response).and_return(@response)
+  
+      QBFC::Item.add_special(@sess, QBFC_CONST::SitFinanceCharge)
+    end
+  end
+  
 end

data/spec/unit/list_finders_spec.rb

@@ -23,7 +23,7 @@ describe QBFC::List do
     # Filter mock
     @filter = mock("QBFC::OLEWrapper#Filter")
     @request.stub!(:filter).and_return(@filter)
-    @filter.stub!(:max_returned=)
+    @request.stub!(:add_limit)
     @request.stub!(:filter_available?).and_return(true)
     @request.stub!(:apply_options)
   end

data/spec/unit/lists/account_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe QBFC::Account do
+
+ before(:each) do 
+    @sess = mock(QBFC::Session)
+    @request = mock("QBFC::Request")
+    @response = mock("QBFC::Request#response")
+  end
+  
+  it "should add a Special Account" do
+    QBFC::Request.should_receive(:new).with(@sess, "SpecialAccountAdd").and_return(@request)
+    @request.should_receive(:special_account_type=).with(QBFC_CONST::SatAccountsReceivable)
+    @request.should_receive(:response).and_return(@response)
+    QBFC::Account.should_receive(:new).with(@sess, @response)
+
+    QBFC::Account.add_special(@sess, QBFC_CONST::SatAccountsReceivable)
+  end
+
+end

data/spec/unit/ole_wrapper_spec.rb

@@ -140,6 +140,13 @@ describe QBFC::OLEWrapper do
       
       @wrapper.qbfc_method_missing(@sess, :full_name=, 'Full Name')
     end
+    
+    it "should convert Dates in setter method" do
+      @ole_object.should_receive(:TimeModified).and_return(@full_name)
+      @full_name.should_receive(:SetValue).with('2008-01-01')
+      
+      @wrapper.qbfc_method_missing(@sess, :time_modified=, Date.parse('2008-01-01'))
+    end
 
     it "should set @setter also when acting as a setter method, if applicable" do
       @setter = mock(WIN32OLE)

data/spec/unit/request_query_survey.txt

@@ -6,7 +6,7 @@ lists
   - list_id_list
   - full_name_list
   - txn_id_list
-  - ref_number_list
+  X ref_number_list
   - ref_number_case_sensitive_list
   
 filters

data/spec/unit/request_spec.rb

@@ -199,12 +199,249 @@ describe QBFC::Request do
   describe "#apply_options" do
     before(:each) do
       @request = QBFC::Request.new(@sess, 'CustomerQuery')
+      @query = mock('Request#query')
+      @filter = mock('Request#filter')
+      @request.stub!(:query).and_return(@query)
     end
   
-    it "accepts an :owner_id option" do
+    it "should apply an :owner_id option" do
       @request.should_receive(:add_owner_ids).with(1)
       @request.apply_options(:owner_id => 1)
     end
+
+    it "should apply an :limit option" do
+      @request.should_receive(:add_limit).with(1)
+      @request.apply_options(:limit => 1)
+    end
+    
+    it "should apply an :include option" do
+      include_ary = [1,2,3]
+      @request.should_receive(:add_includes).with(include_ary)
+      @request.apply_options(:include => include_ary)
+    end
+    
+    it "should apply lists to query" do
+      ref_number_list = mock('OLEWrapper#ref_number_list')
+      @query.should_receive(:RefNumberList).and_return(ref_number_list)
+      ref_number_list.should_receive(:Add).with('82')
+      ref_number_list.should_receive(:Add).with('1234')
+
+      @request.apply_options(:conditions => {:ref_number_list => %w{82 1234}})
+    end
+
+    it "should apply lists to query when given a single item" do
+      ref_number_list = mock('OLEWrapper#ref_number_list')
+      @query.should_receive(:RefNumberList).and_return(ref_number_list)
+      ref_number_list.should_receive(:Add).with('20')
+
+      @request.apply_options(:conditions => {:ref_number_list => '20'})
+    end
+    
+    describe "(range)" do
+      before(:each) do
+        @range_filter = mock('Request#TxnDateRangeFilter')
+        @request.stub!(:filter_for).with('txn_date_range').and_return(@range_filter)
+        @request.stub!(:filter_for).with('modified_date_range').and_return(@range_filter)
+        @range_filter.stub!(:from_txn_date=)
+        @range_filter.stub!(:to_txn_date=)
+      end
+    
+      it "should #parse_range_value" do
+        @request.should_receive(:parse_range_value).with([0,2]).and_return([0,2])
+        @request.apply_options(:conditions => {:txn_date_range => [0,2]})
+      end
+      
+      it "should get appropriate filter" do
+        @request.should_receive(:filter_for).with('txn_date_range').and_return(@range_filter)
+        @request.apply_options(:conditions => {:txn_date_range => [0,2]})
+      end
+      
+      it "should apply date range to filter" do
+        @range_filter.should_receive(:from_txn_date=).with(0)
+        @range_filter.should_receive(:to_txn_date=).with(2)
+        @request.apply_options(:conditions => {:txn_date_range => [0,2]})
+      end
+
+      it "should add 'true' argument (asDateOnly) for modified_date ranges" do
+        @range_filter.should_receive(:from_modified_date=).with(0, true)
+        @range_filter.should_receive(:to_modified_date=).with(2, true)
+        @request.apply_options(:conditions => {:modified_date_range => [0,2]})
+      end
+    end
+    
+    describe "(status)" do
+      it "should set status" do
+        @filter = mock('Request#filter')
+        @request.stub!(:filter).and_return(@filter)
+        @filter.should_receive(:paid_status=).with(QBFC_CONST::PsPaidOnly)
+        @request.apply_options(:conditions => {:paid_status => QBFC_CONST::PsPaidOnly})
+      end
+    end
+    
+    describe "(reference)" do
+      before(:each) do
+        @ref_filter = mock('Request#RefFilter')
+        @full_name_list = mock('OLEWrapper#FullNameList')
+        @request.stub!(:filter_for).with('entity').and_return(@ref_filter)
+        @ref_filter.should_receive(:FullNameList).at_least(:once).and_return(@full_name_list)
+        @full_name_list.stub!(:Add)
+      end
+    
+      it "should get appropriate filter" do
+        @request.should_receive(:filter_for).with('entity').and_return(@ref_filter)
+        @request.apply_options(:conditions => {:entity => 'ABC Supplies'})
+      end
+      
+      it "should set a single full name" do
+        @full_name_list.should_receive(:Add).with('ABC Supplies')
+        @request.apply_options(:conditions => {:entity => 'ABC Supplies'})
+      end
+
+      it "should set a single full name (non-string)" do
+        @full_name_list.should_receive(:Add).with(1)
+        @request.apply_options(:conditions => {:entity => 1})
+      end
+      
+      it "should set a multiple full names" do
+        @full_name_list.should_receive(:Add).with('ABC Supplies')
+        @full_name_list.should_receive(:Add).with('CompuStuff')
+        @request.apply_options(:conditions => {:entity => %w{ABC\ Supplies CompuStuff}})
+      end
+    end
+  end
+  
+  describe "#add_includes" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+      @ret_list = mock('RetElementList')
+      
+      @ole_request.stub!(:respond_to_ole?).with('IncludeLineItems').and_return(true)
+      @ole_request.stub!(:respond_to_ole?).with('IncludeLinkedTxns').and_return(true)
+      @ole_request.stub!(:respond_to_ole?).with('IncludeTxnID').and_return(false)
+      @ole_request.stub!(:respond_to_ole?).with('IncludeCustomerRef').and_return(false)
+    end
+    
+    it "should add specific include requests" do
+      @ole_request.should_receive(:include_line_items=).with(true)
+      @request.__send__(:add_includes, [:line_items])
+    end
+    
+    it "should apply additional includes to IncludeRetElementList" do
+      @ole_request.should_receive(:IncludeRetElementList).twice.and_return(@ret_list)
+      @ret_list.should_receive(:Add).with('TxnID')
+      @ret_list.should_receive(:Add).with('CustomerRef')
+      @request.__send__(:add_includes, [:txn_id, :customer_ref])
+    end
+    
+    it "should include :all" do
+      @ole_request.should_receive(:ole_methods).and_return(%w{ORTxnQuery IncludeLineItems IncludeLinkedTxns iterator})
+      @ole_request.should_receive(:include_line_items=).with(true)
+      @ole_request.should_receive(:include_linked_txns=).with(true)
+      @request.__send__(:add_includes, :all)
+    end
+  end
+  
+  describe "#parse_range_value" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+    end
+
+    it "should add a nil element to a one-element Array" do
+      ary = [0]
+      @request.__send__(:parse_range_value, ary).should == [0, nil]
+    end
+    
+    it "should return unchanged a multiple element Array" do
+      ary = [0, 1]
+      @request.__send__(:parse_range_value, ary).should be(ary)
+    end
+    
+    it "should return unchanged a Range" do
+      rng = 0..1
+      @request.__send__(:parse_range_value, rng).should be(rng)
+    end
+    
+    it "should take a scalar and return an array with the second element nil" do
+      val = 0
+      @request.__send__(:parse_range_value, val).should == [val, nil]
+    end
+    
+    it "should take a String scalar and return an array with the second element nil" do
+      val = '0'
+      @request.__send__(:parse_range_value, val).should == [val, nil]
+    end
+  
+  end
+  
+  describe "#filter_for" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+      @query = mock('Request#query')
+      @filter = mock('Request#filter')
+      @request.stub!(:query).and_return(@query)
+      @request.stub!(:filter).and_return(@filter)
+
+      @or_date_range_filter = mock('Request#ORDateRangeFilter')
+      @or_ref_number_filter = mock('Request#ORRefNumberFilter')
+      @txn_date_range_filter = mock('Request#TxnDateRangeFilter')
+      @final_filter = mock('Request#FinalFilter')
+      
+      @filter.stub!(:respond_to_ole?).and_return(false)
+      @or_date_range_filter.stub!(:respond_to_ole?).and_return(false)
+      @final_filter.stub!(:respond_to_ole?).and_return(false)
+    end
+  
+    it "should follow ORDateRangeFilter for date_ranges" do
+      @filter.should_receive(:respond_to_ole?).with('ORDateRangeFilter').and_return(true)
+      @filter.should_receive(:ORDateRangeFilter).and_return(@or_date_range_filter)
+      @or_date_range_filter.should_receive(:ModifiedDateRangeFilter).and_return(@final_filter)
+      
+      @request.__send__(:filter_for, 'modified_date_range').should be(@final_filter)
+    end
+
+    it "should follow OR{name}Filter" do
+      @filter.should_receive(:respond_to_ole?).with('ORRefNumberFilter').and_return(true)
+      @filter.should_receive(:ORRefNumberFilter).and_return(@or_ref_number_filter)
+      @or_ref_number_filter.should_receive(:RefNumberFilter).and_return(@final_filter)
+      
+      @request.__send__(:filter_for, 'ref_number').should be(@final_filter)
+    end
+    
+    it "should follow OR{name}Filter, with 'Range' removed" do
+      @filter.should_receive(:respond_to_ole?).with('ORRefNumberFilter').and_return(true)
+      @filter.should_receive(:ORRefNumberFilter).and_return(@or_ref_number_filter)
+      @or_ref_number_filter.should_receive(:RefNumberRangeFilter).and_return(@final_filter)
+      
+      @request.__send__(:filter_for, 'ref_number_range').should be(@final_filter)
+    end
+    
+    it "should return #filter if *ModifiedDate in #filter" do
+      @filter.should_receive(:respond_to_ole?).with('FromModifiedDate').and_return(true)
+      @request.__send__(:filter_for, 'modified_date_range').should == @filter
+    end
+    
+    it "should follow OR below the Filter" do
+      @filter.should_receive(:respond_to_ole?).with('TxnDateRangeFilter').and_return(true)
+      @filter.should_receive(:TxnDateRangeFilter).and_return(@txn_date_range_filter)
+      
+      @txn_date_range_filter.should_receive(:respond_to_ole?).with('ORTxnDateRangeFilter').and_return(true)
+      @txn_date_range_filter.should_receive(:ORTxnDateRangeFilter).and_return(@or_date_range_filter)
+      
+      @request.__send__(:filter_for, 'txn_date_range').should be(@or_date_range_filter)
+    end
+
+    it "should get a nested Filter with 'Range' removed" do
+      @filter.should_receive(:respond_to_ole?).with('TxnDateRangeFilter').and_return(true)
+      @filter.should_receive(:TxnDateRangeFilter).and_return(@txn_date_range_filter)
+      
+      @txn_date_range_filter.should_receive(:respond_to_ole?).with('ORTxnDateRangeFilter').and_return(true)
+      @txn_date_range_filter.should_receive(:ORTxnDateRangeFilter).and_return(@or_date_range_filter)
+      
+      @or_date_range_filter.should_receive(:respond_to_ole?).with('TxnDateFilter').and_return(true)
+      @or_date_range_filter.should_receive(:TxnDateFilter).and_return(@final_filter)
+      
+      @request.__send__(:filter_for, 'txn_date_range').should be(@final_filter)
+    end
   end
   
   describe "#add_owner_ids" do
@@ -233,4 +470,17 @@ describe QBFC::Request do
       @request.add_owner_ids(nil)
     end
   end
+  
+  describe "#add_limit" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+      @filter = mock('Request#filter')
+      @request.stub!(:filter).and_return(@filter)
+    end
+ 
+    it "can should update the filter's max_returned value" do
+      @filter.should_receive(:max_returned=).with(1)
+      @request.add_limit(1)
+    end
+  end
 end

data/spec/unit/session_spec.rb

@@ -124,6 +124,12 @@ describe QBFC::Session do
     QBFC::QBCollection.should_receive(:new).with(@qb_sess, :QBClass).and_return(@collection)
     @qb_sess.classes.should == @collection
   end
+
+  it "should create QBFC::QBCollection for QBFC::Terms from #terms" do
+    @collection = mock(QBFC::QBCollection)
+    QBFC::QBCollection.should_receive(:new).with(@qb_sess, :Terms).and_return(@collection)
+    @qb_sess.terms.should == @collection
+  end
   
   it "should let OLEWrapper handle other unknown methods" do
     @ole_wrapper.should_receive(:qbfc_method_missing).with(@qb_sess, :FullName).and_return(true)

data/spec/unit/transaction_finders_spec.rb

@@ -23,7 +23,7 @@ describe QBFC::Transaction do
     # Filter mock
     @filter = mock("QBFC::OLEWrapper#Filter")
     @request.stub!(:filter).and_return(@filter)
-    @filter.stub!(:max_returned=)
+    @request.stub!(:add_limit)
     @request.stub!(:filter_available?).and_return(true)
     @request.stub!(:apply_options)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: qbfc
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: x86-mswin32-60
 authors: 
 - Jared Morgan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-22 00:00:00 -06:00
+date: 2008-03-24 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -42,6 +42,7 @@ files:
 - lib/qbfc/entities/generated.rb
 - lib/qbfc/infos/generated.rb
 - lib/qbfc/items/generated.rb
+- lib/qbfc/lists/account.rb
 - lib/qbfc/lists/generated.rb
 - lib/qbfc/lists/qb_class.rb
 - lib/qbfc/terms/generated.rb
@@ -81,6 +82,7 @@ files:
 - spec/unit/entities/generated_spec.rb
 - spec/unit/info/generated_spec.rb
 - spec/unit/items/generated_spec.rb
+- spec/unit/lists/account_spec.rb
 - spec/unit/lists/generated_spec.rb
 - spec/unit/lists/qb_class_spec.rb
 - spec/unit/terms/generated_spec.rb
@@ -134,6 +136,7 @@ test_files:
 - spec/unit/entities/generated_spec.rb
 - spec/unit/info/generated_spec.rb
 - spec/unit/items/generated_spec.rb
+- spec/unit/lists/account_spec.rb
 - spec/unit/lists/generated_spec.rb
 - spec/unit/lists/qb_class_spec.rb
 - spec/unit/terms/generated_spec.rb