eco-helpers 2.0.18 → 2.0.19

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

@@ -0,0 +1,112 @@
+module Eco
+  module API
+    module Organization
+
+      # 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
+        include Eco::Data::FuzzyMatch
+
+        attr_accessor :attribute
+
+        # @!group Config
+        # @return [String, Proc, nil] the target attribute to be read.
+        def attribute=(attr)
+          @attribute ||= "name"
+        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
+
+        def order
+          @order ||= [: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
+
+        def threshold
+          @threshold ||= 0.15
+        end
+
+        # @!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
+
+        # Analyses People bases on `options`
+        # @return [Hash] where the _keys_ are the people `id`s and the _values_ the `Eco::Data::FuzzyMatch::Results`
+        def analyse(**options)
+          options = { read: self.attribute }.merge(options)
+          each_with_object({}) do |person, results|
+            results[person.id] = find_all_with_score(person, **options)
+          end
+        end
+
+        # Launches a reanalyis on `analysed` based on `options`
+        # @param analysed [Hash] where the _keys_ are the people `id`s and the _values_ the `Eco::Data::FuzzyMatch::Results`
+        def re_analyse(analysed, **options)
+          analysed.each_with_object({}) do |(id, results), out|
+            out[id] = results.relevant_results(**options)
+          end
+        end
+
+        # @!group Helpers
+
+        # @return [String] well structured text
+        def analysis(analysed, format: :txt)
+          case
+          when format == :txt
+            analysed.each_with_object("") do |(id, results), out|
+              msg = results.results.map {|r| r.print}.join("\n  ")
+              "'#{self[id].identify}':\n  " + msg
+            end
+          end
+        end
+
+        # @note
+        #   1. Unless `:analysed` is provided, it launches an analysis cutting with Jaro Winker min 0.5
+        #   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.each_with_object({}) do |(id, results), out|
+            puts analysis(analysed)
+          end
+        end
+        # @!endgroup
+
+        protected
+
+        def on_change
+          remove_instance_variable(@fuzzy_match)
+          super
+        end
+
+        private
+
+
+      end
+    end
+  end
+end

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

@@ -28,7 +28,11 @@ module Eco
         end
 
         def schema(id_name)
-          @by_id.fetch(schema_id(id_name), nil)
+          self[id_name]
+        end
+
+        def [](id_name)
+          @by_id[schema_id(id_name)]
         end
 
         private

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

@@ -44,7 +44,11 @@ module Eco
         end
 
         def policy_group(id_name)
-          @by_id.fetch(policy_group_id(id_name), nil)
+          self[id_name]
+        end
+
+        def [](id_name)
+          @by_id[policy_group_id(id_name)]
         end
 
         def user_pg_ids(initial: [], final: [], non_custom: (non_custom_not_used = true; []), preserve_custom: true)

data/lib/eco/api/session.rb

@@ -74,12 +74,15 @@ module Eco
       def entry_factory(schema: nil)
         schema = to_schema(schema) || self.schema
         return @entry_factories[schema&.id] if @entry_factories.key?(schema&.id)
+        unless @entry_factories.empty?
+          @entry_factories[schema&.id] = @entry_factories.values.first.newFactory(schema: schema)
+          return @entry_factories[schema&.id]
+        end
 
         mappings = []
         if map_file = config.people.fields_mapper
           mappings = map_file ? file_manager.load_json(map_file) : []
         end
-
         @entry_factories[schema&.id] = Eco::API::Common::People::EntryFactory.new(
           enviro,
           schema:        schema,
@@ -127,7 +130,7 @@ module Eco
       # @see Eco::API::Common::People::EntryFactory#new
       # @return [Eco::API::Common::People::PersonEntry] parsed entry.
       def new_entry(data, dependencies: {})
-        entry_factory.new(data, dependencies: dependencies)
+        entry_factory(schema: data&.details&.schema_id).new(data, dependencies: dependencies)
       end
 
       # @see Eco::API::Common::People::EntryFactory#entries

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

@@ -136,11 +136,13 @@ module Eco
             block.call
           rescue error_type => e
             raise unless retries_left > 0
-            print "Batch TimeOut. You have #{retries_left} retries left. Do you want to retry (y/N)? "
-            if (res = STDIN.gets.chomp) && res[0].downcase == "y"
-              offer_retry_on(error_type, retries_left - 1, &block)
-            else
-              raise
+            explanation = "Batch TimeOut. You have #{retries_left} retries left."
+            prompt_user("Do you want to retry (y/N)?", explanation, default: "Y", timeout: 10) do |response|
+              if response.upcase.start_with?("Y")
+                offer_retry_on(error_type, retries_left - 1, &block)
+              else
+                raise
+              end
             end
           end
         end

data/lib/eco/api/usecases/default_cases/analyse_people_case.rb

@@ -7,14 +7,18 @@ class Eco::API::UseCases::DefaultCases::AnalysePeople < Eco::API::Common::Loader
   def main(people, session, options, usecase)
     @session = session; @options = options; @people = people
 
-    save!(cyclic_sets)
+    save!(analysis)
   end
 
   private
 
-  def identify_double_ups
-    analytics.similarity
-    
+  def analysis
+    analytics.attribute = :name
+    analysed = analytics.analyse({
+      threshold: 0.20,
+      order:     [:average, :dice]
+    })
+    analytics.re_analyse(analysed, threshold: 0.5, order: [:average])
   end
 
   def analytics
@@ -25,9 +29,9 @@ class Eco::API::UseCases::DefaultCases::AnalysePeople < Eco::API::Common::Loader
     @file ||= options.dig(:output, :file) || "analytics.txt"
   end
 
-  def save!(data)
-    if data.empty?
-      session.logger.info("There were no cyclic supervisors identified!!")
+  def save!(analysed)
+    if analysed.empty?
+      session.logger.info("There were results identified!!")
       return
     end
 
@@ -35,42 +39,15 @@ class Eco::API::UseCases::DefaultCases::AnalysePeople < Eco::API::Common::Loader
 
     File.open(file, "w") do |fd|
       if ext == "txt"
-        create_file(data, file: file, format: :txt)
+        fd << analytics.analysis(analysed, format: :txt)
       elsif ext == "html"
         puts "html is still not supported"
         exit(1)
-        create_file(data, file: file, format: :html)
       elsif ext == "json"
         puts "json is still not supported"
         exit(1)
-        create_file(data, file: file, format: :json)
       end
     end
   end
 
-  def create_file(sets, file:, format: :txt)
-    File.open(file, "w") do |fd|
-      fd << sets_to_str(sets, format: format)
-    end
-    puts "Generated file #{file}"
-  end
-
-  def sets_to_str(sets, format: :txt)
-    raise "Required Array. Given: #{sets.class}" unless sets.is_a?(Array)
-    "".tap do |str|
-      sets.each do |set|
-        str << set_to_str(set, format: format)
-      end
-    end
-  end
-
-  def set_to_str(set, lev: 0, format: :txt)
-    raise "Required Array. Given: #{set.class}" unless set.is_a?(Array)
-    "".tap do |str|
-      entry = set.shift
-      str << "#{"  " * lev}#{(lev > 0)? "+-#{lev}- " : ""}#{entry.name} (#{entry.external_id}|#{entry.email}|#{entry.id})\n"
-      str << set_to_str(set, lev: lev + 1, format: format) unless !set || set.empty?
-    end
-  end
-
 end

data/lib/eco/api/usecases/default_cases/to_csv_case.rb

@@ -13,28 +13,42 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
       return false
     end
 
-    session.logger.info("going to create file: #{file}")
-    header = spot_header
-
-    CSV.open(file, "w") do |csv|
-      csv << header
-      people.each do |person|
-        csv << to_row(person)
+    if options.dig(:export, :options, :split_schemas)
+      by_schema.each do |id, people|
+        sch_name = schemas.to_name(id)
+        prefix = sch_name ? sch_name.gsub(" ", "_") : "No_Schema"
+        create_file!("#{prefix}_#{file}", people)
       end
+    else
+      create_file!(file, people)
     end
   end
 
   private
 
+  def create_file!(filename = file, data = people)
+    session.logger.info("going to create file: #{filename}")
+
+    CSV.open(filename, "w") do |csv|
+      csv << spot_header(data.first)
+      data.each do |person|
+        csv << to_row(person)
+      end
+    end
+  end
+
   def to_row(person)
     entry = to_entry_type(person)
-    entry.values_at(*keys(entry))
+    entry.values_at(*keys(entry)).tap do |row|
+      row << schemas.to_name(person.details&.schema_id) || "No Schema"
+    end
   end
 
-  def spot_header
-    header = keys(to_entry_type(people.first))
+  def spot_header(person = people.first)
+    header = keys(to_entry_type(person))
+    header << "Schema"
     header = yield(header) if block_given?
-    header = nice_header_names(header) if nice_header_names?
+    header = nice_header_names(header, schema: schema(person.details)) if nice_header_names?
     header
   end
 
@@ -46,10 +60,62 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
      options.dig(:nice_header) || options.dig(:export, :options, :nice_header)
   end
 
-  def nice_header_names(header)
-    name_maps = session.schema.fields_by_alt_id.each_with_object({}) do |(alt_id, fld), mappings|
+  def nice_header_names(header, schema: nil)
+    schema ||= session.schema
+    name_maps = schema.fields_by_alt_id.each_with_object({}) do |(alt_id, fld), mappings|
       mappings[alt_id] = fld.name
-    end.merge({
+    end.merge(nice_header_maps)
+    header.map {|name| name_maps[name] ? name_maps[name] : name}
+  end
+
+  def to_entry_type(person)
+    session.new_entry(person, dependencies: deps).yield_self do |person_entry|
+      options.dig(:export, :options, :internal_names) ? person_entry.mapped_entry : person_entry.external_entry
+    end
+  end
+
+  def deps
+    @deps ||= {"supervisor_id" => {people: people}}
+  end
+
+  def file
+    @file ||= (options[:file] || options.dig(:export, :file, :name)).tap do |filename|
+      unless filename
+        session.logger.error("Destination file not specified")
+        return false
+      end
+    end
+  end
+
+  def by_schema
+    people.group_by do |person|
+      if details = person.details
+        details.schema_id
+      end
+    end.transform_values do |persons|
+      people.newFrom persons
+    end
+  end
+
+  def schema(value)
+    case value
+    when Ecoportal::API::V1::Person
+      schema(value.details&.schema_id)
+    when String
+      schemas[value]
+    when Ecoportal::API::V1::PersonDetails
+      schema(value.schema_id)
+    when Ecoportal::API::V1::PersonSchema
+      value
+    end
+  end
+
+  def schemas
+    session.schemas
+  end
+
+  def nice_header_maps
+    @nice_header_maps ||= {
       "policy_group_ids"   => "User Group(s)",
       "email"              => "Email",
       "name"               => "Name",
@@ -96,28 +162,7 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
       "custom_person_details"     => "(min) on People Schema Details",
       "custom_person_account"     => "(min) on Users",
       "custom_person_abilities"   => "(min) on Users' Abilities"
-    })
-    header.map {|name| name_maps[name] ? name_maps[name] : name}
-  end
-
-  def to_entry_type(person)
-    session.new_entry(person, dependencies: deps).yield_self do |person_entry|
-      options.dig(:export, :options, :internal_names) ? person_entry.mapped_entry : person_entry.external_entry
-    end
-  end
-
-  def deps
-    @deps ||= {"supervisor_id" => {people: people}}
+    }
   end
 
-  def file
-    @file ||= (options[:file] || options.dig(:export, :file, :name)).tap do |filename|
-      unless filename
-        session.logger.error("Destination file not specified")
-        return false
-      end
-    end
-  end
-
-
 end

data/lib/eco/api/usecases/default_cases/to_csv_detailed_case.rb

@@ -5,8 +5,7 @@ class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::UseCases::
   private
 
   def to_row(person)
-    entry = to_entry_type(person)
-    data = entry.values_at(*keys(entry))
+    data = super(person)
     data << person.subordinates
     data << person_supervisor(person)
     data += user_abilities(person)
@@ -38,8 +37,8 @@ class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::UseCases::
     preferences.map {|key| user_preferences[key] || false}
   end
 
-  def spot_header
-    super do |header|
+  def spot_header(person = people.first)
+    super(person) do |header|
       header << "Subordinates"
       header << "Supervisor Name"
       header += abilities_header

data/lib/eco/api/usecases/ooze_samples/ooze_update_case.rb

@@ -124,8 +124,9 @@ class Eco::API::UseCases::OozeSamples::OozeUpdateCase < Eco::API::Common::Loader
   end
 
   def prompt_to_confirm!
-    print "\nDo you want to proceed (y/N)?  "
-    exit(1) unless $stdin.gets.chomp.to_s.downcase == "y"
+    prompt_user("Do you want to proceed (y/N)?", default: "Y") do |response|
+      exit(1) unless response.upcase.start_with?("Y")
+    end
   end
 
 end