stbaldricks 12.15.0 → 15.0.0.alpha.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 813c14606b5395cdc40253fd5452842c29113080c185196c579a21a1c1563b5c
-  data.tar.gz: 8d233977b90f351e8d339f09a7d77fcc000c19295030c6a62094b3db361aa6de
+  metadata.gz: e227814971bc43f036f273b77e3287157d6e28f38ad04641060cef2f005a24fd
+  data.tar.gz: 2d95e0f726ee850a3c1930f171740ad4d942ea5b863bf04df90d3fc5bc0b6f51
 SHA512:
-  metadata.gz: f42d618564cdecc8c6776c4feb06ccb7a8741c63a5d1c1abe0785957c2adc3327697bbd4957c1ae3ef7bda7a13c01ec4e1e4e97c32cc8776d605b90295287f33
-  data.tar.gz: 4ff2946335a23785d19023e76d14c3627961a5cb71543f3b034acb57f9a4f964e145a0d32d5f924e0c8604f6ee348e538cab02f5e5a9334b469d13ed9ff89946
+  metadata.gz: 117ea899c8c479324afc7dc668d808aef7393d341ae291f7aa10b62018fa28ff7d26f90785aba783b263ff450d08bde9e7844b9e7fe03bf51b21c6fde4d7d386
+  data.tar.gz: e4295e00834daa21bab6505827340ae889813a08c4f79f8e5202f9b09a60b6d74f5684b9fc2fef5031f72e19b7a135bc46dea857a43fd79b16a071003d3cebce

data/README.md

@@ -1,4 +1,10 @@
-# St. Baldrick's Ruby SDK
+
+# Table of Contents
+* [Publish Ruby Client Gem](publish-ruby-client.md)
+* [Architecture](architecture.md)
+* [SDK](#st-baldricks-ruby-sdk)
+
+## St. Baldrick's Ruby SDK
 
 ### Installation
 `gem install stbaldricks`
@@ -150,40 +156,3 @@ filter = {and: [{column: 'status_id', operator: 'equals', value: SBF::Client::Se
 active_participant_within_10_mi = request_helper { SBF::Client::Search.find(model_type, nil, filter, geo_location, limit: 2) }[:results]
 puts JSON.pretty_generate(active_participant_within_10_mi)
 ```
-
-## Architecture
-| Component          | Location
-|--------------------|------------------------------|
-| Endpoints          | `/lib/stbaldricks/endpoints` |
-| Entities           | `/lib/stbaldricks/entities`  |
-| Enums              | `/lib/stbaldricks/enums`     |
-| Rspec Unit         | `/spec/unit`                 |
-| Rspec Integration  | `/spec/integration`          |
-
-### Endpoints
-* Define supported requests that can be made to the SBF API for entities in the client library.
-* Extend `SBF::Client::EntityEndpoint` to receive common core action for the entities.
-  * If additional or non-standard functionality is required, actions can be added or overridden.
-* Return a response object which will contain an http status code and depending on the code either error details
-or the expected API response data for a successful request.
-
-### Entities
-* Object representations of the data sent to and received from the API.
-* Top-level entities (those that can be directly requested or modified via the API) inherit from `SBF::Client::TopLevelEntity`.
-  * Supported actions on the entity are defined via `action` and `actions`.
-  * Any actions that are disallowed are blocked via `blacklist_action`.
-  * The entities also map to their corresponding endpoint for handling all related API requests.
-* Sub-entities should still extend the `SBF::Client::BaseEntity`.
-
-### Enums
-* Collections of constants to assist with specifying values within a finite list.
-
-### Rspec Tests
-Tests are broken out into unit and integration tests. Test coverage thresholds are enforced and test additions or modifications are
-required for nearly any client library change.
-
-More detail on understanding and writing Rspec tests can be found in the [Rspec Guide](https://github.com/firespring/sbf/tree/master/documentation/guides/training/rspec).
-
-#### Running Tests
-* use `rake client:ruby:test:all` to run all tests
-  * use `TESTS={path-to-test} rake client:ruby:test:all` to run specific test(s)

data/lib/stbaldricks/configuration.rb

@@ -16,11 +16,11 @@ module SBF
       end
 
       def self.base_uri
-        @base_uri ||= ENV['API_ENDPOINT'] || DEFAULT_API_ENDPOINT
+        @base_uri ||= ENV.fetch('API_ENDPOINT', DEFAULT_API_ENDPOINT)
       end
 
       def self.general_token
-        @general_token ||= ENV['API_KEY'] || raise(SBF::Client::Configuration::Error.new('general_token', 'must be set'))
+        @general_token ||= ENV.fetch('API_KEY', nil) || raise(SBF::Client::Configuration::Error.new('general_token', 'must be set'))
       end
 
       def self.request_id

data/lib/stbaldricks/default_logger.rb

@@ -3,7 +3,7 @@ require 'logger'
 module SBF
   module Client
     module DefaultLogger
-      def self.instance(default_stream = STDOUT)
+      def self.instance(default_stream = $stdout)
         formatter = proc { |severity, datetime, _, msg|
           # ruby logger docs suggested this method for escaping messages since messages may contain user input
           # and are not escaped by default.
@@ -16,7 +16,7 @@ module SBF
 
         logger.formatter = formatter
         logger.level = ::Logger::DEBUG
-        logger.level = ENV['SBF_CLIENT_LOG_LEVEL'] || ::Logger::DEBUG
+        logger.level = ENV.fetch('SBF_CLIENT_LOG_LEVEL', ::Logger::DEBUG)
         logger
       end
     end

data/lib/stbaldricks/endpoints/blog_post.rb

@@ -27,17 +27,17 @@ module SBF
         end
       end
 
-      def find_by_term(term, order = {}, limit = 10, offset = 0, show_hidden = true)
+      def find_by_term(term, order = {}, limit = 10, offset = 0, show_hidden: true)
         # Build the parameter list for search; an empty find is supported
         filter = {}
         filter[:type] = FILTER_BY_TERM
         filter[:term] = term unless term.empty?
         filter[:show_hidden] = show_hidden
 
-        find(filter, order, limit, offset)
+        find(filter:, order:, limit:, offset:)
       end
 
-      def find_by_author(author, order = {}, limit = 10, offset = 0, show_hidden = true)
+      def find_by_author(author, order = {}, limit = 10, offset = 0, show_hidden: true)
         raise SBF::Client::Error, 'Must provide author for the query' if author.empty?
 
         filter = {}
@@ -45,10 +45,10 @@ module SBF
         filter[:term] = author
         filter[:show_hidden] = show_hidden
 
-        find(filter, order, limit, offset)
+        find(filter:, order:, limit:, offset:)
       end
 
-      def find_by_category(category, order = {}, limit = 10, offset = 0, show_hidden = true)
+      def find_by_category(category, order = {}, limit = 10, offset = 0, show_hidden: true)
         raise SBF::Client::Error, 'Must provide category for the query' if category.empty?
 
         filter = {}
@@ -56,10 +56,10 @@ module SBF
         filter[:term] = category
         filter[:show_hidden] = show_hidden
 
-        find(filter, order, limit, offset)
+        find(filter:, order:, limit:, offset:)
       end
 
-      def find_by_tag(tag, order = {}, limit = 10, offset = 0, show_hidden = true)
+      def find_by_tag(tag, order = {}, limit = 10, offset = 0, show_hidden: true)
         raise SBF::Client::Error, 'Must provide tag for the query' if tag.empty?
 
         filter = {}
@@ -67,7 +67,7 @@ module SBF
         filter[:term] = tag
         filter[:show_hidden] = show_hidden
 
-        find(filter, order, limit, offset)
+        find(filter:, order:, limit:, offset:)
       end
     end
   end

data/lib/stbaldricks/endpoints/communicate.rb

@@ -11,14 +11,14 @@ module SBF
       end
 
       def years(category)
-        response = SBF::Client::Api::Request.post_request("#{base_uri}/years", category: category)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/years", category:)
         parsed_response_body = JSON.parse(response.body).symbolize!
 
         handle_parsed_response(parsed_response_body, response)
       end
 
       def groups(category, year)
-        response = SBF::Client::Api::Request.post_request("#{base_uri}/groups", category: category, year: year)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/groups", category:, year:)
         parsed_response_body = JSON.parse(response.body).symbolize!
 
         handle_parsed_response(parsed_response_body, response)
@@ -42,13 +42,13 @@ module SBF
       def contacts(category, year, group_type, group_id)
         response = SBF::Client::Api::Request.post_request(
           "#{base_uri}/contacts",
-          category: category,
-          year: year,
-          group_type: group_type,
-          group_id: group_id
+          category:,
+          year:,
+          group_type:,
+          group_id:
         )
         parsed_response_body = JSON.parse(response.body).symbolize!
-        parsed_response_body.map! { |c| SBF::Client::Contact.new(c) } if ok?(response)
+        parsed_response_body.map! { |c| SBF::Client::Contact.new(c, clear_changes: false) } if ok?(response)
 
         handle_parsed_response(parsed_response_body, response)
       end

data/lib/stbaldricks/endpoints/config.rb

@@ -11,7 +11,7 @@ module SBF
         raise SBF::Client::StandardError, 'Unable to retrieve settings from the api' unless ok?(response)
 
         # re-call initalize with the new api data. This should re-set all of the instance variables on the instance
-        entity.send(:initialize, parsed_response_body)
+        entity.send(:initialize, parsed_response_body, clear_changes: false)
       end
     end
   end

data/lib/stbaldricks/endpoints/deduplicator_match.rb

@@ -3,19 +3,19 @@ require 'stbaldricks/endpoints/lib/entity'
 module SBF
   module Client
     class DeduplicatorMatchEndpoint < SBF::Client::EntityEndpoint
-      def checkout(filter = [], order = {}, limit = 20, offset = 0, with = {})
+      def checkout(filter: [], order: {}, limit: 20, offset: 0, with: {})
         filter = filter.to_json unless filter.is_a? String
         order = order.to_json unless order.is_a? String
         with = normalize_with(with)
 
         response = SBF::Client::Api::Request.post_request(
           "#{base_uri}/checkout",
-          filter: filter, order: order, limit: limit, offset: offset, with: with
+          filter:, order:, limit:, offset:, with:
         )
         parsed_response_body = JSON.parse(response.body).symbolize!
 
         if ok?(response)
-          parsed_response_body[:results].map! { |entity_data| target_class.new(entity_data, true) }
+          parsed_response_body[:results].map! { |entity_data| target_class.new(entity_data, clear_changes: true) }
           SBF::Client::EntityCollection.new(parsed_response_body[:results], parsed_response_body[:total_count])
         else
           parsed_response_body = JSON.parse(response.body).symbolize!
@@ -45,7 +45,7 @@ module SBF
 
       def release_checkout(checkout_id)
         response = SBF::Client::Api::Request.post_request(
-          "#{base_uri}/release_checkout", checkout_id: checkout_id
+          "#{base_uri}/release_checkout", checkout_id:
         )
         parsed_response_body = JSON.parse(response.body).symbolize!
 

data/lib/stbaldricks/endpoints/event.rb

@@ -24,7 +24,7 @@ module SBF
       end
 
       def invite(id, year, participant_data)
-        event_data = {id: id, year: year}
+        event_data = {id:, year:}
         participant_data.store(:event, event_data)
 
         response = SBF::Client::Api::Request.post_request("#{base_uri}/invite", participant_data)

data/lib/stbaldricks/endpoints/facebook/user.rb

@@ -15,8 +15,8 @@ module SBF
         def login!(authorization_code, redirect_uri)
           response = SBF::Client::Api::Request.post_request(
             "/#{SBF::Client::Api::VERSION}/security/facebook/login",
-            authorization_code: authorization_code,
-            redirect_uri: redirect_uri
+            authorization_code:,
+            redirect_uri:
           )
           parsed_response = JSON.parse(response.body).symbolize!
 

data/lib/stbaldricks/endpoints/fund.rb

@@ -11,7 +11,7 @@ module SBF
           data = parsed_response_body
           model_type = SBF::Client::ModelType.list[params[:dest_model_type]].capitalize
           entity_class = "SBF::Client::Full#{model_type}".to_class
-          data[:results].map! { |entity| entity_class.new(entity) }
+          data[:results].map! { |entity| entity_class.new(entity, clear_changes: false) }
         else
           error = SBF::Client::ErrorEntity.new(parsed_response_body)
           data = nil

data/lib/stbaldricks/endpoints/fundraiser.rb

@@ -7,7 +7,7 @@ module SBF
         response = SBF::Client::Api::Request.post_request("#{base_uri}/move_to_different_team", id: fundraiser_id, new_team_id: new_team_id)
 
         if ok?(response)
-          data = SBF::Client::FullFundraiser.new(JSON.parse(response.body).symbolize!)
+          data = SBF::Client::FullFundraiser.new(JSON.parse(response.body).symbolize!, clear_changes: false)
         else
           error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!)
         end

data/lib/stbaldricks/endpoints/kid.rb

@@ -8,11 +8,11 @@ module SBF
         filter = filter.to_json unless filter.is_a? String
         with = normalize_with(with)
 
-        response = SBF::Client::Api::Request.get_request("#{base_uri}/find_random", filter: filter, limit: limit, with: with)
+        response = SBF::Client::Api::Request.get_request("#{base_uri}/find_random", filter:, limit:, with:)
         parsed_response_body = JSON.parse(response.body).symbolize!
 
         if ok?(response)
-          parsed_response_body[:results].map! { |entity_data| target_class.new(entity_data) }
+          parsed_response_body[:results].map! { |entity_data| target_class.new(entity_data, clear_changes: false) }
           SBF::Client::EntityCollection.new(parsed_response_body[:results], parsed_response_body[:total_count])
         else
           parsed_response_body = JSON.parse(response.body).symbolize!

data/lib/stbaldricks/endpoints/lib/entity.rb

@@ -10,8 +10,7 @@ require 'json'
 module SBF
   module Client
     class EntityEndpoint
-      attr_reader :orig_target_class
-      attr_reader :base_uri
+      attr_reader :orig_target_class, :base_uri
 
       def initialize(target_class)
         @orig_target_class = target_class
@@ -34,7 +33,7 @@ module SBF
       # @param with [Hash] The optional entity fields to include in the response
       # @return entity [SBF::Client::BaseEntity]
       def create(entity_or_hash, with = {})
-        entity = entity_or_hash.is_a?(Hash) ? target_class.new(entity_or_hash) : entity_or_hash
+        entity = entity_or_hash.is_a?(Hash) ? target_class.new(entity_or_hash, clear_changes: false) : entity_or_hash
         raise SBF::Client::Error, 'Invalid Entity' unless entity.is_a?(SBF::Client::BaseEntity)
 
         with = normalize_with(with, entity)
@@ -50,10 +49,11 @@ module SBF
       # @param with [Hash] The optional entity fields to include in the response
       # @return entity [SBF::Client::BaseEntity]
       def update(id = nil, entity_or_hash = nil, with = {})
-        if entity_or_hash.is_a?(SBF::Client::BaseEntity)
+        case entity_or_hash
+        when SBF::Client::BaseEntity
           # If someone has passed in an entity, just convert it to a hash
           data = entity_or_hash.dirty_data
-        elsif entity_or_hash.is_a?(Hash)
+        when Hash
           # If someone has passed in a hash, make sure all of it's values match fields in the entity class
           data = sanitize(entity_or_hash)
         else
@@ -75,7 +75,7 @@ module SBF
       def get(id, with = {})
         with = normalize_with(with)
 
-        response = SBF::Client::Api::Request.get_request("#{base_uri}/get/#{id}", with: with)
+        response = SBF::Client::Api::Request.get_request("#{base_uri}/get/#{id}", with:)
 
         if ok?(response)
           hydrated_entity(response, {}, nil)
@@ -89,16 +89,18 @@ module SBF
       end
 
       # Calls the find route for the entity.
-      def find(filter = [], order = {}, limit = 20, offset = 0, with = {})
+      def find(filter: [], order: {}, limit: 20, offset: 0, with: {})
         filter = filter.to_json unless filter.is_a? String
         order = order.to_json unless order.is_a? String
         with = normalize_with(with)
 
-        response = SBF::Client::Api::Request.get_request("#{base_uri}/find", filter: filter, order: order, limit: limit, offset: offset, with: with)
+        response = SBF::Client::Api::Request.get_request("#{base_uri}/find", filter:, order:, limit:, offset:, with:)
         parsed_response_body = JSON.parse(response.body).symbolize!
 
         if ok?(response)
-          parsed_response_body[:results].map! { |entity_data| target_class.new(entity_data, true) }
+          parsed_response_body[:results].map! do |entity_data|
+            target_class.new(entity_data, clear_changes: true)
+          end
           SBF::Client::EntityCollection.new(parsed_response_body[:results], parsed_response_body[:total_count])
         else
           parsed_response_body = JSON.parse(response.body).symbolize!
@@ -113,7 +115,7 @@ module SBF
 
       # Calls the find route for the entity.
       def find_first(filter = [], order = {}, with = {})
-        response = find(filter, order, 1, 0, with)
+        response = find(filter: filter, order: order, limit: 1, with: with)
         if response.is_a?(SBF::Client::EntityCollection)
           response.empty? ? nil : response.first
         else
@@ -126,7 +128,7 @@ module SBF
         filter = filter.to_json unless filter.is_a? String
         aggregate = aggregate.to_json unless aggregate.is_a? String
 
-        response = SBF::Client::Api::Request.get_request("#{base_uri}/aggregate", filter: filter, aggregate: aggregate)
+        response = SBF::Client::Api::Request.get_request("#{base_uri}/aggregate", filter:, aggregate:)
         parsed_response_body = JSON.parse(response.body).symbolize!
         if ok?(response)
           data = parsed_response_body[:aggregate]
@@ -148,7 +150,7 @@ module SBF
 
       def target_class
         class_name_pieces = @orig_target_class.to_s.split('::')
-        full_name = (class_name_pieces[0..-2] + ['Full' + class_name_pieces.last]).join('::')
+        full_name = (class_name_pieces[0..-2] + ["Full#{class_name_pieces.last}"]).join('::')
         Object.const_defined?(full_name) ? Object.const_get(full_name) : @orig_target_class
       end
       private :target_class
@@ -247,7 +249,7 @@ module SBF
             entity_or_hash.send(:initialize_attributes, new_data)
             entity = entity_or_hash
           else
-            entity = target_class.new(new_data)
+            entity = target_class.new(new_data, clear_changes: false)
           end
 
           # Reload entity and its sub-entities so that no fields have a 'changed' state
@@ -256,7 +258,7 @@ module SBF
           entity
         else
           error = SBF::Client::ApiErrorEntity.new(parsed_response_body.merge(http_code: response.code))
-          entity = entity_or_hash.is_a?(SBF::Client::BaseEntity) ? entity_or_hash : target_class.new(entity_or_hash)
+          entity = entity_or_hash.is_a?(SBF::Client::BaseEntity) ? entity_or_hash : target_class.new(entity_or_hash, clear_changes: false)
           entity.add_errors(error)
           entity.errors_http_code = response.code
 

data/lib/stbaldricks/endpoints/message.rb

@@ -28,12 +28,12 @@ module SBF
       def send_contact_us_message(name, sender_email, phone, subject, body, sender_profile_id)
         response = SBF::Client::Api::Request.post_request(
           "#{base_uri}/send_contact_us_message",
-          name: name,
-          sender_email: sender_email,
-          phone: phone,
-          subject: subject,
-          body: body,
-          sender_profile_id: sender_profile_id
+          name:,
+          sender_email:,
+          phone:,
+          subject:,
+          body:,
+          sender_profile_id:
         )
 
         error = SBF::Client::ErrorEntity.new(response) unless ok?(response)
@@ -47,12 +47,12 @@ module SBF
       def send_contact_us_response_message(name, sender_email, phone, subject, body, sender_profile_id)
         response = SBF::Client::Api::Request.post_request(
           "#{base_uri}/send_contact_us_response_message",
-          name: name,
-          sender_email: sender_email,
-          phone: phone,
-          subject: subject,
-          body: body,
-          sender_profile_id: sender_profile_id
+          name:,
+          sender_email:,
+          phone:,
+          subject:,
+          body:,
+          sender_profile_id:
         )
 
         error = SBF::Client::ErrorEntity.new(response) unless ok?(response)

data/lib/stbaldricks/endpoints/newsletter_recipient.rb

@@ -3,9 +3,14 @@ require 'stbaldricks/endpoints/lib/entity'
 module SBF
   module Client
     class NewsletterRecipientEndpoint < EntityEndpoint
-      def subscribe(entity_or_email, first_name = nil, last_name = nil, welcome_email = true)
+      def subscribe(entity_or_email, first_name = nil, last_name = nil, welcome_email: true)
         if entity_or_email.is_a?(String) && entity_or_email && first_name && last_name
-          entity = target_class.new(email_address: entity_or_email, first_name: first_name, last_name: last_name, welcome_email: welcome_email)
+          entity = target_class.new({
+                                      email_address: entity_or_email,
+                                      first_name: first_name,
+                                      last_name: last_name,
+                                      welcome_email: welcome_email
+                                    }, clear_changes: false)
         elsif entity_or_email.is_a?(SBF::Client::BaseEntity)
           entity = entity_or_email
         else
@@ -21,9 +26,10 @@ module SBF
       end
 
       def unsubscribe(entity_or_email)
-        if entity_or_email.is_a?(String)
-          entity = target_class.new(email_address: entity_or_email)
-        elsif entity_or_email.is_a?(SBF::Client::BaseEntity)
+        case entity_or_email
+        when String
+          entity = target_class.new({email_address: entity_or_email}, clear_changes: false)
+        when SBF::Client::BaseEntity
           entity = entity_or_email
         else
           raise SBF::Client::Error, 'Invalid Entity'

data/lib/stbaldricks/endpoints/participant.rb

@@ -7,7 +7,7 @@ module SBF
         response = SBF::Client::Api::Request.post_request("#{base_uri}/move_to_different_team", id: participant_id, new_team_id: new_team_id)
 
         if ok?(response)
-          data = SBF::Client::FullParticipant.new(JSON.parse(response.body).symbolize!)
+          data = SBF::Client::FullParticipant.new(JSON.parse(response.body).symbolize!, clear_changes: false)
         else
           error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!)
         end
@@ -26,7 +26,7 @@ module SBF
         )
 
         if ok?(response)
-          data =  SBF::Client::FullParticipant.new(JSON.parse(response.body).symbolize!)
+          data =  SBF::Client::FullParticipant.new(JSON.parse(response.body).symbolize!, clear_changes: false)
         else
           error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!)
         end
@@ -38,7 +38,7 @@ module SBF
         response = SBF::Client::Api::Request.post_request("#{base_uri}/move_to_different_team", id: participant_id, new_team_id: 0)
 
         if ok?(response)
-          data = SBF::Client::FullParticipant.new(JSON.parse(response.body).symbolize!)
+          data = SBF::Client::FullParticipant.new(JSON.parse(response.body).symbolize!, clear_changes: false)
         else
           error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!)
         end

data/lib/stbaldricks/endpoints/photo.rb

@@ -4,7 +4,7 @@ module SBF
   module Client
     class PhotoEndpoint < SBF::Client::EntityEndpoint
       def create(entity_or_hash, with = {})
-        entity = entity_or_hash.is_a?(Hash) ? target_class.new(entity_or_hash) : entity_or_hash
+        entity = entity_or_hash.is_a?(Hash) ? target_class.new(entity_or_hash, clear_changes: false) : entity_or_hash
         raise SBF::Client::Error, 'Invalid Entity' unless entity.is_a?(SBF::Client::BaseEntity)
 
         with = normalize_with(with)
@@ -20,12 +20,13 @@ module SBF
       end
 
       def update(id = nil, entity_or_hash = nil, with = {})
-        if entity_or_hash.is_a?(SBF::Client::BaseEntity)
+        case entity_or_hash
+        when SBF::Client::BaseEntity
           # If someone has passed in an entity, just convert it to a hash
           data = entity_or_hash.dirty_data
           data[:id] = id unless id.nil?
           data[:id] = entity_or_hash.id if id.nil? && !entity_or_hash.id.nil?
-        elsif entity_or_hash.is_a?(Hash)
+        when Hash
           # If someone has passed in a hash, make sure all of it's values match fields in the entity class
           data = sanitize(entity_or_hash)
         else
@@ -66,7 +67,7 @@ module SBF
           data.file = file
           data
         else
-          photo = SBF::Client::Photo.new(data.is_a?(Hash) && data.any? ? data : {})
+          photo = SBF::Client::Photo.new((data.is_a?(Hash) && data.any?) ? data : {}, clear_changes: false)
           photo.file = file
           photo
         end

data/lib/stbaldricks/endpoints/promo.rb

@@ -4,7 +4,7 @@ module SBF
   module Client
     class PromoEndpoint < SBF::Client::EntityEndpoint
       def render_template(body, name, promo)
-        response = SBF::Client::Api::Request.post_request("#{base_uri}/render_email", body: body, name: name, promo: promo)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/render_email", body:, name:, promo:)
 
         if ok?(response)
           data = response.body
@@ -19,12 +19,12 @@ module SBF
       def send_promo_email(donation_id, name, recipient, body, ecard_send_date = nil, ecard_confirmation_email = nil)
         response = SBF::Client::Api::Request.post_request(
           "#{base_uri}/send_promo_email",
-          donation_id: donation_id,
-          name: name,
-          recipient: recipient,
-          body: body,
-          ecard_send_date: ecard_send_date,
-          ecard_confirmation_email: ecard_confirmation_email
+          donation_id:,
+          name:,
+          recipient:,
+          body:,
+          ecard_send_date:,
+          ecard_confirmation_email:
         )
 
         if ok?(response)

data/lib/stbaldricks/endpoints/search.rb

@@ -18,7 +18,7 @@ module SBF
       # @option [Integer] :offset The query offset.
       # @return [Client::Api::Response] The data attribute on a successful response will be
       #                                 an array of search entities matching the model type(s) specified
-      def find(model_type, search_text = nil, filters = [], geo_location = {}, options = {})
+      def find(model_type, search_text: nil, filters: [], geo_location: {}, options: {})
         if [search_text, filters, geo_location].all?(&:empty?)
           raise SBF::Client::Error, 'Must provide either a search_text, filter or geo_location for the query'
         end
@@ -30,7 +30,7 @@ module SBF
         # Build the parameter list for search
         params = {}
         response_data = {}
-        {model_type: model_type, search_text: search_text, filters: filters, geo_location: geo_location}.each do |k, v|
+        {model_type:, search_text:, filters:, geo_location:}.each do |k, v|
           params[k.to_sym] = v unless v.empty?
         end
 
@@ -45,7 +45,7 @@ module SBF
           response_data[:total_count] = parsed_response_body[:total]
           response_data[:results] = [].tap do |arr|
             parsed_response_body[:hits].each do |entity_data|
-              arr << target_class.const_get(entity_data[:type].capitalize).new(entity_data[:source])
+              arr << target_class.const_get(entity_data[:type].capitalize).new(entity_data[:source], clear_changes: false)
             end
           end
 

data/lib/stbaldricks/endpoints/user.rb

@@ -13,14 +13,14 @@ module SBF
       def login!(username, password)
         response = SBF::Client::Api::Request.post_request(
           "/#{SBF::Client::Api::VERSION}/security/login",
-          username: username,
-          password: password
+          username:,
+          password:
         )
         parsed_response = JSON.parse(response.body).symbolize!
 
         if ok?(response)
           SBF::Client::Configuration.user_token = parsed_response[:token]
-          data = parsed_response.merge(user: target_class.new(parsed_response[:user]))
+          data = parsed_response.merge(user: target_class.new(parsed_response[:user], clear_changes: false))
         else
           SBF::Client::Configuration.user_token = nil
           error = SBF::Client::ErrorEntity.new(parsed_response)
@@ -40,8 +40,8 @@ module SBF
 
         response = SBF::Client::Api::Request.post_request(
           "/#{SBF::Client::Api::VERSION}/security/list_entities_user_has_permission",
-          permission_id: permission_id,
-          event_years: event_years
+          permission_id:,
+          event_years:
         )
         parsed_response = JSON.parse(response.body).symbolize!
 
@@ -63,8 +63,8 @@ module SBF
 
         response = SBF::Client::Api::Request.post_request(
           "/#{SBF::Client::Api::VERSION}/security/change_password",
-          profile_id: profile_id,
-          password: password
+          profile_id:,
+          password:
         )
 
         unless ok?(response)
@@ -85,7 +85,7 @@ module SBF
 
         response = SBF::Client::Api::Request.post_request(
           "/#{SBF::Client::Api::VERSION}/user/disconnect_facebook",
-          profile_id: profile_id
+          profile_id:
         )
 
         SBF::Client::Configuration.user_token = nil