eco-helpers 3.0.20 → 3.0.22

data/lib/eco/api/organization/people.rb

@@ -1,43 +1,10 @@
+# rubocop:disable Style/Attr
 module Eco
   module API
     module Organization
-      class People <  Eco::Language::Models::Collection
-        # Error class that allows to handle cases where multiple people were found for the same criterion.
-        # @note its main purpose to prevent the creation of duplicates or override information between different people.
-        class MultipleSearchResults < StandardError
-          attr_reader :candidates, :property
-          # @param msg [String] the basic message error.
-          # @param candiates [Array<Person>] the people that match the same search criterion.
-          # @param property [String] the property of the person model that triggered the error (base of the search criterion).
-          def initialize(msg, candidates: [], property: "email")
-            @candidates = candidates
-            @property   = property
-            super(msg + " " + candidates_summary)
-          end
-
-          # @param with_index [Boolean] to add an index to each candidate description.
-          # @return [Array<String>] the `candidates` identified
-          def identify_candidates(with_index: false)
-            candidates.map.each_with_index do |person, i|
-              index = with_index     ? "#{i}. " : ""
-              msg   = person.account ? (person.account_added? ? "(new user)" : "(user)") :  "(no account)"
-              "#{index}#{msg} #{person.identify}"
-            end
-          end
-
-          # @return [Person] the `candidate` in the `index` position
-          def candidate(index)
-            candidates[index]
-          end
-
-          private
-
-          def candidates_summary
-            lines = ["The following people have the same '#{property}':"]
-            lines.concat(identify_candidates(with_index: true)).join("\n  ")
-          end
-
-        end
+      class People < Eco::Language::Models::Collection
+        require_relative 'people/multiple_search_results'
+        require_relative 'people/similarity'
 
         # build the shortcuts of Collection
         attr_presence :account, :details
@@ -84,39 +51,39 @@ module Eco
         def updated_or_created
           select do |person|
             !person.as_update(:total).empty?
-          end.yield_self do |persons|
+          end.then do |persons|
             newFrom persons
           end
         end
 
         def supervisors
-          sup_ids = self.ids & self.supervisor_ids
+          sup_ids = ids & supervisor_ids
           sup_ids.map do |id|
             person(id: id, strict: true)
-          end.yield_self do |supervisors|
+          end.then do |supervisors|
             newFrom supervisors
           end
         end
 
         def missing_supervisors_ids
-          sup_ids = self.supervisor_ids
-          sup_ids - (sup_ids & self.ids)
+          sup_ids = supervisor_ids
+          sup_ids - (sup_ids & ids)
         end
 
         def filter_tags_any(tags)
-          attr("filter_tags", tags, default_modifier.any.insensitive)
+          attr('filter_tags', tags, default_modifier.any.insensitive)
         end
 
         def filter_tags_all(tags)
-          attr("filter_tags", tags, default_modifier.all.insensitive)
+          attr('filter_tags', tags, default_modifier.all.insensitive)
         end
 
         def policy_group_ids_any(ids)
-          attr("policy_group_ids", tags, default_modifier.any.insensitive)
+          attr('policy_group_ids', ids, default_modifier.any.insensitive)
         end
 
         def policy_group_ids_all(ids)
-          attr("policy_group_ids", tags, default_modifier.all.insensitive)
+          attr('policy_group_ids', ids, default_modifier.all.insensitive)
         end
 
         # @!endgroup
@@ -138,7 +105,8 @@ module Eco
         # @param id [String] the `internal id` of the person
         # @param external_id [String] the `exernal_id` of the person
         # @param email [String] the `email` of the person
-        # @param strict [Boolean] if should perform a `:soft` or a `:strict` search. `strict` will avoid repeated email addresses.
+        # @param strict [Boolean] if should perform a `:soft` or a `:strict` search.
+        #   `strict` will avoid repeated email addresses.
         # @return [Person, nil] the person we were searching, or `nil` if not found.
         def person(id: nil, external_id: nil, email: nil, strict: false)
           init_caches
@@ -155,9 +123,9 @@ module Eco
 
         # @see Eco::API::Organization::People#person
         def find(object, strict: false)
-          id          = attr_value(object, "id")
-          external_id = attr_value(object, "external_id")
-          email       = attr_value(object, "email")
+          id          = attr_value(object, 'id')
+          external_id = attr_value(object, 'external_id')
+          email       = attr_value(object, 'email')
           person(id: id, external_id: external_id, email: email, strict: strict)
         end
         # @!endgroup
@@ -168,19 +136,20 @@ module Eco
           to_a.to_json
         end
 
-        def newFrom(data)
+        def newFrom(data) # rubocop:disable Naming/MethodName
           self.class.new(data, klass: @klass)
         end
 
         def uniq(strict: false, include_unsearchable: false)
           unsearchable = []
+
           to_a.each_with_object([]) do |person, people|
-            if found = find(person, strict: strict)
+            if (found = find(person, strict: strict))
               people << found
             else
               unsearchable << person
             end
-          end.yield_self do |found|
+          end.then do |found|
             found += unsearchable if include_unsearchable
             newFrom found
           end
@@ -203,7 +172,7 @@ module Eco
         def exclude_people(list, strict: false)
           list.map do |person|
             find(person, strict: strict)
-          end.compact.yield_self do |discarded|
+          end.compact.then do |discarded|
             newFrom to_a - discarded
           end
         end
@@ -212,7 +181,7 @@ module Eco
         # @!group Groupping methods
 
         def email_id_maps
-          users.group_by(:email).transform_values { |person| person.id }
+          users.group_by(:email).transform_values(&:id)
         end
 
         def group_by_supervisor
@@ -221,18 +190,20 @@ module Eco
 
         def group_by_schema
           to_h do |person|
-            person.details && person.details.schema_id
+            next unless (details = person.details)
+
+            details.schema_id
           end
         end
 
-        def to_h(attr = "id")
-          super(attr || "id")
+        def to_h(attr = 'id')
+          super(attr || 'id')
         end
         # @!endgroup
 
         # @!group Helper methods
         def similarity
-          Eco::API::Organization::PeopleSimilarity.new(self.to_a)
+          Eco::API::Organization::People::Similarity.new(to_a)
         end
         # @!endgroup
 
@@ -245,21 +216,22 @@ module Eco
         private
 
         def person_by_email(email, prevent_duplicates: true)
-          return nil unless email
+          return unless email
 
           candidates  = @by_non_users_email[email] || []
           email_users = @by_users_email[email]     || []
 
-          if pers = email_users.first
+          if (pers = email_users.first)
             return pers if candidates.empty?
+
             candidates = [pers] + candidates
           elsif candidates.length == 1
             return candidates.first
           end
 
           if prevent_duplicates && !candidates.empty?
-            msg = "Multiple search results match the criteria."
-            raise MultipleSearchResults.new(msg, candidates: candidates, property: "email")
+            msg = 'Multiple search results match the criteria.'
+            raise MultipleSearchResults.new(msg, candidates: candidates, property: 'email')
           end
 
           @by_external_id[email]&.first
@@ -267,6 +239,7 @@ module Eco
 
         def init_caches
           return if @caches_init
+
           @by_id              = no_nil_key(to_h)
           @by_external_id     = no_nil_key(to_h('external_id'))
           @by_users_email     = no_nil_key(existing_users.to_h('email'))
@@ -276,15 +249,16 @@ module Eco
         end
 
         def existing_users
-          newFrom users.select {|u| !u.account_added?(:original)}
+          usrs = users.reject {|u| u.account_added?(:original)}
+          newFrom usrs
         end
 
         def no_nil_key(hash)
           hash.tap {|h| h.delete(nil)}
         end
-
-
       end
     end
   end
 end
+
+# rubocop:enable Style/Attr

data/lib/eco/api/organization.rb

@@ -10,7 +10,6 @@ require_relative 'organization/tag_tree'
 require_relative 'organization/presets_factory'
 require_relative 'organization/preferences'
 require_relative 'organization/people'
-require_relative 'organization/people_similarity'
 require_relative 'organization/person_schemas'
 require_relative 'organization/policy_groups'
 require_relative 'organization/login_providers'

data/lib/eco/api/policies/policy.rb

@@ -2,17 +2,19 @@ module Eco
   module API
     class Policies
       class Policy < Eco::API::UseCases::UseCase
-        @types = [:transform]
-        
+        TYPES = [:transform].freeze
+
         def initialize(name, type: :transform, root:, &block)
-          super(name, type: type, root: root, &block)
+          super
         end
 
         def root=(value)
-          raise "Root should be a Eco::API::Policies object. Given: #{value}" if !value.is_a?(Eco::API::Policies)
+          msg  = "Root should be a Eco::API::Policies object. "
+          msg << "Given: #{value.class}"
+          raise ArgumentError, msg unless value.is_a?(Eco::API::Policies)
+
           @root = value
         end
-
       end
     end
   end

data/lib/eco/api/policies.rb

@@ -9,21 +9,26 @@ module Eco
       attr_reader :policies
 
       def define(name, type: :transform, &block)
-        Eco::API::Policies::Policy.new(name, type: type, root: self, &block).tap do |policy|
+        Eco::API::Policies::Policy.new(
+          name,
+          type: type,
+          root: self,
+          &block
+        ).tap do |policy|
           add(policy)
         end
       end
 
       def add(policy)
-        msg = "Expected Eco::API::Policies::Policy object. Given: #{policy}"
+        msg = "Expected Eco::API::Policies::Policy object. Given: #{policy.class}"
         raise ArgumentError, msg unless policy.is_a?(Eco::API::Policies::Policy)
 
         super
       end
 
-      def launch(people:, session:, job:, options: {})
+      def launch(data:, session:, job:, options: {})
         args = {
-          people:  people,
+          data:    data,
           session: session,
           job:     job,
           options: options

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

@@ -0,0 +1,60 @@
+module Eco
+  module API
+    class Session
+      class Batch
+        class Feedback
+          module Generate
+            include Feedback::JobDependencies
+            include Feedback::RequestStat
+
+            # @!group Pure feedback methods
+
+            # 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) # rubocop:disable Metrics/AbcSize
+              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.positive?
+                      request
+                    end
+
+                    msg << sample.slice(0, sample_length).pretty_inspect
+                  end
+
+                  stats_str  = "#{'+' * 3}   "
+                  stats_str << "#{type.to_s.upcase} length: #{requests.length} "
+                  stats_str << "#{'+' * 3}  "
+                  stats_str << "STATS  (job '#{name}')  "
+                  stats_str << ('+' * 3)
+
+                  msg << ('-' * stats_str.length) if only_stats
+                  msg << stats_str
+                  msg << request_stats(requests).message.to_s
+                  msg << ('-' * stats_str.length) if only_stats
+                  msg << ('*' * header.length)    unless only_stats
+                end
+              end.join("\n")
+            end
+
+            # @!endgroup
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Eco
+  module API
+    class Session
+      class Batch
+        class Feedback
+          module Getters
+            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_to_s]
+              end
+            end
+
+            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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Eco
+  module API
+    class Session
+      class Batch
+        class Feedback
+          module Identifiers
+            def person_ref(entry)
+              row_str  = (row = get_row(entry)) ? "(row: #{row}) " : ''
+              row_str << "(id: '#{get_attr(entry, :id)}') "
+              row_str << "'#{get_attr(entry, :name)}' "
+              row_str << "('#{get_attr(entry, :external_id)}': "
+              row_str << "'#{get_attr(entry, :email)}')"
+              row_str
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Eco
+  module API
+    class Session
+      class Batch
+        class Feedback
+          module JobDependencies
+            def 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
+
+            # @see Eco::API::Session::Batch::Job#requests
+            def job_requests
+              job.requests
+            end
+
+            # @!endgroup
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Eco
+  module API
+    class Session
+      class Batch
+        class Feedback
+          module RequestStat
+            include Feedback::JobDependencies
+
+            # @!group Pure feedback methods
+
+            # @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::Feedback::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::Feedback::RequestStats.new(type: type, requests: requests)
+            end
+
+            # @!endgroup
+          end
+        end
+      end
+    end
+  end
+end