eco-helpers 3.0.21 → 3.0.23

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

@@ -0,0 +1,270 @@
+module Eco
+  module API
+    class Session
+      class Batch
+        class Feedback
+          # @attr_reader count [Integer] the total number of requests
+          # @attr_reader stats [Hash] plain `Hash` with the number of requests that include an attribute
+          class RequestStats
+            CORE_ATTRS     = Eco::API::Common::People::PersonParser::CORE_ATTRS
+            ACCOUNT_ATTRS  = (Eco::API::Common::People::PersonParser::ACCOUNT_ATTRS + ['permissions_custom']).uniq
+            DETAILS_ATTRS  = ['fields'].freeze
+            BLANKED_PREFIX = 'blanked_'.freeze
+            DETAILS_FIELDS = 'details_fields'.freeze
+
+            class << self
+              def valid_type?(type)
+                Eco::API::Session::Batch::Job.valid_type?(type.to_sym)
+              end
+
+              def core_attrs(stats: false, all: false)
+                CORE_ATTRS.dup.tap do |attrs|
+                  next unless stats || all
+
+                  attrs.unshift('core')
+                  attrs.concat(blank_attrs(CORE_ATTRS))
+                end
+              end
+
+              def account_attrs(stats: false, all: false)
+                ACCOUNT_ATTRS.dup.tap do |attrs|
+                  next unless stats || all
+
+                  attrs.unshift('account_remove')
+                  attrs.unshift('account') if all
+                  attrs.concat(blank_attrs(ACCOUNT_ATTRS))
+                end
+              end
+
+              def details_attrs(stats: false, all: false)
+                DETAILS_ATTRS.dup.tap do |attrs|
+                  next unless stats || all
+
+                  attrs.unshift('details_remove')
+                  attrs.unshift('details') if all
+                end
+              end
+
+              def blanked_prefix(attr = nil)
+                @blanked_prefix ||= BLANKED_PREFIX
+                return @blanked_prefix unless attr
+
+                "#{blanked_prefix}#{attr}"
+              end
+
+              def blanked_prefix=(value)
+                @blanked_prefix = value || blanked_prefix
+              end
+
+              def blank_attrs(attrs)
+                attrs.map {|attr| "#{blanked_prefix}#{attr}"}
+              end
+            end
+
+            attr_reader :type, :count
+
+            def initialize(type:, requests: [])
+              msg = "Type should be one of #{Eco::API::Session::Batch::Job.types}. Given: #{type}"
+              raise msg unless self.class.valid_type?(type.to_sym)
+
+              @type  = type.to_sym
+              @count = requests&.length
+              @stats = build(requests)
+            end
+
+            def to_h
+              @stats
+            end
+
+            def message(percent: false)
+              lines = []
+              lines << pairs_to_line(core_pairs(percent: percent))
+              lines << pairs_to_line(account_pairs(percent: percent))
+              lines << pairs_to_line(details_pairs(percent: percent))
+              lines.join("\n")
+            end
+
+            private
+
+            def attr_value(attr, percent: false, total: count, details: false)
+              target = details ? (@stats[DETAILS_FIELDS] || {}) : @stats
+              i      = target[attr.to_s]
+              return i unless percent
+
+              percentage(i, total: total)
+            end
+
+            def core(percent: false)
+              attr_value('core', percent: percent)
+            end
+
+            def account(percent: false)
+              attr_value('account', percent: percent)
+            end
+
+            def details(percent: false)
+              attr_value('details', percent: percent)
+            end
+
+            def stats
+              @stats ||= Hash.new(0)
+            end
+
+            def build(requests)
+              stats.tap do |stats|
+                stats[type] = count
+
+                no_requests =
+                  !requests                   ||
+                  !requests.is_a?(Enumerable) ||
+                  requests.empty?
+
+                next if no_requests
+
+                stats[DETAILS_FIELDS] = Hash.new(0)
+
+                requests.each do |request|
+                  add_core_stats(stats, request || {})
+                  add_account_stats(stats, request || {})
+                  add_details_stats(stats, request || {})
+                end
+              end
+            end
+
+            def attrs_to_stat(stats, hash, attrs)
+              stats.tap do |st|
+                attrs.each do |attr|
+                  next unless hash.key?(attr)
+
+                  st[attr] += 1
+                  next unless blanked_value?(hash[attr])
+
+                  st[blanked_prefix(attr)]+= 1
+                end
+              end
+            end
+
+            def add_core_stats(stats, request)
+              any_core = !(request.keys & core_attrs).empty? # rubocop:disable Style/ArrayIntersect
+              stats['core'] += 1 if any_core
+
+              attrs_to_stat(stats, request, core_attrs)
+            end
+
+            def add_account_stats(stats, request)
+              return unless request.key?('account')
+
+              stats['account'] += 1
+              stats['account_remove'] += 1 unless request['account']
+
+              attrs_to_stat(stats, request['account'] || {}, account_attrs)
+            end
+
+            def add_details_stats(stats, request)
+              return unless request.key?('details')
+
+              stats['details'] += 1
+              stats['details_remove'] += 1 unless request['details']
+
+              det_attrs = {}
+              if (fields = request.dig('details', 'fields'))
+                stats['fields'] += fields.length
+
+                det_attrs = fields.each_with_object(det_attrs) do |fld, hash|
+                  hash[fld['alt_id']] = fld['value']
+                end
+              end
+
+              attrs_to_stat(stats[DETAILS_FIELDS], det_attrs, det_attrs.keys)
+            end
+
+            def core_pairs(percent: false)
+              cattrs    = core_attrs + blank_attrs(core_attrs)
+              [['core', core(percent: percent)]] + pairs(cattrs, percent: percent, total: core)
+            end
+
+            def account_pairs(percent: false)
+              aattrs       = ['account_remove'] + account_attrs + blank_attrs(account_attrs)
+              [['account', account(percent: percent)]] + pairs(aattrs, percent: percent, total: account)
+            end
+
+            def details_pairs(percent: false)
+              det_pairs  = [['details', details(percent: percent)]]
+              det_pairs += [['fields', fields_average]] if attr_value('fields') && fields_average
+              det_pairs += pairs(['details_remove'], percent: percent, total: details)
+              det_pairs += pairs(details_field_attrs, percent: percent, total: details, details: true)
+              det_pairs
+            end
+
+            def pairs(attrs, percent: false, total: count, details: false)
+              attrs.map do |a|
+                value = attr_value(a, percent: percent, total: total, details: details)
+                value.positive? ? [a, value] : nil
+              end.compact
+            end
+
+            def pairs_to_line(pairs, percent: false)
+              key_val_delimiter = ': '
+              attr_delimiter    = ' ++ '
+
+              pairs.map do |p|
+                [p.first.to_s, "#{p.last}#{percent ? '%' : ''}"].join(key_val_delimiter)
+              end.join(attr_delimiter)
+            end
+
+            def core_attrs
+              @core_attrs ||= self.class.core_attrs
+            end
+
+            def account_attrs
+              @account_attrs ||= self.class.account_attrs
+            end
+
+            def details_attrs
+              @details_attrs ||= self.class.details_attrs
+            end
+
+            def details_field_attrs
+              @stats[DETAILS_FIELDS].keys
+            end
+
+            def blank_attrs(attrs)
+              self.class.blank_attrs(attrs)
+            end
+
+            def blanked_prefix(attr = nil)
+              self.class.blanked_prefix(attr)
+            end
+
+            def blanked_value?(value)
+              case value
+              when nil, false
+                true
+              when Numeric
+                value.zero?
+              when Array
+                value.compact.empty?
+              when String
+                value.to_s.strip.empty?
+              end
+            end
+
+            def fields_average
+              fields_num = attr_value('fields')
+              return unless fields_num && (total = details).positive?
+
+              (fields_num / total.to_f).round(2)
+            end
+
+            def percentage(num, total: count)
+              return unless num
+
+              total ||= count
+              (num.to_f / total * 100).round(2)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,151 +4,76 @@ module Eco
       class Batch
         # @attr_reader job [Eco::API::Session::Batch::Job] `batch job` the feedback is associated with
         class Feedback
+          require_relative 'feedback/job_dependencies'
+          require_relative 'feedback/request_stat'
+          require_relative 'feedback/generate'
 
-          class << self
-            def person_ref(entry)
-              row_str = (row = get_row(entry)) ? "(row: #{row}) " : nil
-              "#{row_str}(id: '#{get_attr(entry, :id)}') '#{get_attr(entry, :name)}' ('#{get_attr(entry, :external_id)}': '#{get_attr(entry, :email)}')"
-            end
+          include JobDependencies
+          include RequestStat
+          include Generate
 
-            def get_attr(entry, attr)
-              if entry.respond_to?(attr.to_sym)
-                entry.public_send(attr.to_sym)
-              elsif entry.is_a?(Hash)
-                entry["#{attr}"]
-              end
-            end
+          require_relative 'feedback/getters'
+          require_relative 'feedback/identifiers'
 
-            def get_row(value)
-              case value
-              when Eco::API::Common::People::PersonEntry
-                value.idx
-              when Ecoportal::API::V1::Person
-                get_row(value.entry)
-              end
-            end            
-          end
-
-          attr_reader :job
+          extend Getters
+          extend Identifiers
 
           # @param job [Eco::API::Session::Batch::Job] `batch job` the feedback is associated with
           def initialize(job:)
-            raise "A Eco::API::Session::Batch::Job object is required. Given: #{job}" unless job.is_a?(Eco::API::Session::Batch::Job)
-            @job  = job
-          end
-
-          # @!group Job shortcut methods
-
-          # @see Eco::API::Session::Batch::Job#name
-          # @return [String] name of the `batch job`
-          def name
-            job.name
-          end
-
-          # @see Eco::API::Session::Batch::Job#type
-          def type
-            job.type
-          end
-
-          # @see Eco::API::Session::Batch::Job#sets
-          def sets
-            job.sets
-          end
-
-          # @see Eco::API::Session::Batch::Job#options
-          def options
-            job.options
-          end
+            msg = "A Eco::API::Session::Batch::Job object is required. Given: #{job.class}"
+            raise msg unless job.is_a?(Eco::API::Session::Batch::Job)
 
-          # @see Eco::API::Session::Batch::Job#requests
-          def job_requests
-            job.requests
+            @job  = job
           end
-          # @!endgroup
 
           # @!group Pure feedback methods
 
-          # Slightly modifies the behaviour of `Ecoportal::API::Common::BaseModel#as_update`, so schema details fields show the `alt_id`
+          # Slightly modifies the behaviour of `Ecoportal::API::Common::BaseModel#as_update`,
+          #   so schema details fields show the `alt_id`.
           # It also fixes possible patch updates that are incomplete or unnecessary.
           # @note for better feedback
           # @param entry [Hash, Ecoportal::API::V1::Person, Ecoportal::API::Internal::Person]
           # @param add_feedback [Boolean] if `true` it tweak the hash update with additional data.
           def as_update(entry, add_feedback: true)
-            case
-            when entry.is_a?(Hash)
-              hash = entry
-            else #entry.is_a?(Ecoportal::API::V1::Person)
-              if only_ids?
-                hash = entry.as_json.slice("id", "external_id", "email")
-              else
-                hash = entry.as_update
-
-                if add_feedback && details = hash["details"]
-                  if hfields = details["fields"]
-                    hfields.each do |fld|
-                      fld.merge!("alt_id" => entry.details.get_field(fld["id"]).alt_id)
-                    end
-                  end
-                end
+            return entry if entry.is_a?(Hash)
+
+            # assuming entry.is_a?(Ecoportal::API::V1::Person)
+
+            if only_ids?
+              # @todo entry.respond_to?(:as_json)
+              hash = entry.as_json.slice('id', 'external_id', 'email')
+            else
+              # @todo entry.respond_to?(:as_update)
+              hash     = entry.as_update
 
-                if account = hash["account"]
-                  if account.keys == ["send_invites"] && !account["send_invites"]
-                    hash.delete("account")
-                    hash.delete("id") if hash.keys == ["id"]
-                  end
+              details  = hash['details']
+              h_fields = details && details['fields']
+
+              if add_feedback && h_fields
+                h_fields.each do |fld|
+                  fld.merge!('alt_id' => entry.details.get_field(fld['id']).alt_id)
                 end
               end
-            end
-            hash || {}
-          end
 
-          # @note if `requests` is not provided, it uses the last requests of the parent `Batch::Job` `job`
-          # @param requests [Enumerable<Hash>] raw requests as they would be sent to the _Server_
-          # @return [Eco::API::Session::Batch::RequestStats] the stats object of the current requests
-          def request_stats(requests = nil)
-            requests ||= job.requests
-            return @request_stats if @request_stats && requests == job.requests
-            @request_stats ||= Eco::API::Session::Batch::RequestStats.new(type: type, requests: requests)
-          end
+              account  = hash['account']
+              invites  = account && account.keys == ['send_invites']
+              ninvites = invites && !account['send_invites']
 
-          # Generates the lines of feedback of the current requests
-          # @note if `requests` is not provided, it uses the last requests of the parent `Batch::Job` `job`
-          # @param requests [Enumerable<Hash>] raw requests as they would be sent to the _Server_
-          # @param max_chars [Integer] the max number of characters for the current feedback message
-          # @param only_stats [Boolean] whether or not should only include a brief summary of stats
-          # @return [String] the feedback message
-          def generate(requests = nil, max_chars: 800, only_stats: false)
-            requests ||= job.requests
-            [].tap do |msg|
-              if !requests || !requests.is_a?(Enumerable) || requests.empty?
-                msg << "#{"*" * 10} Nothing for #{signature} so far :)  #{"*" * 10}"
-              else
-                header = "#{"*"*10}  #{signature} - Feedback Sample #{"*"*10}"
-                msg << header unless only_stats
-                unless only_stats
-                  sample_length = 1
-                  sample = requests.slice(0, 20).map do |request|
-                    max_chars     -= request.pretty_inspect.length
-                    sample_length += 1 if max_chars > 0
-                    request
-                  end
-                  msg << "#{sample.slice(0, sample_length).pretty_inspect}"
-                end
-                stats_str = "#{"+"*3}  #{type.to_s.upcase} length: #{requests.length}  #{"+"*3}  STATS  (job '#{name}')  #{"+"*3}"
-                msg << "#{"-"*stats_str.length}" if only_stats
-                msg << stats_str
-                msg << "#{request_stats(requests).message}"
-                msg << "#{"-"*stats_str.length}" if only_stats
-                msg << "*" * header.length unless only_stats
+              if ninvites
+                hash.delete('account')
+                hash.delete('id') if hash.keys == ['id']
               end
-            end.join("\n")
+            end
+
+            hash || {}
           end
+
           # @!endgroup
 
           private
 
           def only_ids?
-            [:delete, :get].include?(type)
+            %i[delete get].include?(type)
           end
 
           def signature
@@ -156,11 +81,12 @@ module Eco
           end
 
           def sets_title
-            "#{sets.map {|s| s.to_s}.join(", ")}"
+            sets.map(&:to_s).join(', ')
           end
-
         end
       end
     end
   end
 end
+
+require_relative 'feedback/request_stats'

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

@@ -0,0 +1,23 @@
+class Eco::API::Session::Batch::Job
+  module Sets
+    SETS = %i[core details account].freeze
+
+    class << self
+      def included(base)
+        super
+        base.extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def valid_sets?(value)
+        sts = [value].flatten
+        sts.all? { |s| sets.include?(s) }
+      end
+
+      def sets
+        self::SETS
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+class Eco::API::Session::Batch::Job
+  module Type
+    TYPES = %i[get create update delete].freeze
+
+    class << self
+      def included(base)
+        super
+        base.extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def valid_type?(value)
+        types.include?(value)
+      end
+
+      def types
+        self::TYPES
+      end
+    end
+  end
+end

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

@@ -14,23 +14,13 @@ module Eco
         # @attr_reader feedback [Eco::API::Session::Batch::Feedback] helper class
         #   for feedback and end-user decision making
         class Job < Eco::API::Common::Session::BaseSession
-          include Eco::Language::Methods::DslAble
-
-          @types = %i[get create update delete]
-          @sets  = %i[core details account]
+          require_relative 'job/type'
+          require_relative 'job/sets'
 
-          class << self
-            attr_reader :types, :sets
-
-            def valid_type?(value)
-              types.include?(value)
-            end
+          include Eco::Language::Methods::DslAble
 
-            def valid_sets?(value)
-              sts = [value].flatten
-              sts.all? { |s| sets.include?(s) }
-            end
-          end
+          include Type
+          include Sets
 
           attr_reader :name, :type, :sets
           attr_reader :usecase
@@ -197,7 +187,7 @@ module Eco
           #     - only include the entries that, after all above, still hold pending changes
           #       (`!as_update.empty?`) to be launched as update
           #   2. pre launch checks against the `requests`:
-          #     - it generates `stats` (`Eco::API::Session::Batch::RequestStats`) out of the requests
+          #     - it generates `stats` (`Eco::API::Session::Batch::Feedback::RequestStats`) out of the requests
           #     - if there is a batch policy declared for the current job `type`, it
           #       checks compliance against `stats` (see {Eco::API::Session::Batch::Policies}),
           #       - a non-compliant batch will stop the current session by raising an `Exception`
@@ -368,7 +358,7 @@ module Eco
               next if policies.empty?
 
               policies.launch(
-                people:  entries,
+                data:    entries,
                 session: session,
                 options: options,
                 job:     self
@@ -496,7 +486,7 @@ module Eco
               log(:debug) { msg }
 
               handler.launch(
-                people:  people(entries),
+                data:    people(entries),
                 session: session,
                 options: options,
                 job:     handler_job

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

@@ -28,7 +28,8 @@ module Eco
           end
 
           def each(&block)
-            return to_enum(:each) unless block
+            return to_enum(:each) unless block_given?
+
             items.each(&block)
           end
 
@@ -51,6 +52,7 @@ module Eco
           # @return [Eco::API::Session::Batch::Job]
           def job(name, type: nil, sets: nil, usecase: nil, accept_update_with_no_id: false, &block)
             fatal "Can't give a job post-launch callback &block to an already existing job" if exists?(name)
+
             new(name, type: type, sets: sets, usecase: usecase, accept_update_with_no_id: accept_update_with_no_id, &block) unless exists?(name)
             self[name]
           end
@@ -75,7 +77,9 @@ module Eco
           # @yieldparam status [Eco::API::Session::Batch::Status] the status of the batch job launch.
           # @return [Eco::API::Session::Batch::Job]
           def add(job, &block)
-            fatal "Expected Eco::API::Session::Batch::Job object. Given #{job.class}" unless job.is_a?(Eco::API::Session::Batch::Job)
+            msg = "Expected Eco::API::Session::Batch::Job object. Given #{job.class}"
+            fatal msg unless job.is_a?(Eco::API::Session::Batch::Job)
+
             @jobs[job.name] = job
             @callbacks[job] = block if block_given?
           end

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

@@ -19,7 +19,7 @@ module Eco
 
             # Swaps to batch endpoint on specific errors
             def batch_mode_on(*error_types, options: self.options, allow_job_mode: true)
-              msg = "Expecting block. Non given"
+              msg = 'Expecting block. Non given'
               raise ArgumentError, msg unless block_given?
 
               in_job_mode = allow_job_mode && job_mode?(options)

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

@@ -6,7 +6,7 @@ module Eco
           module Retry
             def self.included(base)
               unless base <= Eco::API::Session::Batch::Launcher
-                msg  = "To be included only in Eco::API::Common::Session::BaseSession. "
+                msg  = 'To be included only in Eco::API::Common::Session::BaseSession. '
                 msg << "Tried on '#{base}'"
                 raise msg
               end
@@ -23,15 +23,15 @@ module Eco
 
               explanation = "#{err}\n"
               explanation << "You have #{retries_left} retries left."
-              question    = " Do you want to retry (y/N)?"
+              question    = ' Do you want to retry (Y/n)?'
 
               prompt_user(
                 question,
-                default:     "Y",
+                default:     'Y',
                 explanation: explanation,
                 timeout:     10
               ) do |response|
-                raise unless response.upcase.start_with?("Y")
+                raise unless response.upcase.start_with?('Y')
 
                 puts "\nOkay... let's retry!"
                 offer_retry_on(*error_types, retries_left: retries_left - 1, &block)

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

@@ -39,9 +39,9 @@ module Eco
           def batch_from(
             data,
             method:,
-            params:  {},
             silent:  false,
-            options: self.options
+            options: self.options,
+            **_other_kargs
           )
             fatal "Invalid batch method: #{method}." unless valid_method?(method)
             return unless data.is_a?(Enumerable)

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

@@ -3,9 +3,9 @@ module Eco
     class Session
       class Batch
         class Policies < Eco::API::Session::Batch::BasePolicy
-          CORE_ATTRS    = Eco::API::Session::Batch::RequestStats.core_attrs(stats: true)
-          ACCOUNT_ATTRS = Eco::API::Session::Batch::RequestStats.account_attrs(stats: true)
-          DETAILS_ATTRS = Eco::API::Session::Batch::RequestStats.details_attrs(stats: true)
+          CORE_ATTRS    = Eco::API::Session::Batch::Feedback::RequestStats.core_attrs(stats: true)
+          ACCOUNT_ATTRS = Eco::API::Session::Batch::Feedback::RequestStats.account_attrs(stats: true)
+          DETAILS_ATTRS = Eco::API::Session::Batch::Feedback::RequestStats.details_attrs(stats: true)
 
           core_model    = {core:    CORE_ATTRS}
           account_model = {account: ACCOUNT_ATTRS}
@@ -14,7 +14,7 @@ module Eco
           TOP_MODEL     = Eco::API::Session::Batch::Job.types.each_with_object({}) {|t, h| h[t] = submodel}
 
           self.model = TOP_MODEL
-          policy_attrs *model_attrs
+          policy_attrs(*model_attrs)
         end
       end
     end