eco-helpers 3.0.20 → 3.0.22

data/lib/eco/api/microcases/people/preserve/policy_groups.rb

@@ -0,0 +1,36 @@
+module Eco
+  module API
+    class MicroCases
+      module People
+        module Preserve
+          module PolicyGroups
+            # 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)
+              return unless (account = person.account)
+
+              account.policy_group_ids.tap do
+                next unless account.as_update.key?('policy_group_ids')
+                next unless (original = person.original_doc.dig('account', 'policy_group_ids'))
+                next if original.empty?
+
+                if keep_new
+                  person.account.policy_group_ids += original
+                else
+                  person.account.policy_group_ids  = original
+                end
+
+                return account.policy_group_ids
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/microcases/people/preserve.rb

@@ -0,0 +1,17 @@
+require_relative 'preserve/filter_tags'
+require_relative 'preserve/default_tag'
+require_relative 'preserve/policy_groups'
+
+module Eco
+  module API
+    class MicroCases
+      module People
+        module Preserve
+          include FilterTags
+          include DefaultTag
+          include PolicyGroups
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require_relative 'people/manage'
+require_relative 'people/fetch'
+require_relative 'people/apply_changes'
+require_relative 'people/preserve'
+require_relative 'people/integrity'
+require_relative 'people/macro'
+
+module Eco
+  module API
+    class MicroCases
+      module People
+        include Manage
+        include Fetch
+        include ApplyChanges
+        include Preserve
+        include Integrity
+        include Macro
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module Eco
       # @param context [String] main part of the message.
       # @param reason [String] why are we updating now.
       # @return [Boolean] `true` if it succeded to update, and `false` otherwise
-      def person_update!(person, context: "Session", reason: "")
+      def person_update!(person, context: 'Session', reason: '')
         log(:debug) {
           "#{context}, going to \"#{reason}\".\nPerson: #{person_ref(person)}"
         }

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

@@ -17,7 +17,7 @@ module Eco
             filenames = []
             case pattern
             when Regexp
-              Dir.entries(".").sort.each do |file|
+              Dir.entries('.').sort.each do |file|
                 next unless File.file?(file) # Skip directories
                 filenames.push(file) if file =~ pattern
               end

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

@@ -0,0 +1,40 @@
+module Eco
+  module API
+    class MicroCases
+      # Finds those in `entries` that already exist in the organization (`people`)
+      # and `yield` s them one by one to the given block.
+
+      # @param entries [Eco::API::Common::ContractorEntities::Entries]: the input entries with the data.
+      # @param contractors [Eco::API::Organization::Contractors]: target existing _Contractors_ of the current update.
+      # @param options [Hash]: the options.
+      # @param log_new_record [Boolean]: log error message if an `entry` does not have match in `contractors`.
+      # @yield [entry, contractor]: yields the existing `contractor` elements from `entries`
+      #        that are not included on the `contractors` list.
+      # @yield[:entry] [ContractorEntry]: the input entry with the data that should be used to update the contractor with.
+      # @yield[:contractor] [Ecoportal::API::V1::Contractor]: individual element from the collection of found `contractors`
+
+      # @return [Eco::API::Organization::Contractors]: the contractor collection found by the query.
+
+
+      def with_each_contractor_present(entries, contractors, options, log_new_record: false)
+        found = []
+        micro.with_each(entries, contractors, options) do |entry, contractor|
+          if contractor.new?
+            if log_new_record
+              log(:error) {
+                "This contractor does not exist: #{entry.to_s(:identify)}"
+              }
+            end
+
+            next
+          end
+
+          found << contractor
+          yield(entry, contractor) if block_given?
+        end
+
+        contractors.newFrom found
+      end
+    end
+  end
+end

data/lib/eco/api/microcases.rb

@@ -1,6 +1,9 @@
 module Eco
   module API
     class MicroCases < Eco::API::Common::Session::BaseSession
+      require_relative 'microcases/people'
+      include People
+
       def micro
         self
       end
@@ -8,30 +11,7 @@ module Eco
   end
 end
 
-require_relative 'microcases/account_excluded'
 require_relative 'microcases/append_usergroups'
-require_relative 'microcases/core_excluded'
-require_relative 'microcases/fix_default_group'
-require_relative 'microcases/fix_filter_tags'
-require_relative 'microcases/people_cache'
-require_relative 'microcases/people_load'
-require_relative 'microcases/people_refresh'
-require_relative 'microcases/people_search'
 require_relative 'microcases/person_update'
-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'
-require_relative 'microcases/refresh_default_tag'
 require_relative 'microcases/s3upload_targets'
-require_relative 'microcases/set_supervisor'
 require_relative 'microcases/strict_search'
-require_relative 'microcases/take_email_from_account'
-require_relative 'microcases/with_each'
-require_relative 'microcases/with_each_leaver'
-require_relative 'microcases/with_each_present'
-require_relative 'microcases/with_each_starter'
-require_relative 'microcases/with_each_subordinate'
-require_relative 'microcases/with_supervisor'

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

@@ -0,0 +1,48 @@
+module API
+  module Organization
+    class People
+      # 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 = '(no account)'
+            if person.account
+              msg = '(user)'
+              msg = '(new user)' if person.account_added?
+            end
+
+            "#{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
+    end
+  end
+end

data/lib/eco/api/organization/{people_similarity.rb → people/similarity.rb}

@@ -1,20 +1,15 @@
-module Eco
-  module API
-    module Organization
-
+module API
+  module Organization
+    class People
       # Class to find out duplicates in the People Manager
       #
       # @attr_writer attribute [String, Proc, nil] the target attribute to be read.
-      class PeopleSimilarity <  Eco::API::Organization::People
+      class Similarity < Eco::API::Organization::People
         include Eco::Data::FuzzyMatch
 
-        attr_accessor :attribute
-
         # @!group Config
         # @return [String, Proc, nil] the target attribute to be read.
-        def attribute=(attr)
-          @attribute = attr
-        end
+        attr_writer :attribute
 
         def attribute
           @attribute ||= :name
@@ -22,36 +17,35 @@ module Eco
 
         # Returns the target value to analyse
         # @param person [Ecoportal::API::V1::Person]
-        def item_value(person)
-          return attr.call(item) if attribute.is_a?(Proc)
+        def item_value(item)
+          return attribute.call(item) if attribute.is_a?(Proc)
+
           attr = attribute.to_sym
-          return item.send(attr) if item.respond_to?(attr)
+          item.send(attr) if item.respond_to?(attr)
         end
 
         # Define the order or relevant of per user matches
-        # @param values[Array<Symbol>] the algorithms' results it should be ordered by
-        #   * Possible values: `:dice`, `:levenshtein`, `:jaro_winkler`, `:ngrams`, `:words_ngrams`, `:chars_position`
-        def order=(values)
-          @order = values
-        end
+        # @param values[Array<Symbol>] the algorithms' results it should
+        #   be ordered by:
+        #   * Possible values: `:dice`, `:levenshtein`, `:jaro_winkler`,
+        #     `:ngrams`, `:words_ngrams`, `:chars_position`
+        attr_writer :order
 
         def order
-          @order ||= [:words_ngrams, :dice]
+          @order ||= %i[words_ngrams dice]
         end
 
         # Define the order or relevant of per user matches
         # @param value [Float] the threshold that all of the algorithms should comply with
-        def threshold=(value)
-          @threshold = value
-        end
+        attr_writer :threshold
 
         def threshold
           @threshold ||= 0.15
         end
 
         # Generates a new object with same config but different base `data`.
-        # @return [Eco::API::Organization::PeopleSimilarity]
-        def newFrom(data)
+        # @return [Eco::API::Organization::People::Similarity]
+        def newFrom(data) # rubocop:disable Naming/MethodName
           super(data).tap do |simil|
             simil.threshold = threshold
             simil.order     = order
@@ -67,47 +61,47 @@ module Eco
         # @return [Hash] where `keys` are `email`s and `values` an `Array<Person>`
         def repeated_emails
           init_caches
-          @by_email.select do |email, people|
+          @by_email.select do |_email, people|
             people.count > 1
           end
         end
 
         # It returns all people with no name
-        # @return [Eco::API::Organization::PeopleSimilarity]
+        # @return [Eco::API::Organization::People::Similarity]
         def unnamed
           select do |person|
             person.name.to_s.strip.length < 2
-          end.yield_self do |results|
+          end.then do |results|
             newFrom(results)
           end
         end
 
         # It returns all people with no name
-        # @return [Eco::API::Organization::PeopleSimilarity]
+        # @return [Eco::API::Organization::People::Similarity]
         def named
           reject do |person|
             person.name.to_s.strip.length < 2
-          end.yield_self do |results|
+          end.then do |results|
             newFrom(results)
           end
         end
 
         # It returns all the entries with `attribute` empty
-        # @return [Eco::API::Organization::PeopleSimilarity]
+        # @return [Eco::API::Organization::People::Similarity]
         def blank_attribute
           select do |person|
             item_value(person).to_s.strip.length < 2
-          end.yield_self do |results|
+          end.then do |results|
             newFrom(results)
           end
         end
 
         # It returns all the entries with `attribute` **n0t** empty
-        # @return [Eco::API::Organization::PeopleSimilarity]
+        # @return [Eco::API::Organization::People::Similarity]
         def attribute_present
           reject do |person|
             item_value(person).to_s.strip.length < 2
-          end.yield_self do |results|
+          end.then do |results|
             newFrom(results)
           end
         end
@@ -117,19 +111,26 @@ module Eco
         # @!group Analisys starters
 
         # Analyses People bases on `options`
-        # @param needle_read [Proc, Symbol] when the value to read from `needle` object is different to the `:read` (`attribute`).
-        #   This allows to for example, facet `needle.name` (needle_read) against `haystack_item.details[alt_id]` (read).
-        # @param keep_empty [Boolean] to indicate if it should get rid of people with no results (based on threshold)
-        # @return [Hash] where the _keys_ are the people `id`s and the _values_ the `Eco::Data::FuzzyMatch::Results`
+        # @param needle_read [Proc, Symbol] when the value to
+        #   read from `needle` object is different to the `:read` (`attribute`).
+        #   This allows to for example, facet `needle.name` (needle_read)
+        #     against `haystack_item.details[alt_id]` (read).
+        # @param keep_empty [Boolean] to indicate if it should get
+        #   rid of people with no results (based on threshold)
+        # @return [Hash] where the _keys_ are the people `id`s and
+        #   the _values_ the `Eco::Data::FuzzyMatch::Results`
         def analyse(needle_read: nil, keep_empty: false, **options)
-          options = { read: self.attribute }.merge(options)
-          total = count; i = 1
+          options = { read: attribute }.merge(options)
+          total   = count
+          i       = 1
+
           each_with_object({}) do |person, results|
             needle_str = needle_read ? item_string(person, needle_read) : nil
             results[person.id] = find_all_with_score(person, needle_str: needle_str, **options)
-            print_progress("Analysed", total, i)
+
+            print_progress('Analysed', total, i)
             i += 1
-          end.yield_self do |analysed|
+          end.then do |analysed|
             analysed = clean_empty(analysed) unless keep_empty
             #puts "... #{analysed.count} results after cleaning empty"
             analysed
@@ -142,24 +143,28 @@ module Eco
 
         # Gets a new instance object of this class, with only people in results
         # @param analysed [Hash] where the _keys_ are the people `id`s and _values_ the `Eco::Data::FuzzyMatch::Results`
-        # @return [Eco::API::Organization::PeopleSimilarity]
-        def newSimilarity(analysed)
+        # @return [Eco::API::Organization::People::Similarity]
+        def newSimilarity(analysed) # rubocop:disable Naming/MethodName
           newFrom(people_in_results(analysed))
         end
 
         def people_in_results(analysed)
           analysed.each_with_object([]) do |(id, results), people|
-            related = results.each_with_object([self[id]]) do |result, related|
+            # spot related
+            results.each_with_object([self[id]]) do |result, related|
               related << result.match
+            end.each do |person|
+              next if people.include?(person)
+
+              people << person
             end
-            related.each {|person| people << person unless people.include?(person)}
           end
         end
 
         # Removes from results those that do not have similar entries
         def clean_empty(analysed)
-          analysed.select do |id, results|
-            !results.empty?
+          analysed.reject do |_id, results|
+            results.empty?
           end
         end
 
@@ -169,10 +174,12 @@ module Eco
         def with_analysed(analysed, keep_empty: false)
           analysed.each_with_object({}) do |(id, results), reanalysed|
             reanalysed[id] = yield(self[id], results)
-          end.yield_self do |reanalysed|
+          end.then do |reanalysed|
             reanalysed = clean_empty(reanalysed) unless keep_empty
             reanalysed
-          end.tap {|out| "with_analysed... returns #{out.count} records"}
+          end.tap do |out|
+            puts "with_analysed... returns #{out.count} records"
+          end
         end
 
         # Launches a reanalyis on `analysed` based on `options`
@@ -184,10 +191,12 @@ module Eco
         end
 
         # Reanalyses by using a block to treat the needle and item values
-        def reanalyse(analysed, msg: "Reanalysing", **options, &block)
-          options = { read: self.attribute }.merge(options)
-          total = analysed.count; i = 1
-          with_analysed(analysed) do |person, results|
+        def reanalyse(analysed, msg: 'Reanalysing', **options, &block)
+          options = { read: attribute }.merge(options)
+          total   = analysed.count
+          i       = 1
+
+          with_analysed(analysed) do |_person, results|
             print_progress(msg, total, i)
             i += 1
             recalculate_results(results, &block)
@@ -196,18 +205,21 @@ module Eco
 
         # Renalyses by ignoring matching words between the `needle` and those found in `results`
         def ignore_matching_words(analysed, **options)
-          prompt = "Reanalysing by ignoring matching words"
-          reanalyse(analysed, msg: prompt, **options) do |needle_str, item_str, needle, item|
+          prompt = 'Reanalysing by ignoring matching words'
+
+          reanalyse(analysed, msg: prompt, **options) do |needle_str, item_str, _needle, _item|
             self.class.remove_matching_words(needle_str, item_str)
           end
         end
 
         # Renalyses by ignoring matching words between the `needle` and those found in `results`
         def ignore_matching_words_old(analysed, **options)
-          options = { read: self.attribute }.merge(options)
-          total = analysed.count; i = 1
+          options = { read: attribute }.merge(options)
+          total   = analysed.count
+          i       = 1
+
           with_analysed(analysed) do |person, results|
-            print_progress("Reanalysing by ignoring matching words", total, i)
+            print_progress('Reanalysing by ignoring matching words', total, i)
             i += 1
             ignore_same_words_score(results, **options)
           end
@@ -219,11 +231,12 @@ module Eco
 
         # @return [String] well structured text
         def report(analysed, format: :txt)
-          case
-          when format == :txt
-            analysed.each_with_object("") do |(id, results), out|
-              msg = results.results.map {|r| r.print}.join("\n  ")
-              out << "#{self[id].identify}:\n  " + msg + "\n"
+          case format
+          when :txt
+            analysed.each_with_object('') do |(id, results), out|
+              out << "#{self[id].identify}:\n  "
+              out << results.results.map(&:print).join("\n  ")
+              out << "\n"
             end
           end
         end
@@ -233,7 +246,9 @@ module Eco
         #   2. It then re-sorts and cuts based on `options`
         # @return [Hash] where the _keys_ are the people `id`s and the _values_ the `Eco::Data::FuzzyMatch::Results`
         def print_analysis(**options)
-          analysed = options[:analysed] || results_with_false_positives.analyse(**options)
+          analysed   = options[:analysed]
+          analysed ||= results_with_false_positives.analyse(**options)
+
           analysed.each_with_object({}) do |(id, results), out|
             puts report(analysed)
           end
@@ -250,22 +265,24 @@ module Eco
         private
 
         def print_progress(msg, total, num)
-          return unless total > 10
-          puts "" unless num > 1
+          return  unless total > 10
+          puts '' unless num > 1
+
           @print_msg_len ||= 0
           percent = (100 * num.to_f / total).round(1)
           msg     = "  #{msg}: #{percent}% (#{num} of #{total})\r"
           @print_msg_len = msg.length unless @print_msg_len > msg.length
+
           print msg
           $stdout.flush
-          if percent > 99.9
-            sleep(0.2)
-            print "#{" " * @print_msg_len}\r"
-            $stdout.flush
-          end
-        end
 
+          return unless percent > 99.9
 
+          sleep(0.2)
+          print "#{' ' * @print_msg_len}\r"
+          $stdout.flush
+          nil
+        end
       end
     end
   end