Databasedotcom to Restforce (#32)

* Databasedotcom changed over to the Restorce gem. Haven't been able to fully test yet BUT that'll be better checked when the website is updated

* Removed byebug

* PR comments

* remove delayed_job enqueue call (#33)

* remove delayed_job enqueue call

* .to_json attributes to allow activesupport to be able to serialize any datatype

* Some PR changes and updates to the readme file

Co-authored-by: James Haig <jhaig@infotech.com>

Author: adam-bilyea

CHANGELOG.md

@@ -20,4 +20,6 @@
 # Version 3.2.0
 * Adds support for Rails 5
 * Added ability to specify readonly fields for salesforce syncable models so those fields don't try to sync back to Salesforce
-* WebID syncing fixed
+* WebID syncing fixed
+# Version 4.0.0
+* Changed Databasedotcom over to Restforce

README.md

@@ -1,7 +1,7 @@
 # SalesforceArSync
 
 SalesforceARSync allows you to sync models and fields with Salesforce through a combination of
-Outbound Messaging, SOAP and databasedotcom.
+Outbound Messaging, SOAP and restforce.
 
 ## Installation
 
@@ -10,8 +10,7 @@ Outbound Messaging, SOAP and databasedotcom.
 * Rails ~> 4.0
 * Salesforce.com instance
 * [Have your 18 character organization id ready](#finding-your-18-character-organization-id)
-* databasedotcom gem >= 1.3 installed and configured [see below](#databasedotcom)
-* delayed_job gem >= 3.0 installed and configured
+* restforce gem >= 5.0.4 installed and configured [see below](#restforce)
 
 ### Salesforce Setup
 
@@ -38,14 +37,15 @@ Select the fields you wish to sync (Id and SystemModstamp are required).
 
 *You need to do this for each object/model you want to sync.
 
-### databasedotcom
+### restforce
 
-Before using the salesforce_ar_sync gem you must ensure you have the databasedotcom gem installed and configured
+Before using the salesforce_ar_sync gem you must ensure you have the restforce gem installed and configured
 properly. Make sure each of the models you wish to sync are materialized.
 
 ````ruby
-$sf_client = Databasedotcom::Client.new("config/databasedotcom.yml")
-$sf_client.authenticate :username => <username>, :password => <password>
+# Note: You can name the config to anything you want
+$sf_client = Restforce::Client.new("config/salesforce.yml")
+$sf_client.authenticate username: <username>, password: <password>
 
 module SalesforceArSync::SalesforceSync
   SF_CLIENT = $sf_client
@@ -94,7 +94,7 @@ Next you will need to tell the gem which models are syncable by adding _salesfor
 and specifying which attributes you would like to sync.
 
 ````ruby
-salesforce_syncable :sync_attributes => {:FirstName => :first_name, :LastName => :last_name}
+salesforce_syncable :sync_attributes => {FirstName: :first_name, LastName: :last_name}
 ````
 
 The first parameter in the _:sync_attributes_ hash is the Salesforce field name and the second is the model attribute
@@ -177,7 +177,7 @@ The model can have several options set:
 Model level option to enable disable the sync, defaults to true.
 
 ````ruby
-:salesforce_sync_enabled => false
+salesforce_sync_enabled: false
 ````
 
 #### sync_attributes
@@ -187,15 +187,15 @@ value, you should also implement a corresponding my_method_changed? to return if
 it will always be synced.
 
 ````ruby
-:sync_attributes => { :Email => :login, :FirstName => :first_name, :LastName => :last_name }
+sync_attributes: { Email: :login, FirstName: :first_name, LastName: :last_name }
 ````
 
 #### async_attributes
 An array of Salesforce attributes which should be synced asynchronously, defaults to an empty array. When an object is saved and only attributes contained in this array, the save to Salesforce will be queued and processed asyncronously.
 Use this carefully, nothing is done to ensure data integrity, if multiple jobs are queued for a single object there is no way to guarentee that they are processed in order, or that the save to Salesforce will succeed.
 
 ````ruby
-:async_attributes => ["Last_Login__c", "Login_Count__c"]
+async_attributes: ['Last_Login__c', 'Login_Count__c']
 ````
 
 Note:  The model will fall back to synchronous sync if non-synchronous attributes are changed along with async
@@ -205,35 +205,35 @@ attributes
 A hash of default attributes that should be used when we are creating a new record, defaults to empty hash.
 
 ````ruby
-:default_attributes_for_create => {:password_change_required => true}
+default_attributes_for_create: { password_change_required: true }
 ````
 
 #### salesforce_id_attribute_name
 The "Id" attribute of the corresponding Salesforce object, defaults to _Id_.
 
 ````ruby
-:salesforce_id_attribute_name => :Id
+salesforce_id_attribute_name: :Id
 ````
 
 #### web_id_attribute_name
 The field name of the web id attribute in the Salesforce Object, defaults to _WebId__c_
 
 ````ruby
-:web_id_attribute_name  => :WebId__c
+web_id_attribute_name: :WebId__c
 ````
 
 #### activerecord_web_id_attribute_name
 The field name of the web id attribute in the Active Record Object, defaults to id
 
 ````ruby
-:activerecord_web_id_attribute_name  => :id
+activerecord_web_id_attribute_name: :id
 ````
 
 #### salesforce_sync_web_id
 Enable or disable sync of the web id, defaults to false. Use this if you have a need for the id field of the ActiveRecord model to by synced to Salesforce.
 
 ````ruby
-:salesforce_sync_web_id => false
+salesforce_sync_web_id: false
 ````
 
 #### additional_lookup_fields
@@ -250,37 +250,37 @@ different web object. Defaults to the model name. This would generally be used i
 into a larger SF object like Contact.
 
 ````ruby
-:web_class_name => 'Contact',
+web_class_name: 'Contact',
 ````
 
 #### salesforce_object_name
 Optionally holds the name of a method which will return the name of the Salesforce object to sync to, defaults to nil.
 
 ````ruby
-:salesforce_object_name => :salesforce_object_name_method_name
+salesforce_object_name: :salesforce_object_name_method_name
 ````
 
 #### except
 Optionally holds the name of a method which can contain logic to determine if a record should be synced on save. If no
 method is given then only the salesforce_skip_sync attribute is used. Defaults to nil.
 
 ````ruby
-:except => :except_method_name
+except: :except_method_name
 ````
 
 #### save_method
 Optionally holds the name of a method which contains custom logic for saving on sync. Defaults to `ActiveRecord::Base#save!`
 
 ````ruby
-:save_method => :save_method_name
+save_method: :save_method_name
 ````
 
 #### unscoped_updates
 Enable bypassing the default scope when searching for records to update.  This is useful when using a
 soft deletion strategy that can respect SF undeletion.
 
 ````ruby
-:unscoped_updates => true
+unscoped_updates: true
 ````
 
 #### readonly_fields
@@ -319,7 +319,7 @@ class Contact < ActiveRecord::Base
   attributes :first_name, :last_name, :phone, :email, :last_login_time, :salesforce_id, :salesforce_updated_at
   attr_accessor :first_name, :last_name, :phone, :email
 
-  salesforce_syncable :sync_attributes => {:FirstName => :first_name, :LastName => :last_name, :Phone => :phone, :Email => :email}
+  salesforce_syncable sync_attributes: { FirstName: :first_name, LastName: :last_name, Phone: :phone, Email: :email }
 end
 ```
 
@@ -330,8 +330,8 @@ class Contact < ActiveRecord::Base
   attributes :first_name, :last_name, :phone, :email, :last_login_time, :salesforce_id, :salesforce_updated_at
   attr_accessor :first_name, :last_name, :phone, :email
 
-  salesforce_syncable :sync_attributes => {:FirstName => :first_name, :LastName => :last_name, :Phone => :phone, :Email => :email},
-                      :salesforce_sync_enabled => false
+  salesforce_syncable sync_attributes: {FirstName: :first_name, LastName: :last_name, Phone: :phone, Email: :email},
+                      salesforce_sync_enabled: false
 end
 ```
 
@@ -342,8 +342,8 @@ class Contact < ActiveRecord::Base
   attributes :first_name, :last_name, :phone, :email, :last_login_time, :salesforce_id, :salesforce_updated_at
   attr_accessor :first_name, :last_name, :phone, :email
 
-  salesforce_syncable :sync_attributes => {:FirstName => :first_name, :LastName => :last_name, :Phone => :phone, :Email => :email},
-                      :except => :skip_sync?
+  salesforce_syncable sync_attributes: {FirstName: :first_name, LastName: :last_name, Phone: :phone, Email: :email},
+                      except: :skip_sync?
 
   def skip_sync?
     if first_name.blank?
@@ -367,8 +367,8 @@ class Contact < ActiveRecord::Base
   attributes :first_name, :last_name, :phone, :email, :last_login_time, :salesforce_id, :salesforce_updated_at
   attr_accessor :first_name, :last_name, :phone, :email, :last_login_time
 
-  salesforce_syncable :sync_attributes => {:FirstName => :first_name, :LastName => :last_name, :Phone => :phone, :Email => :email, :Last_Login_Time__c => :last_login_time},
-                      :async_attributes => ["Last_Login_Time__c"]
+  salesforce_syncable sync_attributes: { FirstName: :first_name, LastName: :last_name, Phone: :phone, Email: :email, Last_Login_Time__c: :last_login_time },
+                      async_attributes: ['Last_Login_Time__c']
 end
 ```
 
@@ -379,8 +379,8 @@ class Contact < ActiveRecord::Base
   attributes :first_name, :last_name, :phone, :email, :last_login_time, :salesforce_id, :salesforce_updated_at
   attr_accessor :first_name, :last_name, :phone, :email, :last_login_time
 
-  salesforce_syncable :sync_attributes => {:FirstName => :first_name, :LastName => :last_name, :Phone => :phone, :Email => :email},
-                      :default_attributes_for_create => {:password_change_required => true}
+  salesforce_syncable sync_attributes: { FirstName: :first_name, LastName: :last_name, Phone: :phone, Email: :email },
+                      default_attributes_for_create: { password_change_required: true }
 end
 ```
 
@@ -398,9 +398,9 @@ using the 18 digit Salesforce id, but maintain our ActiveRecord relationships.
 		attributes :first_name, :last_name, :account_id
 		attr_accessor :first_name, :last_name, :account_id
 
-		salesforce_syncable :sync_attributes => { :FirstName => :first_name,
-																							:LastName => :last_name,
-																							:AccountId => :salesforce_account_id }
+		salesforce_syncable sync_attributes: { FirstName: :first_name,
+																							LastName: :last_name,
+																							AccountId: :salesforce_account_id }
 
 		def salesforce_account_id_changed?
 		  account_id_changed?
@@ -426,8 +426,8 @@ class Contact < ActiveRecord::Base
   attributes :first_name, :last_name, :phone, :email, :last_login_time, :salesforce_id, :salesforce_updated_at
   attr_accessor :first_name, :last_name, :phone, :email, :last_login_time
 
-  salesforce_syncable :sync_attributes => {:FirstName => :first_name, :LastName => :last_name, :Phone => :phone, :Email => :email},
-                      :salesforce_object_name => :custom_salesforce_object_name
+  salesforce_syncable sync_attributes: { FirstName: :first_name, LastName: :last_name, Phone: :phone, Email: :email },
+                      salesforce_object_name: :custom_salesforce_object_name
 
   def custom_salesforce_object_name
     "CustomContact__c"
@@ -456,8 +456,8 @@ Syncing inbound deletes is enabled by default, but can be configured in the Rail
 This is done using the :sync_inbound_delete option, which can take either a boolean value, or the name of a method that returns a boolean value.
 
 ```ruby
-  salesforce_syncable :sync_inbound_delete => :inbound_delete
-                     #:sync_inbound_delete => true
+  salesforce_syncable sync_inbound_delete: :inbound_delete
+                     #sync_inbound_delete: true
   def inbound_delete
     return self.comments.count == 0
   end
@@ -468,8 +468,8 @@ Syncing outbound deletes to Salesforce is disabled by default, but can be config
 This is done using the :sync_outbound_delete option, which can take either a boolean value, or the name of a method that returns a boolean value.
 
 ```ruby
-  salesforce_syncable :sync_outbound_delete => :outbound_delete
-                     #:sync_outbound_delete => false
+  salesforce_syncable sync_outbound_delete: :outbound_delete
+                     #sync_outbound_delete: false
 
   def outbound_delete
     return self.is_trial_user?

lib/salesforce_ar_sync/salesforce_object_sync.rb

@@ -1,11 +1,11 @@
 module SalesforceArSync
   # simple object to be serialized when asynchronously sending data to Salesforce
-  class SalesforceObjectSync < Struct.new(:web_object_name, :salesforce_id, :attributes)
-    def perform
+  class SalesforceObjectSync < ActiveJob::Base
+    def perform(web_object_name, salesforce_id, attributes)
       web_object = "#{web_object_name}".constantize.find_by_salesforce_id salesforce_id
-      #object exists in salesforce if we call its system_mod_stamp
+      # object exists in salesforce if we call its system_mod_stamp
       if (system_mod_stamp = web_object.system_mod_stamp)
-        web_object.salesforce_update_object(attributes)
+        web_object.salesforce_update_object(JSON.parse(attributes))
         web_object.update_attribute(:salesforce_updated_at, system_mod_stamp)
       end
     end

lib/salesforce_ar_sync/salesforce_sync.rb

@@ -70,6 +70,7 @@ module ClassMethods
       # Lastly it will create a new record setting it's salesforce_id
       def salesforce_update(attributes = {})
         raise ArgumentError, "#{salesforce_id_attribute_name} parameter required" if attributes[salesforce_id_attribute_name].blank?
+
         data_source = unscoped_updates ? unscoped : self
         object = data_source.find_by(salesforce_id: attributes[salesforce_id_attribute_name])
         object ||= data_source.find_by(activerecord_web_id_attribute_name => attributes[salesforce_web_id_attribute_name]) if salesforce_sync_web_id? && attributes[salesforce_web_id_attribute_name]
@@ -145,8 +146,8 @@ def salesforce_process_update(attributes = {})
 
     # Finds a salesforce record by its Id and returns nil or its SystemModstamp
     def system_mod_stamp
-      hash = JSON.parse(SF_CLIENT.http_get("/services/data/v#{SF_CLIENT.version}/query", q: "SELECT SystemModstamp FROM #{salesforce_object_name} WHERE Id = '#{salesforce_id}'").body)
-      hash['records'].first.try(:[], 'SystemModstamp')
+      sobject = SF_CLIENT.find(salesforce_object_name, salesforce_id)
+      sobject.SystemModstamp
     end
 
     def salesforce_object_exists?
@@ -180,19 +181,20 @@ def is_boolean?(attribute)
 
     def salesforce_create_object(attributes)
       attributes[self.class.salesforce_web_id_attribute_name.to_s] = id if self.class.salesforce_sync_web_id? && !new_record?
-      result = SF_CLIENT.http_post("/services/data/v#{SF_CLIENT.version}/sobjects/#{salesforce_object_name}", format_attributes(attributes).to_json)
-      self.salesforce_id = JSON.parse(result.body)['id']
+      salesforce_id = SF_CLIENT.create(salesforce_object_name, format_attributes(attributes))
+      self.salesforce_id = salesforce_id
       @exists_in_salesforce = true
     end
 
     def salesforce_update_object(attributes)
       attributes[self.class.salesforce_web_id_attribute_name.to_s] = id if self.class.salesforce_sync_web_id? && !new_record?
-      SF_CLIENT.http_patch("/services/data/v#{SF_CLIENT.version}/sobjects/#{salesforce_object_name}/#{salesforce_id}", format_attributes(attributes).to_json)
+
+      SF_CLIENT.update(salesforce_object_name, format_attributes(attributes).merge(Id: salesforce_id))
     end
 
     def salesforce_delete_object
       if ar_sync_outbound_delete?
-        SF_CLIENT.http_delete("/services/data/v#{SF_CLIENT.version}/sobjects/#{salesforce_object_name}/#{salesforce_id}")
+        SF_CLIENT.destroy(salesforce_object_name, salesforce_id)
       end
     end
 
@@ -217,7 +219,7 @@ def salesforce_perform_async_call?
     def salesforce_sync
       return if salesforce_skip_sync?
       if salesforce_perform_async_call?
-        Delayed::Job.enqueue(SalesforceArSync::SalesforceObjectSync.new(self.class.salesforce_web_class_name, salesforce_id, salesforce_attributes_to_update), priority: 50)
+        SalesforceArSync::SalesforceObjectSync.set(priority: 50).perform_later(self.class.salesforce_web_class_name, salesforce_id, salesforce_attributes_to_update.to_json)
       else
         if salesforce_object_exists?
           salesforce_update_object(salesforce_attributes_to_update) if salesforce_attributes_to_update.present?
@@ -227,12 +229,13 @@ def salesforce_sync
       end
     rescue Exception => ex
       errors[:base] << ex.message
-      return false
+      false
     end
 
     def sync_web_id
       return false if !self.class.salesforce_sync_web_id? || SalesforceArSync.config['SYNC_ENABLED'] == false
-      SF_CLIENT.http_patch("/services/data/v#{SF_CLIENT.version}/sobjects/#{salesforce_object_name}/#{salesforce_id}", { self.class.salesforce_web_id_attribute_name.to_s => get_activerecord_web_id }.to_json) if salesforce_id
+
+      SF_CLIENT.update(salesforce_object_name, Id: salesforce_id, self.class.salesforce_web_id_attribute_name.to_s => get_activerecord_web_id) if salesforce_id
     end
 
     def get_activerecord_web_id
@@ -247,6 +250,10 @@ def get_activerecord_web_id
     def format_attributes(attributes)
       attributes.each do |k, v|
         attributes[k] = v.join(';') if v.is_a?(Array)
+
+        # Databasedotcom apparently did some other stuff to make sure this happened in the background
+        # restforce does not so need to make sure this is called on anything that can call it
+        attributes[k] = v.iso8601 if defined?(v.iso8601)
       end
       attributes
     end

lib/salesforce_ar_sync/version.rb

@@ -1,3 +1,3 @@
 module SalesforceArSync
-  VERSION = '3.2.0'
+  VERSION = '4.0.0'
 end

salesforce_ar_sync.gemspec

@@ -24,5 +24,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'vcr'
   gem.add_development_dependency 'webmock'
 
-  gem.add_runtime_dependency 'databasedotcom'
+  gem.add_runtime_dependency 'restforce', '~> 5.0.5'
 end

spec/spec_helper.rb

@@ -2,7 +2,7 @@
 require 'rails/all'
 require 'salesforce_ar_sync'
 require 'active_record'
-require 'databasedotcom'
+require 'restforce'
 require 'rspec'
 require 'ammeter/init'
 require 'vcr'