quickbooks 0.4.0 → 0.9.9

data/lib/qbxml.rb

@@ -1,3 +0,0 @@
-require 'qbxml/request'
-require 'qbxml/response'
-QBXML_VERSION = '0.1.0'

data/lib/qbxml/request.rb

@@ -1,207 +0,0 @@
-require 'qbxml/support'
-require 'builder'
-require 'hash_magic'
-
-module Qbxml
-  VERSION = '6.0'
-
-  # module RequestSetArrayExt
-  # end
-
-  class RequestSet
-    include Enumerable
-    def set
-      unless @set.is_a?(Array)
-        @set = []
-        # @set.extend(Qbxml::RequestSetArrayExt)
-      end
-      @set
-    end
-    delegate_methods [:each, :length, :first, :last, :[], :map, :join] => :set
-    def <<(qbxml_request)
-      if qbxml_request.is_a?(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 Qbxml::RequestSet"
-      end
-    end
-
-    def initialize(*requests)
-      self << requests
-    end
-
-    def to_xml
-      pre = <<-thequickbooks_qbxmlrequestsetxml
-<?xml version="1.0" ?>
-<?qbxml version="#{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
-    # 1. List queries (:query)
-    #   Request.new(object, :query) # <= will return the record matching the object supplied (automatically searches by list_id or txn_id)
-    #   Request.new(Customer, :query, :limit => 1) # <= will return the first customer
-    #   Request.new(Customer, :query, /some match/) # <= will return all customers matching the regexp
-    # 2. Deleted queries (:deleted)
-    #   Request.new(object, :deleted) # <= INVALID!! (besides, you wouldn't have an object to check up on anyway :P )
-    #   Request.new(Customer, :deleted) # <= will return all deleted Customers
-    #   Request.new(Customer, :deleted, :deleted_date_range_filter => {'from_deleted_date' => Date.parse('2008/10/05')}) # <= will return all Customers deleted since 5 October 2008
-    # 3. Object-specific transaction query (:transaction)
-    #   Request.new(Transaction, :query) # <= will return the transaction matching the object supplied
-    # 4. Mod requests (:mod)
-    #   Request.new(object, :mod) # <= will update the object
-    # 5. Delete requests (:delete)
-    #   Request.new(object, :delete) # <= will delete the object
-    # We want the attributes of the object when we are updating, but no other time.
-    def initialize(object, type, options_or_regexp={})
-      options = options_or_regexp.is_a?(Regexp) ? {:matches => options_or_regexp} : options_or_regexp
-      @type = type
-      raise ArgumentError, "Qbxml::Requests can only be of one of the following types: :query, :transaction, :any_transaction, :mod, :add, :delete, :deleted, or :report" unless @type.is_one_of?(:query, :transaction, :any_transaction, :mod, :report, :add, :delete, :deleted)
-      @klass = object.is_a?(Class) ? object : object.class
-      @object = object
-      @options = options
-
-      # Transform the options received for :deleted requests.
-      # This way, Request.new(Customer, :deleted) == Request.new(ListDeleted, :list_del_type => 'Customer')
-      # and Request.new(Transaction, :deleted) == Request.new(TxnDeleted, :txn_del_type => 'Transaction')
-      if @type == :deleted
-        case @klass.ListOrTxn
-        when 'List'
-          @options[:list_del_type] = @klass.lone_name
-          @klass = Quickbooks::ListDeleted
-        when 'Txn'
-          @options[:txn_del_type] = @klass.lone_name
-          @klass = Quickbooks::TxnDeleted
-        end
-      end
-
-      # Return only specific properties: Request.new(Customer, :query, :only => [:list_id, :full_name]); Quickbooks::Customer.first(:only => :list_id)
-      @ret_elements = @options.delete(:only).to_a.only(@klass.properties).ordered(@klass.properties).stringify_values.camelize_values!(Quickbooks::CAMELIZE_EXCEPTIONS) if @options.has_key?(:only)
-
-      # Includes only valid filters + aliases for valid filters, # => {underscore/slashed keys + aliases}
-      # then transforms aliased filters to real filters, # => {underscore/slashed keys}
-      # then camelizes keys to prepare for writing to XML, # => {}
-      # lastly orders the keys to a valid filter order.
-
-      # Study the following:
-      #   @klass.filter_aliases = {'deleted_after' => 'deleted_date_range_filter/from_deleted_date'}
-      #   @klass.valid_filters = ['deleted_date_range_filter/from_deleted_date']
-      #   {:deleted_after => "2008-03-20T11:20:26-04:00"}.slashed.
-      #     only(@klass.valid_filters + @klass.filter_aliases.slashed.flat.keys).
-      #     transform_keys!(@klass.filter_aliases.slashed.flat).
-      #     slash_camelize_keys!(Quickbooks::CAMELIZE_EXCEPTIONS).slashed.
-      #     ordered!(@klass.camelized_valid_filters).slashed.expand
-      #   # => {"DeletedDateRangeFilter" => {"FromDeletedDate" => "2008-03-20T11:20:26-04:00"}}
-      @filters = @options.delete(:filters) || @options.slashed.
-        only(@klass.valid_filters + @klass.filter_aliases.slashed.flat.keys).
-        transform_keys!(@klass.filter_aliases.slashed.flat).
-        slash_camelize_keys!(Quickbooks::CAMELIZE_EXCEPTIONS).
-        ordered!(@klass.camelized_valid_filters)
-      @filters = @filters.to_hash unless @filters.is_a?(Hash)
-      @filters = @filters['FILTERS'] if @filters.keys == ['FILTERS'] # So if you include an xml-formatted string of filters, you can simply wrap them in <FILTERS></FILTERS> as a root key
-
-      # Complain if:
-      #   1) type is :mod or :delete, and object supplied is not a valid model
-      raise ArgumentError, "A Quickbooks record object must be supplied to perform an add, mod or del action" if @type.is_one_of?(:add, :mod, :delete) && !@object.is_a?(Quickbooks::Base)
-    end
-
-    def self.next_request_id
-      @request_id ||= 0
-      @request_id += 1
-    end
-
-    # This is where the magic happens to convert a request object into xml worthy of 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)
-      request_root, container = case
-      when @type.is_one_of?(:query)
-        ["#{@klass.class_leaf_name}QueryRq", nil]
-      when @type == :add
-        ["#{@klass.class_leaf_name}AddRq", "#{@klass.class_leaf_name}Add"]
-      when @type == :mod
-        ["#{@klass.class_leaf_name}ModRq", "#{@klass.class_leaf_name}Mod"]
-      when @type == :delete
-        ["#{@klass.ListOrTxn}DelRq", nil]
-      when @type == :deleted
-        ["#{@klass.ListOrTxn}DeletedQueryRq", nil]
-      else
-        raise RuntimeError, "Could not convert this request to qbxml!\n#{self.inspect}"
-      end
-      inner_stuff = lambda {
-        deep_tag = lambda {|k,v|
-          if v.is_a?(Hash)
-            if k == ''
-              v.each { |k,v|
-                deep_tag.call(k,v)
-              }
-            else
-              req.tag!(k.camelize) { v.each { |k,v| deep_tag.call(k,v) } }
-            end
-          else
-            req.tag!(k.camelize,uncast(v))
-          end
-        }
-
-        # Add the specific elements for the respective request type
-        if @type.is_one_of?(:add, :mod)
-          if @type == :mod
-            # First the ObjectId:
-            req.tag!(@klass.ListOrTxn + 'ID', @object.send("#{@klass.ListOrTxn}Id".underscore))
-            # Second the EditSequence
-            req.tag!('EditSequence', @object.send(:edit_sequence))
-          end
-          # Then, all the dirty_attributes
-          deep_tag.call('',@object.to_dirty_hash) # (this is an hash statically ordered to the model's qbxml attribute order)
-        elsif @type == :query && @object.class == @klass
-          # Sent an instance object for a query - we should include the ListId/TxnId (then other filters?)
-          req.tag!(@klass.ListOrTxn + 'ID', @object.send("#{@klass.ListOrTxn}Id".underscore))
-          deep_tag.call('', @filters)
-        elsif @type == :delete
-          req.tag!(@klass.ListOrTxn + 'DelType', @klass.class_leaf_name)
-          req.tag!(@klass.ListOrTxn + 'ID', @object.send("#{@klass.ListOrTxn}Id".underscore))
-        else
-          # just filters
-          deep_tag.call('', @filters)
-        end
-        # Lastly, specify the fields to return, if desired
-        @ret_elements.each { |r| req.tag!('IncludeRetElement', r) } if @ret_elements.is_a?(Array) && @ret_elements.length > 0
-      }
-      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
-
-    private
-      def uncast(v)
-        case
-        when v.respond_to?(:xmlschema)
-          v.xmlschema
-        else
-          v
-        end
-      end
-  end
-end

data/lib/qbxml/response.rb

@@ -1,197 +0,0 @@
-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 (fallback nil) if not more than one.
-    end
-  end
-end

data/lib/qbxml/support.rb

@@ -1,130 +0,0 @@
-gem 'formattedstring'
-gem 'builder'
-gem 'hash_magic'
-
-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