eco-helpers 2.0.14 → 2.0.19

data/lib/eco/api/common/session/helpers/prompt_user.rb

@@ -0,0 +1,34 @@
+require 'timeout'
+module Eco
+  module API
+    module Common
+      module Session
+        module Helpers
+          module PromptUser
+
+            def prompt_user(question, default:, explanation: "", timeout: nil)
+              response = if config.run_mode_remote?
+                          default
+                        else
+                          puts explanation
+                          print "#{question} "
+                          if timeout
+                            begin
+                              Timeout::timeout(timeout) { STDIN.gets.chop }
+                            rescue Timeout::Error
+                              default
+                            end
+                          else
+                            STDIN.gets.chop
+                          end
+                        end
+              return response unless block_given?
+              yield(response)
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/common/session/mailer.rb

@@ -1,5 +1,4 @@
 require 'aws-sdk-ses'
-require 'dotenv/load'
 
 module Eco
   module API

data/lib/eco/api/common/session/s3_uploader.rb

@@ -1,5 +1,4 @@
 require 'aws-sdk-s3'
-require 'dotenv/load'
 
 module Eco
   module API

data/lib/eco/api/common/session/sftp.rb

@@ -1,5 +1,4 @@
 require "net/sftp"
-require 'dotenv/load'
 
 module Eco
   module API

data/lib/eco/api/common/version_patches/ecoportal_api/external_person.rb

@@ -18,7 +18,7 @@ module Ecoportal
             entry.to_s(:identify)
           else
             str_id = id ? "id: '#{id}'; " : ""
-            "#{name}' (#{str_id}ext_id: '#{external_id}'; email: '#{email}')"
+            "'#{name}' (#{str_id}ext_id: '#{external_id}'; email: '#{email}')"
           end
         end
 

data/lib/eco/api/common/version_patches/ecoportal_api/internal_person.rb

@@ -11,12 +11,15 @@ module Ecoportal
           original_doc["account"] = JSON.parse(doc["account"])
         end
 
-        def new?
-          !initial_doc["details"] && !initial_doc["account"]
+        def new?(doc = :initial)
+          ref_doc = (doc == :original) ? original_doc : initial_doc
+          !ref_doc["details"] && !ref_doc["account"]
         end
 
-        def account_added?
-          account && !initial_doc["account"]
+        # @return [Boolean] if the account has been added, compared to `doc`
+        def account_added?(doc = :initial)
+          ref_doc = (doc == :original) ? original_doc : initial_doc
+          account && !ref_doc["account"]
         end
 
       end

data/lib/eco/api/common/version_patches/exception.rb

@@ -1,9 +1,13 @@
 class ::Exception
   def patch_full_message
-    msg = []
-    msg << "\n#{backtrace.first} \n#{message} (#{self.class.to_s})"
-    backtrace[1..-1].each_with_index {|bt, i| msg << "#{" "*8}#{i+1}: from #{bt}"}
-    msg.join("\n")
+    begin
+      msg = []
+      msg << "\n#{backtrace.first} \n#{message} (#{self.class.to_s})"
+      backtrace[1..-1].each_with_index {|bt, i| msg << "#{" "*8}#{i+1}: from #{bt}"}
+      msg.join("\n")
+    rescue Exception => e
+      puts "Something is wrong with 'patch_full_message': #{e}"
+    end
   end
 end
 

data/lib/eco/api/microcases.rb

@@ -19,7 +19,9 @@ require_relative 'microcases/people_cache'
 require_relative 'microcases/people_load'
 require_relative 'microcases/people_refresh'
 require_relative 'microcases/people_search'
-require_relative 'microcases/refresh_abilities'
+require_relative 'microcases/preserve_filter_tags'
+require_relative 'microcases/preserve_default_tag'
+require_relative 'microcases/preserve_policy_groups'
 require_relative 'microcases/set_account'
 require_relative 'microcases/set_core_with_supervisor'
 require_relative 'microcases/set_core'

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

@@ -9,7 +9,6 @@ module Eco
         unless options.dig(:exclude, :account)
           if person.account
             person.account.policy_group_ids |= entry.policy_group_ids
-            micro.refresh_abilities(person, options)
           end
         end
       end

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

@@ -9,9 +9,9 @@ module Eco
 
         start = Time.now
         people = session.batch.get_people
-        secs    = Time.now - start
+        secs    = (Time.now - start).round(3)
         cnt     = people.count
-        per_sec = (cnt.to_f / secs).floor
+        per_sec = (cnt.to_f / secs).round(2)
         logger.info("Loaded #{cnt} people in #{secs} seconds (#{per_sec} people/sec)")
 
         file   = file_manager.save_json(people, filename, :timestamp)

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

@@ -34,9 +34,9 @@ module Eco
 
           start = Time.now
           session.batch.get_people.tap do |people|
-            secs    = Time.now - start
+            secs    = (Time.now - start).round(3)
             cnt     = people.count
-            per_sec = (cnt.to_f / secs).floor
+            per_sec = (cnt.to_f / secs).round(2)
             logger.info("Loaded #{cnt} people in #{secs} seconds (#{per_sec} people/sec)")
 
             if modifier.include?(:save) && people && people.length > 0

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

@@ -21,9 +21,9 @@ module Eco
 
         start = Time.now
         entries = session.batch.get_people(people, silent: true)
-        secs    = Time.now - start
+        secs    = (Time.now - start).round(3)
         cnt     = entries.count
-        per_sec = (cnt.to_f / secs).floor
+        per_sec = (cnt.to_f / secs).round(2)
         logger.info("Re-loaded #{cnt} people (out of #{people.length}) in #{secs} seconds (#{per_sec} people/sec)")
 
         missing = people.length - entries.length

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

@@ -14,10 +14,10 @@ module Eco
 
         start = Time.now
         people = session.batch.search(data, silent: silent).yield_self do |status|
-          secs    = Time.now - start
+          secs    = (Time.now - start).round(3)
           Eco::API::Organization::People.new(status.people).tap do |people|
             cnt     = people.count
-            per_sec = (cnt.to_f / secs).floor
+            per_sec = (cnt.to_f / secs).round(2)
             msg     = "... could get #{cnt} people (out of #{data.length} entries) in #{secs} seconds (#{per_sec} people/sec)"
             session.logger.info(msg)
           end
@@ -29,10 +29,10 @@ module Eco
           session.logger.info("  Going to api get #{supers.length} current supervisors...")
           start = Time.now
           people = session.batch.search(supers, silent: silent).yield_self do |status|
-            secs    = Time.now - start
+            secs    = (Time.now - start).round(3)
             found   = status.people
             cnt     = found.count
-            per_sec = (cnt.to_f / secs).floor
+            per_sec = (cnt.to_f / secs).round(2)
             msg     = "... could find #{cnt} current supers (out of #{supers.length}) in #{secs} seconds (#{per_sec} people/sec)"
             session.logger.info(msg)
             people.merge(found, strict: micro.strict_search?(options))
@@ -46,10 +46,10 @@ module Eco
           start = Time.now
 
           people = session.batch.search(supers, silent: silent).yield_self do |status|
-            secs    = Time.now - start
+            secs    = (Time.now - start).round(3)
             found   = status.people
             cnt     = found.count
-            per_sec = (cnt.to_f / secs).floor
+            per_sec = (cnt.to_f / secs).round(2)
             msg     = "... could find #{cnt} input supers (out of #{supers.length}) in #{secs} seconds (#{per_sec} people/sec)"
             session.logger.info(msg)
             people.merge(found, strict: micro.strict_search?(options))

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

@@ -0,0 +1,23 @@
+module Eco
+  module API
+    class MicroCases
+      # Helper to preserve the original `default_tag`.
+      # @note
+      #   1. It only works if the original value of `default_tag` was **not** empty
+      # @param person [Ecoportal::API::V1::Person] the person we want to update, carrying the changes to be done.
+      # @param options [Hash] the options.
+      # @return [String] the final value of `default_tag`.
+      def preserve_default_tag(person, options)
+        if account = person.account
+          if account.as_update.key?("default_tag")
+            if original = person.original_doc.dig("account", "default_tag")
+              person.account.default_tag = original
+            end
+          end
+        end
+        person.account&.default_tag
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Eco
+  module API
+    class MicroCases
+      # Helper to preserve the original filter tags.
+      # @note
+      #   1. It only works if the original value of `filter_tags` was **not** empty
+      # @param person [Ecoportal::API::V1::Person] the person we want to update, carrying the changes to be done.
+      # @param options [Hash] the options.
+      # @param keep_new [Boolean] tells if it should keep the new tags or get rid of them.
+      # @return [Array<String>] the final value of `filter_tags`.
+      def preserve_filter_tags(person, options, keep_new: false)
+        if person.as_update.key?("filter_tags")
+          if original  = person.original_doc["filter_tags"]
+            unless original.empty?
+              if keep_new
+                person.filter_tags += original
+              else
+                person.filter_tags  = original
+              end
+            end
+          end
+        end
+        person.filter_tags
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Eco
+  module API
+    class MicroCases
+      # Helper to preserve the original `policy_group_ids`.
+      # @note
+      #   1. It only works if the original value of `policy_group_ids` was **not** empty
+      # @param person [Ecoportal::API::V1::Person] the person we want to update, carrying the changes to be done.
+      # @param options [Hash] the options.
+      # @param keep_new [Boolean] tells if it should keep the new policy groups or get rid of them.
+      # @return [String] the final value of `policy_group_ids`.
+      def preserve_policy_groups(person, options, keep_new: false)
+        if account = person.account
+          if account.as_update.key?("policy_group_ids")
+            if original = person.original_doc.dig("account", "policy_group_ids")
+              unless original.empty?
+                if keep_new
+                  person.account.policy_group_ids += original
+                else
+                  person.account.policy_group_ids  = original
+                end
+              end
+            end
+          end
+        end
+        person.account&.policy_group_ids
+      end
+
+    end
+  end
+end

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

@@ -11,7 +11,6 @@ module Eco
           person.account.send_invites = options[:send_invites] if options.key?(:send_invites)
           micro.refresh_default_tag(entry, person, options)
           micro.fix_default_group(entry, person, options)
-          micro.refresh_abilities(person, options)
         end
       end
 

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

@@ -12,16 +12,77 @@ module Eco
       # @yieldparam person [Ecoportal::API::V1::Person] the found person that matches `entry`, or a new person otherwise.
       # @return [Eco::API::Organization::People] all the people, including new and existing ones.
       def with_each(entries, people, options)
-        entries.map do |entry|
-          unless person = people.find(entry, strict: micro.strict_search?(options))
-            person = session.new_person
+        @_skip_all_multiple_results = false
+        entries.each_with_object([]) do |entry, scoped|
+          begin
+            unless person = people.find(entry, strict: micro.strict_search?(options))
+              person = session.new_person
+            end
+          rescue Eco::API::Organization::People::MultipleSearchResults => e
+            unless @_skip_all_multiple_results
+              msg    = "\n * When searching this Entry: #{entry.to_s(:identify)}"
+              person = _with_each_prompt_to_select_user(e.append_message(msg), entry: entry)
+            end
+          end
+
+          if person
+            person.entry = entry
+            yield(entry, person) if block_given?
+            scoped << person
           end
-          person.entry = entry
-          yield(entry, person) if block_given?
-          person
         end.yield_self {|all_people| people.newFrom all_people.uniq}
       end
 
+      private
+
+      def _with_each_prompt_to_select_user(error, entry: nil, increase_count: true)
+        unless error.is_a?(Eco::API::Organization::People::MultipleSearchResults)
+          raise "Expecting Eco::API::Organization::People::MultipleSearchResults. Given: #{error.class}"
+        end
+        @_with_each_prompts  = 0 unless instance_variable_defined?(:@_with_each_prompts)
+        @_with_each_prompts += 1 if increase_count
+
+        lines = []
+        lines << "\n(#{@_with_each_prompts}) " + error.to_s + "\n"
+        lines << "  #index   - Select the correct person by its number index among the list above."
+        lines << "  (I)      - Just Skip/Ignore this one. I will deal with that input entry in another launch."
+        lines << "  (A)      - Ignore all the rest of input entries with this problem."
+        lines << "  (C)      - Create a new person."
+        lines << "  (B)      - Just break this script. I need to change the input file :/"
+
+        prompt_user("Type one option (#number/I/A/C/B):", explanation: lines.join("\n"), default: "I") do |res|
+          res = res.upcase
+          case
+          when res.start_with?("I")
+            logger.info "Ignoring entry... #{entry.to_s(:identify) if entry}"
+            nil
+          when res.start_with?("A")
+            logger.info "All input entries with this same issue will be ignored for this launch"
+            @_skip_all_multiple_results = true
+            nil
+          when res.start_with?("C")
+            logger.info "Creating new person...#{"for entry #{entry.to_s(:identify)}" if entry}"
+            session.new_person
+          when res.start_with?("B")
+            raise error
+          when res && !res.empty? && (pos = res.to_i rescue nil) && (pos < error.candidates.length)
+            error.candidate(pos).tap do |person|
+              logger.info "Thanks!! You selected #{person.identify}"
+              sleep(1.5)
+            end
+          else
+            if pos.is_a?(Numeric) && (pos >= error.candidates.length)
+              print "#{pos} is not a number in the range. "
+            else
+              print "#{res} is not an option. "
+            end
+            puts "Please select one of the offered options..."
+            sleep(1)
+            _with_each_prompt_to_select_user(error, increase_count: false, entry: entry)
+          end
+        end
+      end
+
     end
   end
 end

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

@@ -15,8 +15,10 @@ module Eco
       def with_each_present(entries, people, options, log_starter: false)
         found = []
         micro.with_each(entries, people, options) do |entry, person|
-          if person.new? && log_starter
-            session.logger.error("This person does not exist: #{entry.to_s(:identify)}")
+          if person.new?
+            if log_starter
+              session.logger.error("This person does not exist: #{entry.to_s(:identify)}")
+            end
             next
           end
           found << person

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

@@ -15,8 +15,10 @@ module Eco
       def with_each_starter(entries, people, options, log_present: false)
         starters = []
         micro.with_each(entries, people, options) do |entry, person|
-          if !person.new? && log_present
-            session.logger.error("This person (id: '#{person.id}') already exists: #{entry.to_s(:identify)}")
+          if !person.new?
+            if log_present
+              session.logger.error("This person (id: '#{person.id}') already exists: #{entry.to_s(:identify)}")
+            end
             next
           end
           starters << person

data/lib/eco/api/organization.rb

@@ -9,6 +9,7 @@ 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/organization/people.rb

@@ -2,6 +2,43 @@ 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
+
         # build the shortcuts of Collection
         attr_presence :account, :details
         attr_collection :id, :external_id, :email, :name, :supervisor_id
@@ -78,34 +115,36 @@ module Eco
         # @!group Searchers
 
         # It searches a person using the parameters given.
+        # @note This is how the search function actually works:
+        #   1. if eP `id` is given, returns the person (if found), otherwise...
+        #   2. if `external_id` is given, returns the person (if found), otherwise...
+        #   3. if `strict` is `false` and `email` is given:
+        #     - if there is only 1 person with that email, returns that person, otherwise...
+        #     - if found but, there are many candidates, it raises MultipleSearchResults error
+        #     - if person `external_id` matches `email`, returns that person
+        # @raise MultipleSearchResults if there are multiple people with the same `email`
+        #   and there's no other criteria to find the person. It only gets to this point if
+        #   `external_id` was **not** provided and we are **not** in 'strict' search mode.
+        #   However, it could be we were in `strict` mode and `external_id` was not provided.
         # @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
-          pers = @by_id[id]&.first if id
-          pers = @by_external_id[external_id&.strip]&.first       if !pers && !external_id.to_s.strip.empty?
-
-          # strict prevents taking existing user for searched person with same email
-          # specially useful if the organisation ensures all have external id (no need for email search)
-          if !pers && (!strict || external_id.to_s.strip.empty?)
-            # person still not found and either not strict or no external_id provided
-            pers = @by_users_email[email&.downcase.strip]&.first  if !email.to_s.strip.empty?
-
-            if !pers && !strict && !email.to_s.strip.empty?
-              candidates = @by_non_users_email[email&.downcase.strip] || []
-              raise "Too many non-user candidates (#{candidates.length}) with email '#{email}'" if candidates.length > 1
-              pers = candidates.first
-            end
-
-            pers = @by_external_id[email&.downcase.strip]&.first    if !pers && !email.to_s.strip.empty?
-          end
-
+          # normalize values
+          ext_id   = !external_id.to_s.strip.empty? && external_id.strip
+          email    = !email.to_s.strip.empty? && email.downcase.strip
+
+          pers   = nil
+          pers ||= @by_id[id]&.first
+          pers ||= @by_external_id[ext_id]&.first
+          pers ||= person_by_email(email) unless strict && ext_id
           pers
         end
 
+        # @see Eco::API::Organization::People#person
         def find(object, strict: false)
           id          = attr_value(object, "id")
           external_id = attr_value(object, "external_id")
@@ -176,6 +215,12 @@ module Eco
         end
         # @!endgroup
 
+        # @!group Helper methods
+        def analytics
+          Eco::API::Organization::PeopleAnalytics.new(self.to_a)
+        end
+        # @!endgroup
+
         protected
 
         def on_change
@@ -184,15 +229,46 @@ module Eco
 
         private
 
+        def person_by_email(email, prevent_duplicates: true)
+          return nil unless email
+
+          candidates  = @by_non_users_email[email] || []
+          email_users = @by_users_email[email]     || []
+
+          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")
+          end
+
+          @by_external_id[email]&.first
+        end
+
         def init_caches
           return if @caches_init
           @by_id              = to_h
-          @by_external_id     = to_h('external_id')
-          @by_users_email     = users.to_h('email')
-          @by_non_users_email = non_users.to_h('email')
+          @by_external_id     = no_nil_key(to_h('external_id'))
+          @by_users_email     = no_nil_key(existing_users.to_h('email'))
+          @by_non_users_email = no_nil_key(non_users.to_h('email'))
+          @by_email           = no_nil_key(to_h('email'))
           @caches_init = true
         end
 
+        def existing_users
+          newFrom users.select {|u| !u.account_added?(:original)}
+        end
+
+        def no_nil_key(hash)
+          hash.tap {|h| h.delete(nil)}
+        end
+
+
       end
     end
   end