Compatibility with Zoho API V3

lib/zoho_invoice/base.rb

@@ -24,25 +24,12 @@ def self.create(client, options = {})
       self.new(client, options).save
     end
 
-    # TODO need to build a class that is something like ActiveRecord::Relation
-    # TODO need to be able to handle associations when hydrating objects
-    #
-    def self.search(client, input_text, options = {})
-      result_hash = client.get("/api/view/search/#{self.to_s.split('::').last.downcase}s", :searchtext => input_text).body
-      objects_to_hydrate = result_hash['Response']["#{self.to_s.split('::').last}s"]["#{self.to_s.split('::').last}"]
-      self.process_objects(client, objects_to_hydrate)
-    rescue Faraday::Error::ClientError => e
-      if e.response[:body]
-        raise ZohoInvoice::Error::ClientError.from_response(e.response)
-      end
-    end
-
     def initialize(client, options = {})
       @client = client
 
       # Assign all of the single attribtues
       #
-      if !self.attributes.empty?
+      if !self.attributes.blank?
         (self.attributes & options.keys).each do |attribute|
           self.send("#{attribute}=", options[attribute])
         end
@@ -76,29 +63,29 @@ def attributes
     # TODO Determining the resource to use will need to change
     #
     def save
-
       klass_name = self.class.to_s.split('::').last
-
-      action = 'create'
-      action = 'update' if !send("#{klass_name.downcase}_id").nil?
-
-      result = client.post("/api/#{klass_name.downcase + 's'}/#{action}", :XMLString => self.to_xml)
-
-      if action == 'create' && !result.body.nil? && !result.body['Response'][klass_name].nil?
-        self.send("#{klass_name.downcase}_id=", result.body['Response'][klass_name]["#{klass_name}ID"])
+      invoice_id = send("#{klass_name.downcase}_id")
+      if(invoice_id.blank?)
+        result = client.post("/api/v3/#{klass_name.downcase + 's'}", :JSONString => self.to_json)
+      else
+        result = client.put("/api/v3/#{klass_name.downcase + 's'}/#{invoice_id}", :JSONString => self.to_json)
+      end
+      if invoice_id.blank? && !result.body.blank? && !result.body[klass_name].blank?
+        self.send("#{klass_name.downcase}_id=", result.body[klass_name.downcase]["#{klass_name.downcase}_id"])
       end
-
       self
     rescue Faraday::Error::ClientError => e
-      if e.response[:body]
+      if e.response && e.response[:body]
         raise ZohoInvoice::Error::ClientError.from_response(e.response)
       end
     end
 
-    # This needs to be a Nokogiri::XML::Builder
-    #
-    def to_xml(*args)
-      build_attributes.to_xml(*args)
+    def to_json(*args)
+      to_hash(*args).to_json
+    end
+
+    def to_hash(*args)
+      build_attributes(ZohoInvoice::Invoice::CREATE_UPDATE_ATTRIBUTES)["#{self.class.to_s.split('::').last}"]
     end
 
     def self.create_attributes(attrs)
@@ -124,65 +111,96 @@ def camel_case(str)
       self.class.camel_case(str)
     end
 
-    def build_attributes
-      Nokogiri::XML::Builder.new do |xml|
-        xml.send("#{self.class.to_s.split('::').last}") {
-          self.attributes.each do |attr|
-            vals = self.send(attr)
-            if !vals.nil? && !vals.is_a?(Array)
-              xml.send("#{camel_case(attr.to_s)}_", self.send(attr))
-            end
+    def build_attributes(attrs)
+      h = {}
+      attrs.each do |attr|
+        vals = self.send(attr)
+        if(vals.is_a?(Array) || vals.is_a?(Hash) || vals.is_a?(String))
+          h["#{attr.to_s}"] = stringify_object_values(vals) unless(vals.blank?)
+        else
+          h["#{attr.to_s}"] = stringify_object_values(vals) unless(vals.nil?)
+        end
+      end
+      self.reflections.each do |refl|
+        refl_val = self.send(refl)
+        if !refl_val.blank?
+          refl_a = []
+          refl_val.each {|r| refl_h << r}
+          h[refl] = refl_a
+        end
+      end
+      g = {}
+      g[self.class.to_s.split('::').last] = h
+      g
+    end
+
+    def stringify_object_values(obj)
+      return(obj.to_s.gsub(/[`~!@#$%^&*()+=\\|\[{\]}'";:\/?><]/, ' ').squeeze(' ').strip) unless(obj.is_a?(Array) || obj.is_a?(Hash))
+      res = nil
+      if(obj.is_a?(Array))
+        res = []
+        obj.each do |elt|
+          if(elt.is_a?(Array) || elt.is_a?(Hash) || elt.is_a?(String))
+            res << stringify_object_values(elt) unless(elt.blank?)
+          else
+            res << stringify_object_values(elt) unless(elt.nil?)
           end
-          self.reflections.each do |refl|
-            if !refl.empty?
-              xml.send(camel_case(refl.to_s)) {
-                self.send(refl).each { |x| xml << x.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_DECLARATION) }
-              }
-            end
+        end
+      elsif(obj.is_a?(Hash))
+        res = {}
+        obj.each do |key, elt|
+          if(elt.is_a?(Array) || elt.is_a?(Hash) || elt.is_a?(String))
+            res[key] = stringify_object_values(elt) unless(elt.blank?)
+          else
+            res[key] = stringify_object_values(elt) unless(elt.nil?)
           end
-        }
+        end
       end
+      res
     end
 
     private
 
-    def self.retrieve(client, url)
-      klass = self.to_s.split('::').last
+    def self.retrieve(client, url, plural = true)
+      klass_name = self.to_s.split('::').last.downcase
+      klass_name += 's' if(plural)
       page = 1
       query = {}
       objects_to_hydrate = []
 
       begin
         result_hash = client.get(url, query).body
-        potential_objects = result_hash['Response'][klass + 's']
+        potential_objects = result_hash
 
         if potential_objects
-          potential_objects = potential_objects[klass]
+          potential_objects = potential_objects[klass_name]
           if potential_objects.is_a? Hash
             potential_objects = [potential_objects]
           end
           objects_to_hydrate += potential_objects
         end
 
-        page_context = result_hash['Response']['PageContext']
+        page_context = result_hash['page_context']
         if page_context
-          num_pages = page_context['Total_Pages'].to_i
-          page += 1
-          query = { :page => page }
+          has_more_page = page_context['has_more_page']
+          if(has_more_page)
+            page += 1
+            query = { :page => page }
+          end
         else
-          num_pages = nil
+          has_more_page = false
         end
-      end while num_pages && page <= num_pages
+      end while has_more_page
 
       self.process_objects(client, objects_to_hydrate)
     rescue Faraday::Error::ClientError => e
-      if e.response[:body]
+      if e.response && e.response[:body]
         raise ZohoInvoice::Error::ClientError.from_response(e.response)
       end
     end
 
     def self.process_objects(client, objects_to_hydrate)
-      if objects_to_hydrate.nil?
+      if objects_to_hydrate.blank?
         return []
       else
         if objects_to_hydrate.is_a?(Hash) #Convert hash to array if only a single object is returned
@@ -191,7 +209,7 @@ def self.process_objects(client, objects_to_hydrate)
         objects_to_hydrate.map do |result|
           new_hash = {}
           result.each do |key, value|
-            new_hash[key.to_underscore.to_sym] = value if !value.is_a?(Hash) && !value.is_a?(Array)
+            new_hash[key.to_underscore.to_sym] = value
           end
           self.new(client, new_hash)
         end

lib/zoho_invoice/client.rb

@@ -28,6 +28,10 @@ def post(path, params={})
       request(:post, path, credentials.merge(params))
     end
 
+    def put(path, params={})
+      request(:put, path, credentials.merge(params))
+    end
+
     def request(verb, path, params={})
       connection.send(verb, path, params)
     end
@@ -37,15 +41,13 @@ def request(verb, path, params={})
     def connection
       @connection ||= Faraday.new(@client_options) do |c|
         c.use       Faraday::Response::RaiseError
-
         c.request :multipart
         c.request :url_encoded
-
-        c.response  :xml, :content_type => /\bxml$/
-
+        c.response  :json, :content_type => /\bjson$/
         c.adapter Faraday.default_adapter
       end
     end
 
   end
+
 end

lib/zoho_invoice/customer.rb

@@ -27,11 +27,11 @@ def self.all(client, options = {})
     end
 
     def self.all_active(client, options = {})
-      retrieve(client, '/api/customers').each { |c| c.active = true }
+      retrieve(client, '/api/v3/customers').each { |c| c.active = true }
     end
 
     def self.all_inactive(client, options = {})
-      retrieve(client, '/api/customers/inactive').each { |c| c.active = false }
+      retrieve(client, '/api/v3/customers/inactive').each { |c| c.active = false }
     end
 
   end

lib/zoho_invoice/error/client_error.rb

@@ -14,9 +14,9 @@ def self.parse_error(response)
         error = self.new
         if !response[:body].nil?
           response_body = response[:body]
-          error.response_status  = response_body['Response']['status']
-          error.code    = response_body['Response']['Code']
-          error.message = response_body['Response']['Message']
+          error.response_status  = response_body['status']
+          error.code    = response_body['code']
+          error.message = response_body['message']
         end
         error.http_status = response[:status]
         error

lib/zoho_invoice/invoice.rb

@@ -3,26 +3,72 @@
 module ZohoInvoice
   class Invoice < Base
 
-    define_object_attrs :invoice_id,
-      :created_time,          :exchange_rate,
-      :last_modified_time,    :l_f_name,
-      :last_sync_time,        :late_fee_amount,
-      :source,                :total,
-      :reference_id,          :invoice_item_total,
-      :invoice_number,        :tax_total,
-      :p_o_number,            :balance,
-      :status,                :notes,
-      :customer_id,           :terms,
+    READ_ATTRIBUTES = [
+      :invoice_id,
+      :created_time,
+      :exchange_rate,
+      :last_modified_time,
+      :l_f_name,
+      :last_sync_time,
+      :late_fee_amount,
+      :source,
+      :total,
+      :reference_id,
+      :invoice_item_total,
+      :invoice_number,
+      :tax_total,
+      :p_o_number,
+      :balance,
+      :status,
+      :notes,
+      :customer_id,
+      :terms,
       :customer_name,
+      :custom_fields,
       :invoice_date,
       :payments_due,
       :due_date,
-      :currency_code
+      :currency_code,
+      :additional_field1,
+      :adjustment,
+      :adjustment_description,
+      :allow_partial_payments,
+      :contact_persons,
+      :date,
+      :description,
+      :discount,
+      :discount_type,
+      :expense_id,
+      :gateway_name,
+      :invoiced_estimate_id,
+      :is_discount_before_tax,
+      :item_id,
+      :line_items,
+      :name,
+      :payment_gateways,
+      :payment_options,
+      :payment_terms,
+      :payment_terms_label,
+      :project_id,
+      :quantity,
+      :rate,
+      :recurring_invoice_id,
+      :salesperson_name,
+      :shipping_charge,
+      :tax_id,
+      :template_id,
+      :time_entry_ids,
+      :unit
+    ]
+
+    CREATE_UPDATE_ATTRIBUTES = READ_ATTRIBUTES - [:invoice_id]
+
+    define_object_attrs(*READ_ATTRIBUTES)
 
     has_many :invoice_items
 
     def self.find_by_customer_id(client, id, options = {})
-      retrieve(client, "/api/invoices/customer/#{id}")
+      retrieve(client, "/api/v3/invoices/customer/#{id}", false)
     end
 
     def self.find_by_multiple_customer_ids(client, ids, options={})
@@ -34,7 +80,7 @@ def self.find_by_multiple_customer_ids(client, ids, options={})
     end
 
     def self.find_unpaid_by_customer_id(client, id, options = {})
-      retrieve(client, "/api/invoices/unpaid/customer/#{id}")
+      retrieve(client, "/api/v3/invoices/unpaid/customer/#{id}", false)
     end
 
     def self.find_unpaid_by_multiple_customer_ids(client, ids, options={})
@@ -46,7 +92,11 @@ def self.find_unpaid_by_multiple_customer_ids(client, ids, options={})
     end
 
     def self.all(client)
-      retrieve(client, '/api/invoices')
+      retrieve(client, '/api/v3/invoices')
+    end
+
+    def self.find(client, id, options={})
+      retrieve(client, "/api/v3/invoices/#{id}", false)
     end
 
   end

spec/fixtures/successful_customers_response

@@ -1,5 +1,5 @@
 <Response>
-  <Customers uri='/api/customers'>
+  <Customers uri='/api/v3/customers'>
     <Customer>
       <CustomerID>1</CustomerID>
     </Customer>

spec/fixtures/successful_empty_response

@@ -1,3 +1,3 @@
 <Response>
-  <Somethings uri='/api/views/search/somethings'></Somethings>
+  <Somethings uri='/api/v3/views/search/somethings'></Somethings>
 </Response>

spec/fixtures/successful_multiple_customer_response

@@ -1,5 +1,5 @@
 <Response>
-  <Invoices uri='/api/invoices/customer/1234'>
+  <Invoices uri='/api/v3/invoices/customer/1234'>
     <Invoice>
       <InvoiceID>1</InvoiceID>
       <Status>Open</Status>

spec/fixtures/successful_multiple_page_response_page_1

@@ -1,5 +1,5 @@
 <Response>
-  <Invoices uri='/api/invoices/customer/1234'>
+  <Invoices uri='/api/v3/invoices/customer/1234'>
     <Invoice>
       <InvoiceID>1</InvoiceID>
       <Status>Open</Status>