salesforce_ar_sync 2.0.2 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 49700928b08b5846bf589c0f17a6b3e901cd95a2
-  data.tar.gz: 383abff58a8729112727c7b5f8ae91c912215002
+SHA256:
+  metadata.gz: 5a366e664f19f09c3ad3f31088f75d90e4d11ba5b2708d59a5a8e470ebc0276c
+  data.tar.gz: 2f37638a57e5769698051c8cbbdcaa49dce50de4eae90d12da6a59dabc5b0765
 SHA512:
-  metadata.gz: e0138c4ea8225d242f7263fda308178a103a0797fb8c0ac430feda439a189942190e5ec3a230d32f883bf0faea6f24c7937527d796bea801920f1c4e9aa1492b
-  data.tar.gz: be0fd33f8551419b04be48a7424afeb62ce43d6f43bf083e10a25487bc3ce52eb7581caa839bbf05902c68b9b9f3667406f484667633b29d394ab2d1e3d93e14
+  metadata.gz: 401722023c03c42c8dd070a8259dd0e5ddeec6306414ebd6d66d23de4055857a5fac177943d61bc8f81e2e5be508295c5cd22673e9a7be1adcd1e66adcdf1fad
+  data.tar.gz: 60529516c0d6350377dd7f9b229cd6642a6025dc9c72bf107331dd323232fa8526453b7c727a8dd57de754576f1687e1f72f7790643dcdeab43772148614659a

data/README.md

@@ -1,7 +1,57 @@
 # 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.
+
+### Contents
+
+- [Installation](#installation)
+  - [Requirements](#requirements)
+  - [Salesforce Setup](#salesforce-setup)
+    - [1. Setup Remote Access](#1-setup-remote-access)
+    - [2. Setup Outbound Messaging](#2-setup-outbound-messaging)
+  - [restforce](#restforce)
+  - [Gem Installation](#gem-installation)
+  - [Application Setup](#application-setup)
+- [Usage](#usage)
+  - [Configuration Options](#configuration-options)
+  - [Model Options](#model-options)
+    - [salesforce\_sync\_enabled](#salesforce_sync_enabled)
+    - [sync\_attributes](#sync_attributes)
+    - [async\_attributes](#async_attributes)
+    - [default\_attributes\_for\_create](#default_attributes_for_create)
+    - [salesforce\_id\_attribute\_name](#salesforce_id_attribute_name)
+    - [web\_id\_attribute\_name](#web_id_attribute_name)
+    - [activerecord\_web\_id\_attribute\_name](#activerecord_web_id_attribute_name)
+    - [salesforce\_sync\_web\_id](#salesforce_sync_web_id)
+    - [additional\_lookup\_fields](#additional_lookup_fields)
+    - [web\_class\_name](#web_class_name)
+    - [salesforce\_object\_name](#salesforce_object_name)
+    - [except](#except)
+    - [save\_method](#save_method)
+    - [unscoped\_updates](#unscoped_updates)
+    - [readonly\_fields](#readonly_fields)
+  - [Stopping the Sync](#stopping-the-sync)
+  - [Manual Sync](#manual-sync)
+- [Examples](#examples)
+  - [Our Basic Example Model](#our-basic-example-model)
+  - [Making the Model Syncable](#making-the-model-syncable)
+  - [Stopping the Model from Syncing with a Flag](#stopping-the-model-from-syncing-with-a-flag)
+  - [Stopping the Model from Syncing with a Method](#stopping-the-model-from-syncing-with-a-method)
+  - [Stopping a Record from Syncing](#stopping-a-record-from-syncing)
+  - [Specify Async Attributes](#specify-async-attributes)
+  - [Specify Default Attributes when an Object is Created](#specify-default-attributes-when-an-object-is-created)
+  - [Relationships](#relationships)
+  - [Defining a Custom Salesforce Object](#defining-a-custom-salesforce-object)
+- [Deletes](#deletes)
+  - [Inbound Deletes](#inbound-deletes)
+  - [Outbound Deletes](#outbound-deletes)
+  - [Soft Deletes](#soft-deletes)
+- [Errors](#errors)
+  - [Outbound Message Errors](#outbound-message-errors)
+- [Finding your 18 Character Organization ID](#finding-your-18-character-organization-id)
+- [Testing](#testing)
+- [Contributing](#contributing)
 
 ## Installation
 
@@ -10,8 +60,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 +87,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 +144,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
@@ -112,6 +162,7 @@ The options available to configure are
 * __sync_enabled__: a global sync enabled flag which is a boolean true/false
 * __namespace_prefix__: Namespace prefix of your Salesforce app in case you specified one
 * __deletion_map__: Salesforce object names mapped to internal app name.
+* __job_queue__: A symbol naming the ActiveJob queue you wish sync and delete jobs to use. (default is :default)
 
 To generate a YAML file
 
@@ -129,7 +180,7 @@ which will create a template salesforce_ar_sync.yml in /config that looks like t
     deletion_map:
 
 
-To use the ENV variable you must pass environemnt variables to rails via the _export_ command in bash or before the
+To use the ENV variable you must pass environment variables to rails via the _export_ command in bash or before the
 initializer loads the ENV settings.
 
     $ export SALESFORCE_AR_SYNC_ORGANIZATION_ID=123456789123456789
@@ -143,37 +194,12 @@ An example of adding an aliased object to the deletion map should look like the
       Account: 'YourModelName'
 
 ### Model Options
-The model can have several options set:
-
-[__salesforce_sync_enabled__](#salesforce_sync_enabled)
-
-[__sync_attributes__](#sync_attributes)
-
-[__async_attributes__](#async_attributes)
-
-[__default_attributes_for_create__](#default_attributes_for_create)
-
-[__salesforce_id_attribute_name__](#salesforce_id_attribute_name)
-
-[__web_id_attribute_name__](#web_id_attribute_name)
-
-[__activerecord_web_id_attribute_name__](#activerecord_web_id_attribute_name)
-
-[__salesforce_sync_web_id__](#salesforce_sync_web_id)
-
-[__web_class_name__](#web_class_name)
-
-[__salesforce_object_name__](#salesforce_object_name)
-
-[__except__](#except)
-
-[__unscoped_updates__](#unscoped_updates)
 
 #### <a id="salesforce_sync_enabled"></a>salesforce_sync_enabled
 Model level option to enable disable the sync, defaults to true.
 
 ````ruby
-:salesforce_sync_enabled => false
+salesforce_sync_enabled: false
 ````
 
 #### sync_attributes
@@ -183,7 +209,7 @@ 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
@@ -191,7 +217,7 @@ An array of Salesforce attributes which should be synced asynchronously, default
 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
@@ -201,51 +227,59 @@ 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
+Optionally can specify what fields can be used for finding the object that should be updated if object was not found by salesforce id or web id
+
+````ruby
+additional_lookup_fields: { login: :User_ID_Email__c }
 ````
 
+
 #### web_class_name
 The name of the Web Objects class. A custom value can be provided if you wish to sync to a SF object and back to a
 different web object. Defaults to the model name. This would generally be used if you wanted to flatten a web object
 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
@@ -253,7 +287,14 @@ Optionally holds the name of a method which can contain logic to determine if a
 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
 ````
 
 #### unscoped_updates
@@ -261,7 +302,16 @@ Enable bypassing the default scope when searching for records to update.  This i
 soft deletion strategy that can respect SF undeletion.
 
 ````ruby
-:unscoped_updates => true
+unscoped_updates: true
+````
+
+#### readonly_fields
+Optionally set fields on the salesforce object that have been defined as Read Only in Salesforce.
+This helps to ensure that those fields are not synced from the model to salesforce (but still syncable the other way).
+Accepts the salesforce field, not the model's fields.
+
+````ruby
+readonly_fields: %i[NumberOfPosts__c ActiveSeats__c]
 ````
 
 ### Stopping the Sync
@@ -273,6 +323,16 @@ configuration variable _SALESFORCE_AR_SYNC_CONFIG["SYNC_ENABLED"]_
 * The model level by setting the _:salesforce_sync_enabled => false_ or _:except => :method_name_
 * The instance level by setting _:salesforce_skip_sync => true_ in the instance
 
+### Manual Sync
+
+You can trigger a manual sync of any configured attributes. All checks to skip syncing or to sync asynchronously will still be executed.
+
+```ruby
+my_user_record.salesforce_sync(:email)
+
+my_user_record.salesforce_sync(:email, :phone)
+```
+
 ## Examples
 
 ### Our Basic Example Model
@@ -291,7 +351,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
 ```
 
@@ -302,8 +362,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
 ```
 
@@ -314,8 +374,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?
@@ -339,8 +399,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
 ```
 
@@ -351,8 +411,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
 ```
 
@@ -370,9 +430,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?
@@ -398,8 +458,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"
@@ -428,8 +488,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
@@ -440,8 +500,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?
@@ -471,6 +531,11 @@ If the SOAP handler encounters an error it will be recorded in the log of the ou
  it to an 18 character id by running it through the tool located here:
  http://cloudjedi.wordpress.com/no-fuss-salesforce-id-converter/ or by installing the Force.com Utility Belt for Chrome.
 
+## Testing
+This gem uses [Appraisal](https://github.com/thoughtbot/appraisal) to test against many versions of Rails.
+
+Run the test script to automatically set up and run the test suite: `./test`
+
 ## Contributing
 
 1. Fork it

data/app/controllers/salesforce_ar_sync/soap_message_controller.rb

@@ -1,8 +1,7 @@
 module SalesforceArSync
   class SoapMessageController < ::ApplicationController
-
     protect_from_forgery with: :null_session
-    before_filter :validate_ip_ranges
+    before_action :validate_ip_ranges
 
     def sync_object
       delayed_soap_handler SalesforceArSync::SoapHandler::Base
@@ -14,20 +13,18 @@ module SalesforceArSync
 
     private
 
-    def delayed_soap_handler (klass, priority = 90)
-      begin
-        soap_handler = klass.new(SalesforceArSync.config["ORGANIZATION_ID"], params)
-        soap_handler.process_notifications(priority) if soap_handler.sobjects
-        render :xml => soap_handler.generate_response, :status => :created
-      rescue Exception => ex
-        render :xml => soap_handler.generate_response(ex), :status => :created
-      end
+    def delayed_soap_handler(klass, priority = 90)
+      soap_handler = klass.new(SalesforceArSync.config['ORGANIZATION_ID'], params)
+      soap_handler.process_notifications(priority) if soap_handler.sobjects
+      render xml: soap_handler.generate_response, status: :created
+    rescue Exception => ex
+      render xml: soap_handler.generate_response(ex), status: :created
     end
 
-    # to be used in a before_filter, checks ip ranges specified in configuration
+    # to be used in a before_action, checks ip ranges specified in configuration
     # and renders a 404 unless the request matches
     def validate_ip_ranges
-      raise ActionController::RoutingError.new('Not Found') unless SalesforceArSync::IPConstraint.new.matches?(request)
+      raise ActionController::RoutingError, 'Not Found' unless SalesforceArSync::IPConstraint.new.matches?(request)
     end
   end
-end
+end

data/lib/salesforce_ar_sync/engine.rb

@@ -1,31 +1,40 @@
+# frozen_string_literal: true
+
 module SalesforceArSync
   class Engine < ::Rails::Engine
-    initializer "salesforce_ar_sync.load_app_instance_data" do |app|
+    initializer 'salesforce_ar_sync.load_app_instance_data' do |app|
       SalesforceArSync.setup do |config|
         config.app_root = app.root
 
-        #Load the configuration from the environment or a yaml file or disable it if no config present
-        SalesforceArSync.config = Hash.new
-        #load the config file if we have it
-        if FileTest.exist?("#{Rails.root}/config/salesforce_ar_sync.yml")
-          config = YAML.load_file("#{Rails.root}/config/salesforce_ar_sync.yml")[Rails.env]
-          SalesforceArSync.config["ORGANIZATION_ID"] = config['organization_id']
-          SalesforceArSync.config["SYNC_ENABLED"] = config['sync_enabled']
-          SalesforceArSync.config["IP_RANGES"] = config['ip_ranges'].split(',').map{ |ip| ip.strip }
-          SalesforceArSync.config["NAMESPACE_PREFIX"] = config['namespace_prefix']
-          SalesforceArSync.config['DELETION_MAP'] = config['deletion_map'].stringify_keys
+        # Load the configuration from the environment or a yaml file or disable it if no config present
+        SalesforceArSync.config = {}
+        # load the config file if we have it
+        config_file = "#{Rails.root}/config/salesforce_ar_sync.yml"
+        if FileTest.exist?(config_file)
+          begin
+            config = YAML.load_file(config_file, aliases: true)[Rails.env]
+          rescue ArgumentError
+            config = YAML.load_file(config_file)[Rails.env]
+          end
+          SalesforceArSync.config['ORGANIZATION_ID'] = config['organization_id']
+          SalesforceArSync.config['SYNC_ENABLED'] = config['sync_enabled']
+          SalesforceArSync.config['IP_RANGES'] = config['ip_ranges'].split(',').map{ |ip| ip.strip }
+          SalesforceArSync.config['NAMESPACE_PREFIX'] = config['namespace_prefix']
+          SalesforceArSync.config['DELETION_MAP'] = config['deletion_map'].stringify_keys if config['deletion_map']
+          SalesforceArSync.config['JOB_QUEUE'] = config['job_queue']&.to_sym || :default
         end
 
-        #if we have ENV flags prefer them
-        SalesforceArSync.config["ORGANIZATION_ID"] = ENV["SALESFORCE_AR_SYNC_ORGANIZATION_ID"] if ENV["SALESFORCE_AR_SYNC_ORGANIZATION_ID"]
-        SalesforceArSync.config["SYNC_ENABLED"] = ENV["SALESFORCE_AR_SYNC_SYNC_ENABLED"] if ENV.include? "SALESFORCE_AR_SYNC_SYNC_ENABLED"
-        SalesforceArSync.config["IP_RANGES"] = ENV["SALESFORCE_AR_SYNC_IP_RANGES"].split(',').map{ |ip| ip.strip } if ENV["SALESFORCE_AR_SYNC_IP_RANGES"]
-        SalesforceArSync.config["NAMESPACE_PREFIX"] = ENV["SALESFORCE_AR_NAMESPACE_PREFIX"] if ENV["SALESFORCE_AR_NAMESPACE_PREFIX"]
+        # if we have ENV flags prefer them
+        SalesforceArSync.config['ORGANIZATION_ID'] = ENV['SALESFORCE_AR_SYNC_ORGANIZATION_ID'] if ENV['SALESFORCE_AR_SYNC_ORGANIZATION_ID']
+        SalesforceArSync.config['SYNC_ENABLED'] = ENV['SALESFORCE_AR_SYNC_SYNC_ENABLED'] if ENV.include? 'SALESFORCE_AR_SYNC_SYNC_ENABLED'
+        SalesforceArSync.config['IP_RANGES'] = ENV['SALESFORCE_AR_SYNC_IP_RANGES'].split(',').map{ |ip| ip.strip } if ENV['SALESFORCE_AR_SYNC_IP_RANGES']
+        SalesforceArSync.config['NAMESPACE_PREFIX'] = ENV['SALESFORCE_AR_NAMESPACE_PREFIX'] if ENV['SALESFORCE_AR_NAMESPACE_PREFIX']
         SalesforceArSync.config['DELETION_MAP'] = ENV['DELETION_MAP'] if ENV['DELETION_MAP']
+        SalesforceArSync.config['JOB_QUEUE'] = ENV['SALESFORCE_AR_SYNC_JOB_QUEUE'] if ENV['SALESFORCE_AR_SYNC_JOB_QUEUE']
 
-        #do we have valid config options now?
-        if !SalesforceArSync.config["ORGANIZATION_ID"].present? || SalesforceArSync.config["ORGANIZATION_ID"].length != 18
-          SalesforceArSync.config["SYNC_ENABLED"] = false
+        # do we have valid config options now?
+        if !SalesforceArSync.config['ORGANIZATION_ID'].present? || SalesforceArSync.config['ORGANIZATION_ID'].length != 18
+          SalesforceArSync.config['SYNC_ENABLED'] = false
         end
       end
     end

data/lib/salesforce_ar_sync/extenders/salesforce_syncable.rb

@@ -21,6 +21,10 @@ module SalesforceArSync
 
         self.salesforce_object_name_method = options.has_key?(:salesforce_object_name) ? options[:salesforce_object_name] : nil
         self.salesforce_skip_sync_method = options.has_key?(:except) ? options[:except] : nil
+        self.salesforce_save_method = options.has_key?(:save_method) ? options[:save_method] : :save!
+        self.additional_lookup_fields = options.has_key?(:additional_lookup_fields) ? options[:additional_lookup_fields] : nil
+
+        self.readonly_fields = options.fetch(:readonly_fields, [])
 
         instance_eval do
           before_save :salesforce_sync

data/lib/salesforce_ar_sync/jobs/base_job.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SalesforceArSync
+  class BaseJob < (defined?(::ApplicationJob) ? ::ApplicationJob : ActiveJob::Base)
+    queue_as do
+      SalesforceArSync.config['JOB_QUEUE']
+    end
+
+    protected
+
+    def prepare_class(klass)
+      klass.is_a?(String) ? klass.camelize.constantize : klass
+    end
+  end
+end

data/lib/salesforce_ar_sync/jobs/delete_object_job.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SalesforceArSync
+  class DeleteObjectJob < BaseJob
+    def perform(klass, sobject)
+      prepare_class(klass).delete_object(sobject)
+    end
+  end
+end

data/lib/salesforce_ar_sync/jobs/salesforce_object_sync_job.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SalesforceArSync
+  # simple object to be serialized when asynchronously sending data to Salesforce
+  class SalesforceObjectSyncJob < BaseJob
+    def perform(web_object_name, salesforce_id, attributes)
+      web_object = web_object_name.to_s.constantize.find_by_salesforce_id salesforce_id
+      # object exists in salesforce if we call its system_mod_stamp
+      if web_object&.system_mod_stamp&.present?
+        web_object.salesforce_update_object(JSON.parse(attributes))
+        web_object.update_attribute(:salesforce_updated_at, web_object.system_mod_stamp)
+      end
+    end
+  end
+end

data/lib/salesforce_ar_sync/jobs/sync_object_job.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SalesforceArSync
+  class SyncObjectJob < BaseJob
+    def perform(klass, sobject)
+      prepare_class(klass).salesforce_update(sobject)
+    end
+  end
+end

data/lib/salesforce_ar_sync/salesforce_sync.rb

@@ -46,6 +46,9 @@ module SalesforceArSync
       attr_accessor :salesforce_sync_web_id
       attr_accessor :activerecord_web_id_attribute_name
 
+      # Optionally can specify what fields can be used for finding the object that should be updated
+      attr_accessor :additional_lookup_fields
+
       # Optionally holds the name of a method which will return the name of the Salesforce object to sync to
       attr_accessor :salesforce_object_name_method
 
@@ -53,19 +56,34 @@ module SalesforceArSync
       # If no method is given then only the salesforce_skip_sync attribute is used.
       attr_accessor :salesforce_skip_sync_method
 
+      # Optionally holds the name of a method which can provide custom logic for saving a record
+      # If no method is given then `ActiveRecord::Base#save!` is used
+      attr_accessor :salesforce_save_method
+
+      # Optionally holds a list of fields on the model that should not be synced to salesforce
+      # because they are classified as readonly and are calculated on the salesforce side
+      attr_accessor :readonly_fields
+
       # Accepts values from an outbound message hash and will either update an existing record OR create a new record
       # Firstly attempts to find an object by the salesforce_id attribute
       # Secondly attempts to look an object up by it's ID (WebId__c in outbound message)
       # Lastly it will create a new record setting it's salesforce_id
-      def salesforce_update(attributes={})
+      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]
 
+        if !object && additional_lookup_fields
+          additional_lookup_fields.each do |attribute_name, salesforce_attribute_name|
+            object = data_source.find_by(attribute_name => attributes[salesforce_attribute_name]) if attributes[salesforce_attribute_name]
+          end
+        end
+
         if object.nil?
           object = new
-          salesforce_default_attributes_for_create.merge(:salesforce_id => attributes[salesforce_id_attribute_name]).each_pair do |k, v|
+          salesforce_default_attributes_for_create.merge(salesforce_id: attributes[salesforce_id_attribute_name]).each_pair do |k, v|
             object.send("#{k}=", v)
           end
         end
@@ -82,7 +100,7 @@ module SalesforceArSync
     # We initialize all declared attributes as nil before mapping the values from the message
     def salesforce_empty_attributes
       {}.tap do |hash|
-        self.class.salesforce_sync_attribute_mapping.each do |key, value|
+        self.class.salesforce_sync_attribute_mapping.each do |key, _value|
           hash[key] = nil
         end
       end
@@ -95,7 +113,7 @@ module SalesforceArSync
         # create a reversed hash of value's and key's to pass to update_attributes
         attributes.each do |key, value|
           # make sure our sync_mapping contains the salesforce attribute AND that our object has a setter for it
-          hash[self.class.salesforce_sync_attribute_mapping[key.to_s].to_sym] = value if self.class.salesforce_sync_attribute_mapping.include?(key.to_s) && self.respond_to?("#{self.class.salesforce_sync_attribute_mapping[key.to_s]}=")
+          hash[self.class.salesforce_sync_attribute_mapping[key.to_s].to_sym] = value if self.class.salesforce_sync_attribute_mapping.include?(key.to_s) && respond_to?("#{self.class.salesforce_sync_attribute_mapping[key.to_s]}=")
         end
 
         # remove the web_id from hash if it exists, as we don't want to modify a web_id
@@ -111,29 +129,22 @@ module SalesforceArSync
 
     # Gets passed the Salesforce outbound message hash of changed values and updates the corresponding model
     def salesforce_process_update(attributes = {})
-      attributes_to_update = salesforce_attributes_to_set(self.new_record? ? attributes : salesforce_empty_attributes.merge(attributes)) # only merge empty attributes for updates, so we don't overwrite the default create attributes
+      attributes_to_update = salesforce_attributes_to_set(new_record? ? attributes : salesforce_empty_attributes.merge(attributes)) # only merge empty attributes for updates, so we don't overwrite the default create attributes
       attributes_to_update.each_pair do |k, v|
-        self.send("#{k}=", v)
+        send("#{k}=", v)
       end
 
       # we don't want to keep going in a endless loop.  SF has just updated these values.
       self.salesforce_skip_sync = true
-      self.save!
+      self.send(self.class.salesforce_save_method)
     end
 
-#    def salesforce_object_exists?
-#      return salesforce_object_exists_method if respond_to? salesforce_exists_method
-#      return salesforce_object_exists_default
-#    end
-
-
     # 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?
       return @exists_in_salesforce if @exists_in_salesforce
       @exists_in_salesforce = !system_mod_stamp.nil?
@@ -141,90 +152,95 @@ module SalesforceArSync
 
     # Checks if the passed in attribute should be updated in Salesforce.com
     def salesforce_should_update_attribute?(attribute)
-      !self.respond_to?("#{attribute}_changed?") || (self.respond_to?("#{attribute}_changed?") && self.send("#{attribute}_changed?"))
+      !respond_to?("#{attribute}_changed?") || (respond_to?("#{attribute}_changed?") && send("#{attribute}_changed?"))
     end
 
     # create a hash of updates to send to salesforce
-    def salesforce_attributes_to_update(include_all = false)
+    def salesforce_attributes_to_update(include_all = false, attrs = [])
       {}.tap do |hash|
         self.class.salesforce_sync_attribute_mapping.each do |key, value|
-          if self.respond_to?(value)
+          next if (attrs.any? && attrs.exclude?(value.to_sym)) || !respond_to?(value)
 
-            #Checkboxes in SFDC Cannot be nil.  Here we check for boolean field type and set nil values to be false
-            attribute_value = self.send(value)
-            if is_boolean?(value) && attribute_value.nil?
-              attribute_value = false
-            end
+          # Checkboxes in SFDC Cannot be nil.  Here we check for boolean field type and set nil values to be false
+          attribute_value = send(value)
+          attribute_value = false if is_boolean?(value) && attribute_value.nil?
 
-            hash[key] = attribute_value if include_all || salesforce_should_update_attribute?(value)
-          end
+          hash[key] = attribute_value if !self.class.readonly_fields&.include?(key.to_sym) && (include_all || salesforce_should_update_attribute?(value))
         end
       end
     end
 
     def is_boolean?(attribute)
-      self.column_for_attribute(attribute) && self.column_for_attribute(attribute).type == :boolean
+      column_for_attribute(attribute) && column_for_attribute(attribute).type == :boolean
     end
 
     def salesforce_create_object(attributes)
-      attributes.merge!(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"]
+      attributes[self.class.salesforce_web_id_attribute_name.to_s] = id if self.class.salesforce_sync_web_id? && !new_record?
+      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.merge!(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)
+      attributes[self.class.salesforce_web_id_attribute_name.to_s] = id if self.class.salesforce_sync_web_id? && !new_record?
+
+      SF_CLIENT.update(salesforce_object_name, format_attributes(attributes).merge(Id: salesforce_id))
     end
 
     def salesforce_delete_object
-      if self.ar_sync_outbound_delete?
-        SF_CLIENT.http_delete("/services/data/v#{SF_CLIENT.version}/sobjects/#{salesforce_object_name}/#{salesforce_id}")
+      if ar_sync_outbound_delete?
+        SF_CLIENT.destroy(salesforce_object_name, salesforce_id)
       end
     end
 
     # Check to see if the user passed in a true/false, if so return that, if not then they passed int a symbol to a method
     # We then call the method and use its value instead
     def ar_sync_inbound_delete?
-      [true,false].include?(self.class.sync_inbound_delete) ? self.class.sync_inbound_delete : send(self.class.sync_inbound_delete)
+      [true, false].include?(self.class.sync_inbound_delete) ? self.class.sync_inbound_delete : send(self.class.sync_inbound_delete)
     end
 
     def ar_sync_outbound_delete?
-      [true,false].include?(self.class.sync_outbound_delete) ? self.class.sync_outbound_delete : send(self.class.sync_outbound_delete)
+      [true, false].include?(self.class.sync_outbound_delete) ? self.class.sync_outbound_delete : send(self.class.sync_outbound_delete)
     end
 
     # if attributes specified in the async_attributes array are the only attributes being modified, then sync the data
     # via delayed_job
-    def salesforce_perform_async_call?
-      return false if salesforce_attributes_to_update.empty? || self.class.salesforce_async_attributes.empty?
-      salesforce_attributes_to_update.keys.all? {|key| self.class.salesforce_async_attributes.include?(key) } && salesforce_id.present?
+    def salesforce_perform_async_call?(attributes_to_update)
+      return false if attributes_to_update.empty? || self.class.salesforce_async_attributes.empty?
+      attributes_to_update.keys.all? { |key| self.class.salesforce_async_attributes.include?(key) } && salesforce_id.present?
     end
 
     # sync model data to Salesforce, adding any Salesforce validation errors to the models errors
-    def salesforce_sync
-      return if self.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)
+    def salesforce_sync(*attrs)
+      return if salesforce_skip_sync?
+
+      attributes_to_update = salesforce_attributes_to_update(attrs.any?, attrs)
+
+      if salesforce_perform_async_call?(attributes_to_update)
+        SalesforceArSync::SalesforceObjectSyncJob.set(priority: 50).perform_later(
+          self.class.salesforce_web_class_name, salesforce_id,
+          attributes_to_update.to_json
+        )
       else
         if salesforce_object_exists?
-          salesforce_update_object(salesforce_attributes_to_update) if salesforce_attributes_to_update.present?
+          salesforce_update_object(attributes_to_update) if attributes_to_update.present?
         else
-          salesforce_create_object(salesforce_attributes_to_update(!new_record?)) if salesforce_id.nil?
+          salesforce_create_object(attributes_to_update(!new_record?)) if salesforce_id.nil?
         end
       end
     rescue Exception => ex
-      self.errors[:base] << ex.message
-      return false
+      errors.add(:base, ex.message)
+      false
     end
 
     def sync_web_id
-      return false if !self.class.salesforce_sync_web_id? || self.salesforce_skip_sync?
-      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
+      return false if !self.class.salesforce_sync_web_id? || SalesforceArSync.config['SYNC_ENABLED'] == false
+
+      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
-      self.send(self.class.activerecord_web_id_attribute_name)
+      send(self.class.activerecord_web_id_attribute_name)
     end
 
     private
@@ -233,10 +249,14 @@ module SalesforceArSync
     # This method converts all attribute that are arrays into these values
     # Eg. ["A","B","C"]  =>  "A;B;C"
     def format_attributes(attributes)
-      attributes.each do |k,v|
-        attributes[k] = v.join(";") if v.is_a?(Array)
+      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
-      return attributes
+      attributes
     end
   end
 end

data/lib/salesforce_ar_sync/soap_handler/base.rb

@@ -3,47 +3,50 @@ module SalesforceArSync
     class Base
       attr_reader :xml_hashed, :options, :sobjects
 
-      def initialize organization, options = {}
-        @options = options
-        @xml_hashed = options
-        @organization = SalesforceArSync.config["ORGANIZATION_ID"]
+      def initialize(_organization, options = {})
+        @options = options.to_unsafe_h
+        @xml_hashed = options.to_unsafe_h
+        @organization = SalesforceArSync.config['ORGANIZATION_ID']
         @sobjects = collect_sobjects if valid?
       end
 
       # queues each individual record from the message for update
       def process_notifications(priority = 90)
         batch_process do |sobject|
-          options[:klass].camelize.constantize.delay(:priority => priority, :run_at => 5.seconds.from_now).salesforce_update(sobject)
+          SalesforceArSync::SyncObjectJob.set(
+            priority: priority,
+            wait_until: 5.seconds.from_now
+          ).perform_later(options[:klass], sobject)
         end
       end
 
       # ensures that the received message is properly formed, and that it comes from the expected Salesforce Org
       def valid?
-        notifications = @xml_hashed.try(:[], "Envelope").try(:[], "Body").try(:[], "notifications")
+        notifications = @xml_hashed.try(:[], 'Envelope').try(:[], 'Body').try(:[], 'notifications')
 
-        organization_id = notifications.try(:[], "OrganizationId")
-        return !notifications.try(:[], "Notification").nil? && organization_id == @organization # we sent this to ourselves
+        organization_id = notifications.try(:[], 'OrganizationId')
+        !notifications.try(:[], 'Notification').nil? && organization_id == @organization # we sent this to ourselves
       end
 
-      def batch_process(&block)
+      def batch_process
         return if sobjects.nil? || !block_given?
-        sobjects.each do | sobject |
+        sobjects.each do |sobject|
           yield sobject
         end
       end
 
-      #xml for SFDC response
-      #called from soap_message_controller
+      # xml for SFDC response
+      # called from soap_message_controller
       def generate_response(error = nil)
         response = "<Ack>#{sobjects.nil? ? false : true}</Ack>" unless error
         if error
           response = "<soapenv:Fault><faultcode>soap:Receiver</faultcode><faultstring>#{error.message}</faultstring></soapenv:Fault>"
         end
-        return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"><soapenv:Body><notificationsResponse>#{response}</notificationsResponse></soapenv:Body></soapenv:Envelope>"
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?><soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"><soapenv:Body><notificationsResponse>#{response}</notificationsResponse></soapenv:Body></soapenv:Envelope>"
       end
 
       def self.namespaced(field)
-         SalesforceArSync.config["NAMESPACE_PREFIX"].present? ? :"#{SalesforceArSync.config["NAMESPACE_PREFIX"]}__#{field}" : :"#{field}"
+        SalesforceArSync.config['NAMESPACE_PREFIX'].present? ? :"#{SalesforceArSync.config['NAMESPACE_PREFIX']}__#{field}" : :"#{field}"
       end
 
       # Get configuration for the in app deletions.
@@ -55,11 +58,11 @@ module SalesforceArSync
       private
 
       def collect_sobjects
-        notification = @xml_hashed["Envelope"]["Body"]["notifications"]["Notification"]
+        notification = @xml_hashed['Envelope']['Body']['notifications']['Notification']
         if notification.is_a? Array
-          return notification.collect{ |h| h["sObject"].symbolize_keys}
+          return notification.collect { |h| h['sObject'].symbolize_keys }
         else
-          return [notification["sObject"].try(:symbolize_keys)]
+          return [notification['sObject'].try(:symbolize_keys)]
         end
       end
     end

data/lib/salesforce_ar_sync/soap_handler/delete.rb

@@ -3,7 +3,10 @@ module SalesforceArSync
     class Delete < SalesforceArSync::SoapHandler::Base
       def process_notifications(priority = 90)
         batch_process do |sobject|
-          SalesforceArSync::SoapHandler::Delete.delay(priority: priority, run_at: 5.seconds.from_now).delete_object(sobject)
+          SalesforceArSync::DeleteObjectJob.set(
+            priority: priority,
+            wait_until: 5.seconds.from_now
+          ).perform_later(SalesforceArSync::SoapHandler::Delete, sobject)
         end
       end
 

data/lib/salesforce_ar_sync/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SalesforceArSync
-  VERSION = "2.0.2"
+  VERSION = '5.2.0'
 end

data/lib/salesforce_ar_sync.rb

@@ -1,11 +1,13 @@
 require 'salesforce_ar_sync/engine'
 require 'salesforce_ar_sync/version'
 require 'salesforce_ar_sync/extenders/salesforce_syncable'
-require 'salesforce_ar_sync/salesforce_object_sync'
 require 'salesforce_ar_sync/soap_handler/base'
 require 'salesforce_ar_sync/soap_handler/delete'
 require 'salesforce_ar_sync/ip_constraint'
-require 'salesforce_ar_sync/railtie'
+require 'salesforce_ar_sync/jobs/base_job'
+require 'salesforce_ar_sync/jobs/salesforce_object_sync_job'
+require 'salesforce_ar_sync/jobs/delete_object_job'
+require 'salesforce_ar_sync/jobs/sync_object_job'
 
 module SalesforceArSync
   mattr_accessor :app_root
@@ -18,4 +20,4 @@ end
 
 if defined?(ActiveRecord::Base)
   ActiveRecord::Base.extend SalesforceArSync::Extenders::SalesforceSyncable
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: salesforce_ar_sync
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 5.2.0
 platform: ruby
 authors:
 - Michael Halliday
@@ -9,55 +9,69 @@ authors:
 - Andrew Coates
 - Devon Noonan
 - Liam Nediger
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-08-18 00:00:00.000000000 Z
+date: 2025-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: actionpack-xml_parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: actionpack-xml_parser
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rexml
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: ammeter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.1.2
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -71,7 +85,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -85,7 +99,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: vcr
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -99,21 +113,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ammeter
+  name: vcr
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.2
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -127,19 +141,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: databasedotcom
+  name: restforce
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 5.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 5.0.5
 description: ActiveRecord extension & rails engine for syncing data with Salesforce.com
 email:
 - mhalliday@infotech.com
@@ -163,8 +177,10 @@ files:
 - lib/salesforce_ar_sync/engine.rb
 - lib/salesforce_ar_sync/extenders/salesforce_syncable.rb
 - lib/salesforce_ar_sync/ip_constraint.rb
-- lib/salesforce_ar_sync/railtie.rb
-- lib/salesforce_ar_sync/salesforce_object_sync.rb
+- lib/salesforce_ar_sync/jobs/base_job.rb
+- lib/salesforce_ar_sync/jobs/delete_object_job.rb
+- lib/salesforce_ar_sync/jobs/salesforce_object_sync_job.rb
+- lib/salesforce_ar_sync/jobs/sync_object_job.rb
 - lib/salesforce_ar_sync/salesforce_sync.rb
 - lib/salesforce_ar_sync/soap_handler/base.rb
 - lib/salesforce_ar_sync/soap_handler/delete.rb
@@ -172,7 +188,7 @@ files:
 homepage: http://github.com/InfoTech/
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -187,9 +203,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.6
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: ActiveRecord extension & rails engine for syncing data with Salesforce.com
 test_files: []

data/lib/salesforce_ar_sync/railtie.rb

@@ -1,7 +0,0 @@
-module SalesforceArSync
-  class Railtie < Rails::Railtie
-    initializer 'salesforce_ar_sync.insert_middleware' do |app|
-      app.config.middleware.insert_after ActionDispatch::ParamsParser, ActionDispatch::XmlParamsParser
-    end
-  end
-end

data/lib/salesforce_ar_sync/salesforce_object_sync.rb

@@ -1,13 +0,0 @@
-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        
-      web_object = "#{web_object_name}".constantize.find_by_salesforce_id salesforce_id
-      #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(web_object.salesforce_attributes_to_update(true))
-        web_object.update_attribute(:salesforce_updated_at, system_mod_stamp)
-      end
-    end
-  end
-end