quickeebooks 0.0.2

data/lib/quickeebooks/online/service/entitlement.rb

@@ -0,0 +1,15 @@
+module Quickeebooks
+  module Online
+    module Service
+      class Entitlement < ServiceBase
+
+        def status
+          url = url_for_base("manage/entitlements")
+          response = do_http_get(url)
+          puts response.body
+        end
+
+      end
+    end
+  end
+end

data/lib/quickeebooks/online/service/filter.rb

@@ -0,0 +1,96 @@
+module Quickeebooks
+  module Online
+    module Service
+      class Filter
+
+        DATE_FORMAT = '%Y-%m-%d'
+        DATE_TIME_FORMAT = '%Y-%m-%dT%H:%M:%S%z'
+
+        attr_reader :type
+        attr_accessor :field, :value
+
+        # For Date/Time filtering
+        attr_accessor :before, :after
+
+        # For number comparisons
+        attr_accessor :gt, :lt, :eq
+
+        def initialize(type, *args)
+          @type = type
+          if args.first.is_a?(Hash)
+            args.first.each_pair do |key, value|
+              instance_variable_set("@#{key}", value)
+            end
+          end
+        end
+
+        def to_s
+          case @type.to_sym
+          when :date, :datetime
+            date_time_to_s
+          when :text
+            text_to_s
+          when :boolean
+            boolean_to_s
+          when :number
+            number_to_s
+          else
+            raise ArgumentError, "Don't know how to generate a Filter for type #{@type}"
+          end
+        end
+
+        private
+
+        def number_to_s
+          clauses = []
+          if @eq
+            clauses << "#{@field} :EQUALS: #{@value}"
+          end
+          if @gt
+            clauses << "#{@field} :GreaterThan: #{@value}"
+          end
+          if @lt
+            clauses << "#{@field} :LessThan: #{@value}"
+          end
+          clauses.join(" :AND: ")
+        end
+
+        def date_time_to_s
+          clauses = []
+          if @before
+            raise ':before is not a valid DateTime/Time object' unless (@before.is_a?(Time) || @before.is_a?(DateTime))
+            clauses << "#{@field} :BEFORE: #{formatted_time(@before)}"
+          end
+          if @after
+            raise ':after is not a valid DateTime/Time object' unless (@after.is_a?(Time) || @after.is_a?(DateTime))
+            clauses << "#{@field} :AFTER: #{formatted_time(@after)}"
+          end
+
+          if @before.nil? && @after.nil?
+            clauses << "#{@field} :EQUALS: #{formatted_time(@value)}"
+          end
+
+          clauses.join(" :AND: ")
+        end
+
+        def text_to_s
+          "#{@field} :EQUALS: #{@value}"
+        end
+
+        def boolean_to_s
+          "#{@field} :EQUALS: #{@value}"
+        end
+
+        def formatted_time(time)
+          if time.is_a?(Date)
+            time.strftime(DATE_FORMAT)
+          elsif time.is_a?(DateTime) || time.is_a?(Time)
+            time.strftime(DATE_TIME_FORMAT)
+          end
+        end
+
+
+      end
+    end
+  end
+end

data/lib/quickeebooks/online/service/invoice.rb

@@ -0,0 +1,50 @@
+require 'quickeebooks/online/service/service_base'
+require 'quickeebooks/online/model/invoice'
+require 'quickeebooks/online/model/invoice_header'
+require 'quickeebooks/online/model/invoice_line_item'
+require 'tempfile'
+
+module Quickeebooks
+  module Online
+    module Service
+      class Invoice < ServiceBase
+
+
+        # Fetch a +Collection+ of +Invoice+ objects
+        # Arguments:
+        # filters: Array of +Filter+ objects to apply
+        # page: +Fixnum+ Starting page
+        # per_page: +Fixnum+ How many results to fetch per page
+        # sort: +Sort+ object
+        # options: +Hash+ extra arguments
+        def list(filters = [], page = 1, per_page = 20, sort = nil, options = {})
+          fetch_collection("invoices", "Invoice", Quickeebooks::Online::Model::Invoice, filters, page, per_page, sort, options)
+        end
+
+        # Returns the absolute path to the PDF on disk
+        # Its left to the caller to unlink the file at some later date
+        # Returns: +String+ : absolute path to file on disk or nil if couldnt fetch PDF
+        def invoice_as_pdf(invoice_id, destination_parent_directory)
+          response = do_http_get("#{url_for_resource("invoice-document")}/#{invoice_id}", {}, {'Content-Type' => 'application/pdf'})
+          if response && response.code.to_i == 200
+            file_name = File.join(destination_parent_directory, "invoice-document-#{invoice_id}-#{Time.now.strftime('%Y-%m-%d_%H-%M')}.pdf")
+            File.open(file_name, "wb") do |file|
+              file.write(response.body)
+            end
+            file_name
+          else
+            nil
+          end
+        end
+
+        # Fetch an invoice by its ID
+        # Returns: +Invoice+ object
+        def fetch_by_id(invoice_id)
+          response = do_http_get("#{url_for_resource("invoice")}/#{invoice_id}")
+          Quickeebooks::Online::Model::Invoice.from_xml(response.body)
+        end
+
+      end
+    end
+  end
+end

data/lib/quickeebooks/online/service/item.rb

@@ -0,0 +1,52 @@
+require 'quickeebooks/online/model/item'
+require 'quickeebooks/online/service/service_base'
+
+module Quickeebooks
+  module Online
+    module Service
+      class Item < ServiceBase
+
+        def list(filters = [], page = 1, per_page = 20, sort = nil, options = {})
+          fetch_collection("items", "Item", Quickeebooks::Online::Model::Item, filters, page, per_page, sort, options)
+        end
+
+        def create(item)
+          raise InvalidModelException unless item.valid?
+          xml = item.to_xml_ns
+          response = do_http_post(url_for_resource("item"), valid_xml_document(xml))
+          if response && response.code.to_i == 200
+            Quickeebooks::Online::Model::Item.from_xml(response.body)
+          else
+            nil
+          end
+        end
+
+        def update(item)
+          raise InvalidModelException unless item.valid?
+          xml = item.to_xml_ns
+          url = "#{url_for_resource("item")}/#{item.id}"
+          response = do_http_post(url, valid_xml_document(xml))
+          if response && response.code.to_i == 200
+            Quickeebooks::Online::Model::Item.from_xml(response.body)
+          else
+            nil
+          end
+        end
+
+        def fetch_by_id(id)
+          response = do_http_get("#{url_for_resource("item")}/#{id}")
+          Quickeebooks::Online::Model::Item.from_xml(response.body)
+        end
+
+        def delete(item)
+          raise InvalidModelException.new("Missing required parameters for delete") unless item.valid_for_deletion?
+          xml = valid_xml_document(item.to_xml_ns(:fields => ['Id', 'SyncToken']))
+          url = "#{url_for_resource("item")}/#{item.id}"
+          response = do_http_post(url, xml, {:methodx => "delete"})
+          response.code.to_i == 200
+        end
+
+      end
+    end
+  end
+end

data/lib/quickeebooks/online/service/pagination.rb

@@ -0,0 +1,19 @@
+module Quickeebooks
+  module Online
+    module Service
+      class Pagination
+        attr_accessor :page, :results_per_page
+
+        def initialize(page, results_per_page)
+          @page = page
+          @results_per_page = results_per_page
+        end
+
+        def to_s
+          "PageNum=#{@page}\nResultsPerPage=#{@results_per_page}"
+        end
+
+      end
+    end
+  end
+end

data/lib/quickeebooks/online/service/service_base.rb

@@ -0,0 +1,202 @@
+require 'rexml/document'
+require 'uri'
+require 'cgi'
+
+class IntuitRequestException < Exception
+  attr_accessor :code, :cause
+  def initialize(msg)
+    super(msg)
+  end
+end
+class AuthorizationFailure < Exception; end
+
+module Quickeebooks
+  module Online
+
+    module Service
+      class ServiceBase
+        attr_accessor :realm_id
+        attr_accessor :oauth
+        attr_reader :base_uri
+
+        QB_BASE_URI = "https://qbo.intuit.com/qbo1/rest/user/v2"
+        XML_NS = %{xmlns:ns2="http://www.intuit.com/sb/cdm/qbo" xmlns="http://www.intuit.com/sb/cdm/v2" xmlns:ns3="http://www.intuit.com/sb/cdm"}
+
+        def initialize(oauth_consumer_token, realm_id, base_url = nil)
+          @oauth = oauth_consumer_token
+          @realm_id = realm_id
+          if base_url.nil?
+            determine_base_url
+          else
+            uri = URI.parse(base_url)
+            if uri.host.nil?
+              raise ArgumentError, "#{base_url} doesn't appear to be a valid host name!"
+            end
+            @base_uri = base_url
+          end
+        end
+
+        # Given a realm ID we need to determine the real Base URL
+        # to use for all subsequenet REST operations
+        # See: https://ipp.developer.intuit.com/0010_Intuit_Partner_Platform/0050_Data_Services/0400_QuickBooks_Online/0100_Calling_Data_Services/0010_Getting_the_Base_URL
+        def determine_base_url
+          response = @oauth.request(:get, qb_base_uri_with_realm_id)
+          if response
+            if response.code == "200"
+              doc = parse_xml(response.body)
+              element = doc.xpath("//qbo:QboUser/qbo:CurrentCompany/qbo:BaseURI")[0]
+              if element
+                @base_uri = element.text
+              end
+            else
+              raise IntuitRequestException.new("Response error: invalid code #{response.code}")
+            end
+          end
+        end
+
+        def url_for_resource(resource)
+          url_for_base("resource/#{resource}")
+          #{}"#{@base_uri}/resource/#{resource}/v2/#{@realm_id}"
+        end
+
+        def url_for_base(raw)
+          "#{@base_uri}/#{raw}/v2/#{@realm_id}"
+        end
+
+        def qb_base_uri_with_realm_id
+          "#{QB_BASE_URI}/#{@realm_id}"
+        end
+
+        private
+
+        def parse_xml(xml)
+          Nokogiri::XML(xml)
+        end
+
+        def valid_xml_document(xml)
+          %Q{<?xml version="1.0" encoding="utf-8"?>\n#{xml.strip}}
+        end
+
+        def fetch_collection(resource, container, model, filters = [], page = 1, per_page = 20, sort = nil, options ={})
+          raise ArgumentError, "missing resource to fetch" if resource.nil?
+          raise ArgumentError, "missing result container" if container.nil?
+          raise ArgumentError, "missing model to instantiate" if model.nil?
+
+          post_body_lines = []
+
+          if filters.is_a?(Array) && filters.length > 0
+            filter_string = filters.collect { |f| f.to_s }
+            post_body_lines << "Filter=#{CGI.escape(filter_string.join(" :AND: "))}"
+          end
+
+          post_body_lines << "PageNum=#{page}"
+          post_body_lines << "ResultsPerPage=#{per_page}"
+
+          if sort
+            post_body_lines << "Sort=#{CGI.escape(sort.to_s)}"
+          end
+
+          body = post_body_lines.join("&")
+          response = do_http_post(url_for_resource(resource), body, {}, {'Content-Type' => 'application/x-www-form-urlencoded'})
+          if response
+            collection = Quickeebooks::Collection.new
+            xml = parse_xml(response.body)
+            begin
+              results = []
+              collection.count = xml.xpath("//qbo:SearchResults/qbo:Count")[0].text.to_i
+              if collection.count > 0
+                xml.xpath("//qbo:SearchResults/qbo:CdmCollections/xmlns:#{container}").each do |xa|
+                  results << model.from_xml(xa)
+                end
+              end
+              collection.entries = results
+              collection.current_page = xml.xpath("//qbo:SearchResults/qbo:CurrentPage")[0].text.to_i
+            rescue => ex
+              log("Error parsing XML: #{ex.message}")
+              raise IntuitRequestException.new("Error parsing XML: #{ex.message}")
+            end
+            collection
+          else
+            nil
+          end
+        end
+
+        def do_http_post(url, body = "", params = {}, headers = {}) # throws IntuitRequestException
+          url = add_query_string_to_url(url, params)
+          do_http(:post, url, body, headers)
+        end
+
+        def do_http_get(url, params = {}, headers = {}) # throws IntuitRequestException
+          url = add_query_string_to_url(url, params)
+          do_http(:get, url, "", headers)
+        end
+
+        def do_http(method, url, body, headers) # throws IntuitRequestException
+          unless headers.has_key?('Content-Type')
+            headers.merge!({'Content-Type' => 'application/xml'})
+          end
+          # puts "METHOD = #{method}"
+          # puts "URL = #{url}"
+          # puts "BODY = #{body == nil ? "<NIL>" : body}"
+          # puts "HEADERS = #{headers.inspect}"
+          response = @oauth.request(method, url, body, headers)
+          check_response(response)
+        end
+
+        def add_query_string_to_url(url, params)
+          if params.is_a?(Hash) && !params.empty?
+            url + "?" + params.collect { |k| "#{k.first}=#{k.last}" }.join("&")
+          else
+            url
+          end
+        end
+
+        def check_response(response)
+          #puts "HTTP Response: #{response.code}"
+          status = response.code.to_i
+          case status
+          when 200
+            response
+          when 302
+            raise "Unhandled HTTP Redirect"
+          when 401
+            raise AuthorizationFailure
+          when 400, 500
+            err = parse_intuit_error(response.body)
+            ex = IntuitRequestException.new(err[:message])
+            ex.code = err[:code]
+            ex.cause = err[:cause]
+            raise ex
+          else
+            raise "HTTP Error Code: #{status}, Msg: #{response.body}"
+          end
+        end
+
+        def parse_intuit_error(body)
+          xml = parse_xml(body)
+          error = {:message => "", :code => 0, :cause => ""}
+          fault = xml.xpath("//xmlns:FaultInfo/xmlns:Message")[0]
+          if fault
+            error[:message] = fault.text
+          end
+          error_code = xml.xpath("//xmlns:FaultInfo/xmlns:ErrorCode")[0]
+          if error_code
+            error[:code] = error_code.text
+          end
+          error_cause = xml.xpath("//xmlns:FaultInfo/xmlns:Cause")[0]
+          if error_cause
+            error[:cause] = error_cause.text
+          end
+
+          error
+        end
+
+        def log(msg)
+          Quickeebooks.logger.info(msg)
+          Quickeebooks.logger.flush if Quickeebooks.logger.respond_to?(:flush)
+        end
+
+      end
+    end
+  end
+end

data/lib/quickeebooks/online/service/sort.rb

@@ -0,0 +1,19 @@
+module Quickeebooks
+  module Online
+    module Service
+      class Sort
+        attr_accessor :field, :how
+
+        def initialize(field, how)
+          @field = field
+          @how = how
+        end
+
+        def to_s
+          "#{field} #{how}"
+        end
+
+      end
+    end
+  end
+end