eco-helpers 2.7.13 → 2.7.15

data/lib/eco/api/common/people/entry_factory.rb

@@ -27,6 +27,7 @@ module Eco
           # @param attr_map [nil, Eco::Data::Mapper] attribute names mapper
           #   to translate external names into internal ones and _vice versa_.
           def initialize(e, schema:, person_parser: nil, default_parser: nil, attr_map: nil)
+            super(e)
             msg = "Constructor needs a PersonSchema. Given: #{schema.class}"
             fatal msg unless schema.is_a?(Ecoportal::API::V1::PersonSchema)
 
@@ -35,7 +36,6 @@ module Eco
 
             msg = "Expecting Mapper object. Given: #{attr_map.class}"
             fatal msg if attr_map && !attr_map.is_a?(Eco::Data::Mapper)
-            super(e)
 
             @schema = Ecoportal::API::V1::PersonSchema.new(JSON.parse(schema.doc.to_json))
             @source_person_parser = person_parser

data/lib/eco/api/session/batch.rb

@@ -2,9 +2,8 @@ module Eco
   module API
     class Session
       class Batch < Common::Session::BaseSession
-
         DEFAULT_BATCH_BLOCK = 50
-        VALID_METHODS =  [:get, :create, :update, :upsert, :delete]
+        VALID_METHODS = %i[get create update upsert delete].freeze
 
         class << self
           # @return [Boolean] `true` if the method is supported, `false` otherwise.
@@ -25,7 +24,8 @@ module Eco
         # @return [Array<People>] all the people based on `params`
         def get_people(people = nil, params: {}, silent: false)
           return launch(people, method: :get, params: params, silent: silent).people if people.is_a?(Enumerable)
-          return get(params: params, silent: silent)
+
+          get(params: params, silent: silent)
         end
 
         # launches a batch of `method` type using `people` and the specified `params`
@@ -37,11 +37,11 @@ module Eco
         # @param params [Hash] api request options.
         # @option params [String] :per_page the number of people included per each batch api request.
         # @return [Batch::Status] the `status` of this batch launch.
-        def launch(people, method:, params: {} , silent: false)
+        def launch(people, method:, params: {}, silent: false)
           batch_from(people, method: method, params: params, silent: silent)
         end
 
-        def search(data, silent: false, params: {})
+        def search(data, silent: false, params: {}) # rubocop:disable Metrics/AbcSize
           params = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
 
           launch(data, method: :get, params: params, silent: silent).tap do |status|
@@ -50,36 +50,35 @@ module Eco
             entries = status.queue
             puts "\n"
             entries.each_with_index do |entry, i|
-              if (i % 10 == 0)
+              if (i % 10).zero?
                 percent = i * 100 / entries.length
                 print "Searching: #{percent.round}% (#{i}/#{entries.length} entries)\r"
                 $stdout.flush
               end
 
-              unless status.success?(entry)
-                email = nil
-                case
-                when entry.respond_to?(:email)
-                  email = entry.email
-                when entry.respond_to?(:to_h)
-                  email = entry.to_h["email"]
-                end
+              next if status.success?(entry)
 
-                people_matching = []
-                email = email.to_s.strip.downcase
-                unless email.empty?
-                  people_matching = get(params: params.merge(q: email), silent: silent).select do |person|
-                    person.email == email
-                  end
-                end
+              email = nil
+              if entry.respond_to?(:email)
+                email = entry.email
+              elsif entry.respond_to?(:to_h)
+                email = entry.to_h["email"]
+              end
 
-                case people_matching.length
-                when 1
-                  status.set_person_match(entry, people_matching.first)
-                when 2..Float::INFINITY
-                  status.set_people_match(entry, people_matching)
+              people_matching = []
+              email = email.to_s.strip.downcase
+              unless email.empty?
+                people_matching = get(params: params.merge(q: email), silent: silent).select do |person|
+                  person.email == email
                 end
               end
+
+              case people_matching.length
+              when 1
+                status.set_person_match(entry, people_matching.first)
+              when 2..Float::INFINITY
+                status.set_people_match(entry, people_matching)
+              end
             end
           end
         end
@@ -87,42 +86,61 @@ module Eco
         private
 
         def get(params: {}, silent: false)
-          fatal "cannot batch get without api connnection, please provide a valid api connection!" unless people_api = api&.people
+          msg = "cannot batch get without api connnection, please provide a valid api connection!"
+          fatal msg unless (people_api = api&.people)
+
           params = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
-          return people_api.get_all(params: params, silent: silent)
+          people_api.get_all(params: params, silent: silent)
         end
 
-
         def batch_from(data, method:, params: {}, silent: false)
-          fatal "Invalid batch method: #{method}." if !self.class.valid_method?(method)
+          fatal "Invalid batch method: #{method}." unless self.class.valid_method?(method)
           return nil if !data || !data.is_a?(Enumerable)
-          fatal "cannot batch #{method} without api connnection, please provide a valid api connection!" unless people_api = api&.people
+
+          msg = "cannot batch #{method} without api connnection, please provide a valid api connection!"
+          fatal msg unless (people_api = api&.people)
 
           # param q does not make sense here, even for GET method
           params   = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
           per_page = params[:per_page] || DEFAULT_BATCH_BLOCK
 
-          launch_batch(data,
-            method: method,
-            per_page: per_page,
+          launch_batch(
+            data,
+            method:     method,
+            per_page:   per_page,
             people_api: people_api,
-            silent: silent
+            silent:     silent
           )
         end
 
-        def launch_batch(data, method:, status: nil, job_mode: true, per_page: DEFAULT_BATCH_BLOCK, people_api: api&.people, silent: false)
-          iteration  = 1; done = 0
+        def launch_batch( # rubocop:disable Metrics/AbcSize
+          data,
+          method:,
+          status:     nil,
+          job_mode:   true, # rubocop:disable Lint/UnusedMethodArgument
+          per_page:   DEFAULT_BATCH_BLOCK,
+          people_api: api&.people,
+          silent:     false
+        )
+          iteration  = 1
+          done       = 0
           iterations = (data.length.to_f / per_page).ceil
 
-          status ||= Eco::API::Session::Batch::Status.new(enviro, queue: data, method: method)
-          status.tap do |status|
+          status ||= Eco::API::Session::Batch::Status.new(
+            enviro,
+            queue:  data,
+            method: method
+          )
+
+          status.tap do
             start_time  = Time.now
-            start_slice = Time.now; slice = []
-            pending_for_server_error = data.to_a[0..-1]
+            start_slice = Time.now
+
+            pending_for_server_error = data.to_a[0..]
             data.each_slice(per_page) do |slice|
               msg  = "starting batch '#{method}' iteration #{iteration}/#{iterations},"
-              msg += " with #{slice.length} entries of #{data.length} -- #{done} done"
-              msg += " (last: #{str_stats(start_slice, slice.length)}; total: #{str_stats(start_time, done)})"
+              msg << " with #{slice.length} entries of #{data.length} -- #{done} done"
+              msg << " (last: #{str_stats(start_slice, slice.length)}; total: #{str_stats(start_time, done)})"
               logger.info(msg) unless silent
 
               start_slice = Time.now
@@ -130,11 +148,12 @@ module Eco
                 people_api.batch(job_mode: false) do |batch|
                   slice.each do |person|
                     batch.public_send(method, person) do |response|
-                      faltal("Request with no response") unless !!response
-                      unless server_error?(response)
-                        pending_for_server_error.delete(person)
-                        status[person] = response
-                      end
+                      faltal("Request with no response") unless response
+
+                      next if server_error?(response)
+
+                      pending_for_server_error.delete(person)
+                      status[person] = response
                     end
                   end
                 end # end batch
@@ -148,13 +167,15 @@ module Eco
             unless pending_for_server_error.empty?
               msg = "Going to re-try #{pending_for_server_error.count} due to server errors"
               logger.info(msg) unless silent
-              launch_batch(pending_for_server_error,
-                status: status,
-                method: method,
-                job_mode: false,
-                per_page: per_page,
+
+              launch_batch(
+                pending_for_server_error,
+                status:     status,
+                method:     method,
+                job_mode:   false,
+                per_page:   per_page,
                 people_api: people_api,
-                silent: silent
+                silent:     silent
               )
             end
           end
@@ -164,24 +185,23 @@ module Eco
           res_status   = response.status
           server_error = !res_status || res_status.server_error?
           other_error  = !server_error && (!res_status.code || res_status.code < 100)
-          no_body      = !server_error && !other_error  && !response.body
+          no_body      = !server_error && !other_error && !response.body
           server_error || other_error || no_body
         end
 
         def offer_retry_on(error_type, retries_left = 3, &block)
-          begin
-            block.call
-          rescue error_type => e
-            raise unless retries_left > 0
-            explanation = "Batch TimeOut. You have #{retries_left} retries left."
-            prompt_user(" Do you want to retry (y/N)?", default: "Y", explanation: explanation, timeout: 10) do |response|
-              if response.upcase.start_with?("Y")
-                puts "\nOkay... let's retry!"
-                offer_retry_on(error_type, retries_left - 1, &block)
-              else
-                raise
-              end
-            end
+          block.call
+        rescue error_type
+          raise unless retries_left.positive?
+
+          explanation = "Batch TimeOut. You have #{retries_left} retries left."
+          question    = " Do you want to retry (y/N)?"
+
+          prompt_user(question, default: "Y", explanation: explanation, timeout: 10) do |response|
+            raise unless response.upcase.start_with?("Y")
+
+            puts "\nOkay... let's retry!"
+            offer_retry_on(error_type, retries_left - 1, &block)
           end
         end
 
@@ -195,7 +215,6 @@ module Eco
             " -- "
           end
         end
-
       end
     end
   end

data/lib/eco/api/usecases/graphql/samples/location/command/track_changed_ids.rb

@@ -50,7 +50,9 @@ class Eco::API::UseCases::GraphQL::Samples::Location
       msg = "Expecting CommandResults object. Given: #{results.class}"
       raise msg unless results.is_a?(request_results_class)
 
-      results.applied.each do |result|
+      target = simulate?? results.results : results.applied
+
+      target.each do |result|
         prev_id, new_id = result.command_input_data.values_at(:nodeId, :newId)
         next if new_id.nil? # not an id change
         next if prev_id == new_id

data/lib/eco/api/usecases/ooze_samples/register_update_case.rb

@@ -244,12 +244,12 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
   end
 
   def conf_filters
-    return filters if respond_to?(:filters)
+    filters if respond_to?(:filters)
     []
   end
 
   def conf_search
-    return search if respond_to?(:search)
+    search if respond_to?(:search)
   end
 
   def register_id

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = '2.7.13'.freeze
+  VERSION = '2.7.15'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.7.13
+  version: 2.7.15
 platform: ruby
 authors:
 - Oscar Segura
@@ -534,6 +534,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".markdownlint.jsonc"
 - ".rspec"
 - ".rubocop.yml"
 - ".yardopts"