eco-helpers 2.0.13 → 2.0.18

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/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_analytics'
 require_relative 'organization/person_schemas'
 require_relative 'organization/policy_groups'
 require_relative 'organization/login_providers'

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

@@ -176,6 +176,12 @@ module Eco
         end
         # @!endgroup
 
+        # @!group Helper methods
+        def analytics
+          Eco::API::Organization::PeopleAnalytics.new(self.to_a)
+        end
+        # @!endgroup
+
         protected
 
         def on_change
@@ -190,6 +196,7 @@ module Eco
           @by_external_id     = to_h('external_id')
           @by_users_email     = users.to_h('email')
           @by_non_users_email = non_users.to_h('email')
+          @by_email           = to_h('email')
           @caches_init = true
         end
 

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

@@ -0,0 +1,60 @@
+module Eco
+  module API
+    module Organization
+      class PeopleAnalytics <  Eco::API::Organization::People
+        include Eco::Data::FuzzyMatch
+
+        # @!group Helpers
+
+        # @!endgroup
+
+        # @!group Searchers
+
+        # It gathers those that have the same `email`
+        # @return [Hash] where `keys` are `email`s and `values` an `Array<Person>`
+        def repeated_emails
+          init_caches
+          @by_email.select do |email, people|
+            people.count > 1
+          end
+        end
+
+        # @!endgroup
+
+        # @!group Analysers
+
+        # TODO: Sort results by `results.first.methods`
+        def similarity(**options)
+          each_with_object({}) do |person, results|
+            results[person.id] = find_all_with_score(person, **options)
+          end
+        end
+
+
+        def print_analysis(threshold)
+          similarity.each do |id, results|
+            msg = results.results.select do |result|
+              result.threshold?(threshold)
+            end.map do |result|
+              result.print
+            end.join("\n  ")
+
+            puts "'#{self[id].identify}':\n  " + msg
+          end
+        end
+        # @!endgroup
+
+        protected
+
+        def on_change
+          remove_instance_variable(@fuzzy_match)
+          super
+        end
+
+        private
+
+
+      end
+    end
+  end
+end

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

@@ -4,112 +4,58 @@ module Eco
 
       class PresetsFactory
         ABILITIES = File.join(__dir__, 'presets_values.json')
-        DEFAULT_CUSTOM = 'presets_custom.json'
-        DEFAULT_MAP    = 'presets_map.json'
+        INTEGRITY = File.join(__dir__, 'presets_integrity.json')
 
-        def initialize(presets_custom: DEFAULT_CUSTOM, presets_map: DEFAULT_MAP, enviro: nil, policy_groups: nil)
-          @abilities  = JSON.load(File.open(ABILITIES))
-          @habilities = @abilities.map do |key, values|
-            h_values = values.map { |v| [v, true] }.to_h
-            [key, h_values]
-          end.to_h
+        class << self
 
-          fatal("Expecting Environment object. Given: #{enviro}") if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
-          @enviro = enviro
+          def all_abilities(hash = {})
+            Hash[abilities.each_with_object(nil).to_a].merge(hash)
+          end
 
-          policy_groups = policy_groups || @enviro&.api&.policy_groups.to_a
-          if policy_groups.is_a?(Eco::API::Organization::PolicyGroups)
-            @policy_groups = policy_groups
-          else
-            @policy_groups = Eco::API::Organization::PolicyGroups.new(policy_groups)
+          def abilities_model
+            @abilities_model ||= JSON.load(File.open(ABILITIES))
           end
 
-          init_custom(presets_custom)
-          init_map(presets_map)
-        end
+          def integrity_model
+            @integrity_model ||= JSON.load(File.open(INTEGRITY))
+          end
 
-        def new(*policy_group_ids_or_names)
+          def abilities
+            @abilities ||= abilities_model.keys
+          end
 
-          names = policy_group_ids_or_names.map do |id_name|
-            @policy_groups.to_name(id_name)&.downcase
-          end.compact
+        end
 
-          if @presets_map
-            preset_names = names.map { |name| @presets_map.fetch(name, nil) }
-          else # option to do not use preset mapping (so just the policy group name)
-            preset_names = names
-          end
-          compile(*preset_names)
+        def initialize(enviro: nil, policy_groups: nil)
+          fatal("Expecting Environment object. Given: #{enviro}") if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
+          @enviro        = enviro
+          @policy_groups = policy_groups
         end
 
         # @return [Array<String>] all the abilities
         def keys
-          @abilities.keys
+          self.class.abilities
         end
 
-        private
-
-        def init_custom(file = DEFAULT_CUSTOM)
-          @presets_custom = nil
-
-          return if !file
-          file = File.expand_path(file)
-
-          if File.exists?(file)
-            @presets_custom = JSON.load(File.open(file))
-
-            errors = @presets_custom.map do |key, preset|
-              (err = preset_errors(preset)) ? "{ '#{key}' preset -> #{err}}": nil
-            end.compact
-
-            fatal("File '#{file}' contains invalid presets:\n  #{errors.join("\n  ")}") if errors.length > 0
-          end
-
+        def valid?(preset)
+          validate(perset).length == 0
         end
 
-        def init_map(file = DEFAULT_MAP)
-          @presets_map = nil
-
-          return if !file
-          file = File.expand_path(file)
-
-          if File.exists?(file)
-            fatal("Maps file specified without custom presets file. Aborting!") if !@presets_custom
-            @presets_map = JSON.load(File.open(file))
-
-            errors = []
-            if @policy_groups.length > 0
-              errors = @policy_groups.map do |pg|
-                exists = @presets_map[pg.name.downcase] || @presets_custom[pg.name.downcase]
-                exists ? nil : "'#{pg.name}'"
-              end.compact
-
-              warn("No maps or no preset for policy group(s): #{errors.join(", ")}") if errors.length > 0
+        def validate(preset)
+          [].tap do |errors|
+            if err = preset_errors(preset)
+              errors << "{ '#{key}' preset -> #{err}}"
+            end
+            if err = preset_integrity(preset)
+              errors << "{ '#{key}' preset -> #{err}}"
             end
-
-            errors = @presets_map.map do |source, dest|
-              @presets_custom[dest] ? nil : "'#{dest}'"
-            end.compact
-
-            warn("Unexisting mapped preset(s): #{errors.uniq.join(", ")}") if errors.length > 0
           end
-
-        end
-
-        def fatal(msg)
-          raise msg if !@enviro
-          @enviro.logger.fatal(msg)
-          raise msg
         end
 
-        def warn(msg)
-          raise msg if !@enviro
-          @enviro.logger.warn(msg)
-        end
+        private
 
-        def compile(*preset_names)
-          fatal("You need to specify an existing file for the custom presets.") if !@presets_custom
-          @presets_custom.values_at(*preset_names).compact.reduce({}) do |p1, p2|
+        def compile(*presets)
+          presets.compact.reduce({}) do |p1, p2|
             merge(p1, p2)
           end
         end
@@ -117,7 +63,7 @@ module Eco
         def merge(preset1, preset2)
           keys = preset1.keys | preset2.keys
 
-          @abilities.each_with_object({}) do |(key, values), result|
+          abilities_model.each_with_object({}) do |(key, values), result|
             next unless keys.include?(key)
             idx = [
               values.index(preset1[key]),
@@ -127,19 +73,96 @@ module Eco
           end
         end
 
-        # unsused: only play with the given abilities
-        def empty_model
-          JSON.parse(@abilities.to_json).transform_values {|v| nil }
-        end
-
         def preset_errors(preset)
           return "No preset given" if !preset
           errors = preset.map do |k, v|
-            @habilities.dig(k, v) ? nil : "#{k}:#{v}"
+            value_exists?(k, v) ? nil : "#{k}:#{v}"
           end.compact
-          return " unknown: {#{errors.join(", ")}}" if errors.length > 0
+          return " Unknown: {#{errors.join(", ")}}" if errors.length > 0
           nil
         end
+
+        def preset_integrity(preset)
+          preset.each_with_object([]) do |(ability, value), errors|
+            next unless checks = integrity_model[ability]
+
+            suberrors = []
+
+            checks.each do |check|
+              next unless check["value"] == value
+              check["conditions"].each do |cond, targets|
+                case cond
+                when "at_least"
+                  targets.each do |other, minimum|
+                    unless (ability_value_idx(other, minimum) <= ability_value_idx(other, preset[other]))
+                      suberrors << "'#{other}' should be at least '#{minimum}'"
+                    end
+                  end
+                when "one_of"
+                  unless targets.any? {|other, expected| preset[other] == expected}
+                    suberrors << targets.each_with_object([]) do |(other, expected), out|
+                      out << "'#{other}': '#{expected}'"
+                    end.join(", ").yield_self do |msg|
+                      "there should be at least one of: {#{msg}}"
+                    end
+                  end
+                else
+                  warn("Unsuported integrity condition statement '#{cond}' in '#{ability}' with level '#{value}'")
+                end
+              end
+            end
+
+            if suberrors.length > 0
+              errors << "Incorrect value '#{value}' for '#{ability}' - reasons: {#{suberrors.join(", ")}}"
+            end
+          end.yield_self do |errors|
+            " Integrity errors: { #{errors.join(", ")} }" if errors.length > 0
+          end
+        end
+
+        def integrity_model
+          self.class.integrity_model
+        end
+
+        def value_exists?(ability, value)
+          abilities_model_inverted.dig(ability, value)
+        end
+
+        def abilities_model_inverted
+          @abilities_model_inverted ||= abilities_model.each_with_object({}) do |(key, values), out|
+            out[key] = values.each_with_object({}) {|v, h| h[v] = true }
+          end
+        end
+
+        def ability_value_idx(ability, value)
+          abilities_model[ability].index(value) || -1
+        end
+
+        def abilities_model
+          self.class.abilities_model
+        end
+
+        def policy_groups
+          return @policy_groups if @policy_groups.is_a?(Eco::API::Organization::PolicyGroups)
+          @policy_groups ||= @enviro&.api&.policy_groups.to_a
+
+          unless @policy_groups.is_a?(Eco::API::Organization::PolicyGroups)
+            @policy_groups = Eco::API::Organization::PolicyGroups.new(@policy_groups)
+          end
+          @policy_groups
+        end
+
+        def fatal(msg)
+          raise msg if !@enviro
+          @enviro.logger.fatal(msg)
+          raise msg
+        end
+
+        def warn(msg)
+          raise msg if !@enviro
+          @enviro.logger.warn(msg)
+        end
+
       end
 
     end