eco-helpers 3.0.21 → 3.0.23

data/lib/eco/api/microcases/with_each_starter.rb

@@ -1,37 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Detects who in the `entries` is new in the organization and `yield` s them one by one to the given block.
-      # @note
-      #   - it also links to `person.entry` the input data `entry`.
-      # @param entries [Eco::API::Common::People::Entries] the input entries with the data.
-      # @param people [Eco::API::Organization::People] target existing _People_ of the current update.
-      # @param options [Hash] the options.
-      # @param log_present [Boolean] log error message if an `entry` has match in `people`.
-      # @param append_created [Boolean] whether or not a new person will be added to the `people` object.
-      # @yield [entry, person] gives each **new** `person` of `entries` that is not present in `people`.
-      # @yieldparam entry [PersonEntry] the input entry with the data we should set on person.
-      # @yieldparam person [Ecoportal::API::V1::Person] the **new** person.
-      # @return [Eco::API::Organization::People] the starters.
-      def with_each_starter(entries, people, options, log_present: false, append_created: true)
-        starters = []
-        micro.with_each(entries, people, options, append_created: append_created) do |entry, person|
-          unless person.new?
-            if log_present
-              log(:error) {
-                "This person (id: '#{person.id}') already exists: #{entry.to_s(:identify)}"
-              }
-            end
-
-            next
-          end
-
-          starters << person
-          yield(entry, person) if block_given?
-        end
-
-        people.newFrom starters
-      end
-    end
-  end
-end

data/lib/eco/api/microcases/with_each_subordinate.rb

@@ -1,33 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Finds all the subordinates of `supervisor`.
-      # @note if `supervisor` is `nil`, it will return all people with no supervisor.
-      # @param supervisor [String, Ecoportal::API::V1::Person, Hash] the `supervisor` or the `id` / `external_id` thereof.
-      # @param people [Eco::API::Organization::People] target existing _People_ of the current update.
-      # @yield [subordinate] block that does some stuff with `subordinate`.
-      # @yieldparam subordinate [Ecoportal::API::V1::Person] each one of the suborinates of `supervisor`.
-      # @return [Eco::API::Organization::People] the **subordinates** of `supervisor`.
-      def with_each_subordinate(supervisor, people)
-        people.supervisor_id(_person_id(supervisor, people)).tap do |subordinates|
-          subordinates.each do |subordinate|
-            yield(subordinate) if block_given?
-          end
-        end
-      end
-
-      private
-
-      def _person_id(value, people)
-        case value
-        when Hash
-          _person_id(value["id"] || value["external_id"], people)
-        when Ecoportal::API::V1::Person
-          _person_id(value.id    || value.external_id, people)
-        when String
-          micro.with_supervisor(value, people)&.id
-        end
-      end
-    end
-  end
-end

data/lib/eco/api/microcases/with_supervisor.rb

@@ -1,35 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Finds the supervisor among `people` by using the `supervisor_id` of `value`.
-      # @param value [String, Ecoportal::API::V1::Person, Hash] the subordinate person,
-      #   or the unique identifier of the supervisor to be found (preferably the `external_id`).
-      # @param people [Eco::API::Organization::People] target existing _People_ of the current update.
-      # @param strict [Boolean] specifies if the search should be `strict` (see {Eco::API::Organization::People#person}).
-      # @yield [supervisor] block that does some stuff with supevisor.
-      # @yieldparam supervisor [Ecoportal::API::V1::Person] the person object of the supervisor, or `nil` if not found.
-      # @return [nil, Ecoportal::API::V1::Person] found `supervisor` of `value`.
-      def with_supervisor(value, people, strict: false)
-        if sup_id = with_supervisor_supervisor_id(value)
-          people.person(id: sup_id, external_id: sup_id, email: sup_id, strict: strict)
-        end.tap do |supervisor|
-          yield(supervisor) if block_given?
-        end
-      end
-
-      private
-
-      def with_supervisor_supervisor_id(value)
-        return nil if value.to_s.strip.empty?
-        case
-        when value.respond_to?(:supervisor_id)
-          value.supervisor_id
-        when value.is_a?(Hash)
-          value["supervisor_id"]
-        else
-          value
-        end
-      end
-    end
-  end
-end

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

@@ -1,266 +0,0 @@
-module Eco
-  module API
-    class Session
-      class Batch
-        # @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