module Synced::Model
Public Instance Methods
Reset last sync timestamp for given scope, this forces synced to sync all the records on the next sync. Useful for cases when you add a new column to be synced and you use updated since strategy for faster synchronization.
# File lib/synced/model.rb, line 152 def reset_synced(scope: scope_from_relation) options = { scope: scope, strategy: synced_strategy, only_updated: synced_only_updated, initial_sync_since: synced_initial_sync_since, timestamp_strategy: synced_timestamp_strategy, synced_endpoint: synced_endpoint } Synced::Synchronizer.new(self, options).reset_synced end
Enables synced for ActiveRecord model.
@param options [Hash] Configuration options for synced. They are inherited
by subclasses, but can be overwritten in the subclass.
@option options [Symbol] strategy: synchronization strategy, one of :full, :updated_since, :check.
Defaults to :updated_since
@option options [Symbol] id_key: attribute name under which
remote object's ID is stored, default is :synced_id.
@option options [Boolean] only_updated: If true requests to API will take
advantage of updated_since param and fetch only created/changed/deleted remote objects
@option options [Symbol] data_key: attribute name under which remote
object's data is stored.
@option options [Array|Hash] local_attributes: Array of attributes in the remote
object which will be mapped to local object attributes.
@option options [Boolean|Symbol] remove: If it's true all local objects
within current scope which are not present in the remote array will be destroyed. If only_updated is enabled, ids of objects to be deleted will be taken from the meta part. By default if cancel_at column is present, all missing local objects will be canceled with cancel_all, if it's missing, all will be destroyed with destroy_all. You can also force method to remove local objects by passing it to remove: :mark_as_missing.
@option options [Array|Hash] globalized_attributes: A list of attributes
which will be mapped with their translations.
@option options [Time|Proc] initial_sync_since: A point in time from which
objects will be synchronized on first synchronization. Works only for partial (updated_since param) synchronizations.
@option options [Array|Hash] delegate_attributes: Given attributes will be defined
on synchronized object and delegated to synced_data Hash
@option options [Hash] query_params: Given attributes and their values
which will be passed to api client to perform search
@option options [Boolean] auto_paginate: If true (default) will fetch and save all
records at once. If false will fetch and save records in batches.
@option options transaction_per_page [Boolean]: If false (default) all fetched records
will be persisted within single transaction. If true the transaction will be per page of fetched records
@option options [Proc] handle_processed_objects_proc: Proc taking one argument (persisted remote objects).
Called after persisting remote objects (once in case of auto_paginate, after each batch when paginating with block).
@option options [Integer] tolerance: amount of seconds subtracted from last_request timestamp.
Used to ensure records are up to date in case request has been made in the middle of transaction. Defaults to 0.
# File lib/synced/model.rb, line 49 def synced(strategy: :updated_since, **options) options.assert_valid_keys(:associations, :data_key, :fields, :globalized_attributes, :id_key, :include, :initial_sync_since, :local_attributes, :mapper, :only_updated, :remove, :auto_paginate, :transaction_per_page, :delegate_attributes, :query_params, :timestamp_strategy, :handle_processed_objects_proc, :tolerance, :endpoint) class_attribute :synced_id_key, :synced_data_key, :synced_local_attributes, :synced_associations, :synced_only_updated, :synced_mapper, :synced_remove, :synced_include, :synced_fields, :synced_auto_paginate, :synced_transaction_per_page, :synced_globalized_attributes, :synced_initial_sync_since, :synced_delegate_attributes, :synced_query_params, :synced_timestamp_strategy, :synced_strategy, :synced_handle_processed_objects_proc, :synced_tolerance, :synced_endpoint self.synced_strategy = strategy self.synced_id_key = options.fetch(:id_key, :synced_id) self.synced_data_key = options.fetch(:data_key) { synced_column_presence(:synced_data) } self.synced_local_attributes = options.fetch(:local_attributes, []) self.synced_associations = options.fetch(:associations, []) self.synced_only_updated = options.fetch(:only_updated, synced_strategy == :updated_since) self.synced_mapper = options.fetch(:mapper, nil) self.synced_remove = options.fetch(:remove, false) self.synced_include = options.fetch(:include, []) self.synced_fields = options.fetch(:fields, []) self.synced_globalized_attributes = options.fetch(:globalized_attributes, []) self.synced_initial_sync_since = options.fetch(:initial_sync_since, nil) self.synced_delegate_attributes = options.fetch(:delegate_attributes, []) self.synced_query_params = options.fetch(:query_params, {}) self.synced_timestamp_strategy = options.fetch(:timestamp_strategy, nil) self.synced_auto_paginate = options.fetch(:auto_paginate, true) self.synced_transaction_per_page = options.fetch(:transaction_per_page, false) self.synced_handle_processed_objects_proc = options.fetch(:handle_processed_objects_proc, nil) self.synced_tolerance = options.fetch(:tolerance, 0).to_i.abs self.synced_endpoint = options.fetch(:endpoint) { self.to_s.tableize } include Synced::DelegateAttributes include Synced::HasSyncedData end
Performs synchronization of given remote objects to local database.
@param remote [Array] - Remote objects to be synchronized with local db. If
it's nil then synchronizer will make request on it's own.
@param model_class [Class] - ActiveRecord model class to which remote objects
will be synchronized.
@param scope [ActiveRecord::Base] - Within this object scope local objects
will be synchronized. By default it's model_class. Can be infered from active record association scope.
@param remove [Boolean] - If it's true all local objects within
current scope which are not present in the remote array will be destroyed. If only_updated is enabled, ids of objects to be deleted will be taken from the meta part. By default if cancel_at column is present, all missing local objects will be canceled with cancel_all, if it's missing, all will be destroyed with destroy_all. You can also force method to remove local objects by passing it to remove: :mark_as_missing. This option can be defined in the model and then overwritten in the synchronize method.
@param auto_paginate [Boolean] - If true (default) will fetch and save all
records at once. If false will fetch and save records in batches.
@param transaction_per_page [Boolean] - If false (default) all fetched records
will be persisted within single transaction. If true the transaction will be per page of fetched records
@param api [BookingSync::API::Client] - API client to be used for fetching
remote objects
@example Synchronizing amenities
Amenity.synchronize(remote: [remote_amenity1, remote_amenity2])
@example Synchronizing rentals within given website. This will
create/remove/update rentals only within website. It requires relation website.rentals to exist. website.rentals.synchronize(remote: remote_rentals)
# File lib/synced/model.rb, line 120 def synchronize(scope: scope_from_relation, strategy: synced_strategy, **options) options.assert_valid_keys(:api, :fields, :include, :remote, :remove, :query_params, :association_sync, :auto_paginate, :transaction_per_page) options[:remove] = synced_remove unless options.has_key?(:remove) options[:include] = Array.wrap(synced_include) unless options.has_key?(:include) options[:fields] = Array.wrap(synced_fields) unless options.has_key?(:fields) options[:query_params] = synced_query_params unless options.has_key?(:query_params) options[:auto_paginate] = synced_auto_paginate unless options.has_key?(:auto_paginate) options[:transaction_per_page] = synced_transaction_per_page unless options.has_key?(:transaction_per_page) options.merge!({ scope: scope, strategy: strategy, id_key: synced_id_key, synced_data_key: synced_data_key, data_key: synced_data_key, local_attributes: synced_local_attributes, associations: synced_associations, only_updated: synced_only_updated, mapper: synced_mapper, globalized_attributes: synced_globalized_attributes, initial_sync_since: synced_initial_sync_since, timestamp_strategy: synced_timestamp_strategy, handle_processed_objects_proc: synced_handle_processed_objects_proc, tolerance: synced_tolerance, synced_endpoint: synced_endpoint }) Synced::Synchronizer.new(self, options).perform end
Private Instance Methods
attempt to get scope from association reflection, so you could do: account.bookings.synchronize and the scope would be account
# File lib/synced/model.rb, line 169 def scope_from_relation all.proxy_association.owner if all.respond_to?(:proxy_association) end
# File lib/synced/model.rb, line 173 def synced_column_presence(name) name if column_names.include?(name.to_s) end