eco-helpers 2.0.15 → 2.0.21

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

@@ -83,6 +83,10 @@ module Eco
             self["name"]
           end
 
+          def one_off?
+            name.is_a?(Symbol)
+          end
+
           def key
             self["key"]
           end

data/lib/eco/api/session/config/apis.rb

@@ -82,6 +82,86 @@ module Eco
             self["user_key"]
           end
 
+          # Method to support CLI one-off API requests
+          def one_off
+            if one_off?
+              add(one_off_org, key: one_off_key, host: "#{one_off_enviro}.ecoportal.com")
+              return one_off_org
+            end
+          end
+
+          private
+
+          def one_off?
+            @is_one_off ||= SCR.get_arg("-api-key") || SCR.get_arg("-one-off")
+          end
+
+          def one_off_key
+            return @one_off_key if instance_variable_defined?(:@one_off_key)
+            if one_off?
+              Dotenv.load("./.env_one_off")
+              SCR.get_arg("-api-key", with_param: true).yield_self do |key|
+                 one_off_key_env(key)
+              end
+            end
+          end
+
+          def one_off_key_env(key)
+            if one_off?
+              if key
+                env_file_set_var("./.env_one_off", one_off_key_env_var, key)
+                key
+              else
+                Dotenv.load("./.env_one_off")
+                ENV[one_off_key_env_var].tap do |k|
+                  raise "At least the first time, you should provide the -api-key" unless k
+                end
+              end
+            end
+          end
+
+          def one_off_key_env_var
+            @one_off_key_env_var ||= "#{one_off_org}_KEY"
+          end
+
+          def one_off_org
+            return @one_off_org if instance_variable_defined?(:@one_off_org)
+            unless org = SCR.get_arg("-org", with_param: true)
+              raise("You should specify -org NAME when using -api-key or -one-off")
+            end
+            @one_off_org  ||= "#{org.downcase.split(/[^a-z]+/).join("_")}_#{one_off_enviro.gsub(".", "_")}".to_sym
+          end
+
+          def one_off_enviro
+            return @one_off_enviro if instance_variable_defined?(:@one_off_enviro)
+            enviro = SCR.get_arg("-enviro") ? SCR.get_arg("-enviro", with_param: true) : "live"
+            @one_off_enviro ||= enviro.downcase
+          end
+
+          def env_file_set_var(file, var, value)
+            begin
+              pattern = /"#{var}=(?<value>[^ \r\n]+)"/
+              File.open(file, "w+") do |fd|
+                found = false
+                fd.each_line do |line|
+                  if match = line.match(pattern)
+                    found = true
+                    #  IO::SEEK_CUR => Seeks to _amount_ plus current position
+                    fd.seek(-(line.length + 1), IO::SEEK_CUR)
+                    fd.write line.gsub(match[:value], value)
+                  end
+                end
+
+                fd << "#{var}=#{value}" unless found
+              end
+            rescue StandardError => e
+              puts "#{e}"
+              return false
+            end
+            return true
+          end
+
+
         end
       end
     end

data/lib/eco/api/session/config/files.rb

@@ -14,6 +14,13 @@ module Eco
           end
 
           def working_directory
+            if config.apis.active_api&.one_off?
+              one_off_dir = File.join("one_off", config.apis.active_name.to_s)
+              unless full_path = Eco::Data::Files::Directory.new(one_off_dir).create
+                raise "Could not create the folder '#{full_path}'"
+              end
+              self["dir"] = one_off_dir
+            end
             self["dir"]
           end
 

data/lib/eco/api/session/config/people.rb

@@ -9,7 +9,7 @@ module Eco
           end
 
           def cache
-            self["cache"]
+            self["cache"] ||= "cache/people.json"
           end
 
           def partial_cache
@@ -35,7 +35,7 @@ module Eco
           end
 
           def requests_folder
-            self["requests_folder"]
+            self["requests_folder"] ||= "requests"
           end
 
           # people to exclude from update feeds
@@ -86,23 +86,7 @@ module Eco
           def default_schema?
             !!self["default_schema"]
           end
-
-          def presets_custom=(file)
-            self["presets_custom"] = file
-          end
-
-          def presets_custom
-            self["presets_custom"]
-          end
-
-          def presets_map=(file)
-            self["presets_map"] = file
-          end
-
-          def presets_map
-            self["presets_map"]
-          end
-
+          
           # @return [Hash] with defined pairs format `key` and Person parsers.
           def parsers
             self["parsers"] ||= {}

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

@@ -9,8 +9,11 @@ module Eco
   end
 end
 
+require_relative 'default_cases/abstract_policygroup_abilities_case.rb'
+require_relative 'default_cases/analyse_people_case'
 require_relative 'default_cases/append_usergroups_case'
 require_relative 'default_cases/change_email_case'
+require_relative 'default_cases/clean_unknown_tags_case'
 require_relative 'default_cases/codes_to_tags_case'
 require_relative 'default_cases/create_case'
 require_relative 'default_cases/create_details_case'
@@ -22,7 +25,6 @@ require_relative 'default_cases/hris_case'
 require_relative 'default_cases/new_id_case'
 require_relative 'default_cases/new_email_case'
 require_relative 'default_cases/org_data_convert_case'
-require_relative 'default_cases/refresh_abilities_case'
 require_relative 'default_cases/refresh_case'
 require_relative 'default_cases/reinvite_trans_case'
 require_relative 'default_cases/reinvite_sync_case'
@@ -33,6 +35,7 @@ require_relative 'default_cases/restore_db_case'
 require_relative 'default_cases/set_default_tag_case'
 require_relative 'default_cases/set_supervisor_case'
 require_relative 'default_cases/supers_hierarchy_case'
+require_relative 'default_cases/supers_cyclic_identify_case'
 require_relative 'default_cases/switch_supervisor_case'
 require_relative 'default_cases/to_csv_case'
 require_relative 'default_cases/to_csv_detailed_case'

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

@@ -0,0 +1,161 @@
+class Eco::API::UseCases::DefaultCases::AbstractPolicyGroupAbilities < Eco::API::Common::Loaders::UseCase
+  name "abstract-policygroup-abilities"
+  type :export
+
+  attr_reader :session, :people, :options
+
+  def main(people, session, options, usecase)
+    options[:end_get] = false
+    @session = session; @options = options; @people = people
+
+    generate_csv!
+  end
+
+  private
+
+  def file
+    @file ||= options.dig(:output, :file) || "suggested_abilities.csv"
+  end
+
+  def generate_csv!
+    policy_groups.each_with_object({}) do |group, data|
+      data[group.id] ||= {}
+      data[group.id][:name]      = group.name
+      data[group.id][:suggested] = group_suggestions(group.id)
+      data[group.id][:percents]  = group_abilities(group.id)
+    end.yield_self do |data|
+      abilities_list = Eco::API::Organization::PresetsFactory.abilities
+      CSV.open(file, "w") do |csv|
+        csv << ["Type", "UserGroup", "ID", *abilities_list]
+        # Dump the final suggestions
+        data.each do |id, meta|
+          csv << ["Suggested", meta[:name], id, *meta[:suggested].values_at(*abilities_list)]
+        end
+        # Dump the percentaged levels of each ability
+        data.each do |id, meta|
+          analysis = meta[:percents].values_at(*abilities_list).each_with_object([]) do |levels, values|
+            values << levels.map do |level, percentil|
+              "#{level ? level : "null"} => #{percentil}"
+            end.join("\n")
+          end
+          csv << ["Analysis", meta[:name], id, *analysis]
+        end
+      end
+      puts "Generated file #{file}"
+    end
+  end
+
+  def policy_groups
+    @policy_groups ||= session.policy_groups
+  end
+
+  # Suggests 1 final set of abilities for a usergroup
+  def group_suggestions(id)
+    group_abilities(id).each_with_object({}) do |(key, levels), set|
+      data = levels.to_a.sort_by(&:last).reverse.first
+      set[key] = data ? data.shift : nil
+    end
+  end
+
+  # Cleans up each ability's levels by:
+  #   1. cutting at some minimum threshold percentage
+  #   2. directly selecting those greater than 70%
+  def group_abilities(id)
+    @group_abilities     ||= {}
+    @group_abilities[id] ||= ability_levels_percent(id).each_with_object({}) do |(ability, levels), out|
+      outstanding = nil
+      levels.select do |level, percentil|
+        outstanding ||= level if percentil >= 75
+        percentil > 15
+      end.yield_self do |filtered|
+        out[ability] =  outstanding ? filtered.slice(outstanding) : filtered
+      end
+    end
+  end
+
+  # With given the percentages of sets of abilities
+  # it abstracts the percentage of each level of each ability
+  def ability_levels_percent(id)
+    @ability_levels_percent     ||= {}
+    @ability_levels_percent[id] ||= Eco::API::Organization::PresetsFactory.abilities.each_with_object({}) do |key, out|
+      out[key] ||= {}
+      ability_sets_percent(id).each_with_object(out[key]) do |(set, percentil), levels|
+        levels[set[key]] ||= 0
+        levels[set[key]]   = (levels[set[key]] + percentil).round(2)
+      end
+    end
+  end
+
+  # Give a percentage to each set of abilities
+  def ability_sets_percent(id)
+    @ability_sets_percent     ||= {}
+    @ability_sets_percent[id] ||= scoped_relevant_raw_data(id).yield_self do |data|
+      # Transform ability sets counter to percentage
+      total     = data[:count]
+      abilities = data[:abilities]
+      data[:abilities].transform_values do |val|
+        percent(val, total)
+      end
+    end
+  end
+
+  # Get rid of data simingly irrelevant
+  def scoped_relevant_raw_data(id)
+    sp   = single_percent(id)
+    sing = single(id); mult = multiple(id)
+
+    # Scope Relevant Raw Data
+    case
+    when sp >= 3 # >= 80
+      sing
+    #when sp < 15
+    #  mult
+    else # combine
+      all_abilities = sing[:abilities].keys | mult[:abilities].keys
+      data = {count: sing[:count] + mult[:count], abilities: {}}
+      all_abilities.each_with_object(data) do |abilities, merged|
+        scount = sing[:abilities][abilities] || 0
+        mcount = mult[:abilities][abilities] || 0
+        merged[:abilities][abilities] = scount + mcount
+      end
+    end
+  end
+
+  def single_percent(id)
+    percent(single(id)[:count], count(id))
+  end
+
+  def single(id)
+    groups_abilities.dig(id, :single) ||  {count: 0, abilities: {}}
+  end
+
+  def multiple(id)
+    groups_abilities.dig(id, :multiple) ||  {count: 0, abilities: {}}
+  end
+
+  def count(id)
+    groups_abilities.dig(id, :count) || 0
+  end
+
+  def groups_abilities
+    @groups_abilities ||= people.users.each_with_object({}) do |user, groups|
+      abilities = Eco::API::Organization::PresetsFactory.all_abilities(user.account.permissions_custom)
+      ids       = user.account.policy_group_ids
+      category  = ids.count > 1 ? :multiple : :single
+
+      ids.each do |id|
+        groups[id] ||= {count: 0}
+        groups[id][:count]   += 1
+        groups[id][category] ||= {count: 0, abilities: {}}
+        groups[id][category][:count] += 1
+        groups[id][category][:abilities][abilities] ||= 0
+        groups[id][category][:abilities][abilities]  += 1
+      end
+    end
+  end
+
+  def percent(num, total)
+    (100 * num.to_f / total).round(2)
+  end
+
+end

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

@@ -0,0 +1,223 @@
+class Eco::API::UseCases::DefaultCases::AnalysePeople < Eco::API::Common::Loaders::UseCase
+  name "analyse-people"
+  type :export
+
+  attr_reader :session, :people, :options
+
+  def main(people, session, options, usecase)
+    options[:end_get] = false
+    @session = session; @options = options; @people = people
+
+    case
+    when case_options[:identify_duplicates]
+      identify_duplicates
+    when case_options[:identify_unnamed]
+      identify_unnamed
+    else
+      session.logger.info("No analysis operation was specified")
+    end.tap do |people_involved|
+      if people_involved
+        to_csv(people_involved) if to_csv?
+        create_people_backup(people_involved) if results_people_backup?
+      end
+    end
+  end
+
+  private
+
+  def identify_unnamed
+    similarity_analytics.unnamed.tap do |unnamed|
+      if unnamed.empty?
+        session.logger.info("There were no people with no name!!")
+      end
+    end
+  end
+
+  def identify_duplicates
+    analysed = similarity_screening
+    if case_options[:ignore_matching_words]
+      puts "Fine tune results by ignoring matching words..."
+      analysed = strict_similarity(analysed)
+    end
+
+    similarity_analytics.newSimilarity(analysed).tap do |related_people|
+      if related_people.empty?
+        session.logger.info("There were no possible duplicates identified!!")
+      else
+        report = similarity_analytics.report(analysed, format: :txt)
+        save!(report)
+      end
+    end
+  end
+
+  def strict_similarity(analysed)
+    similarity_analytics.ignore_matching_words(analysed, **{
+      threshold: 0.5,
+      order: [:ngrams]
+    })
+  end
+
+  def similarity_screening
+    similarity_analytics.attribute = field_similarity
+    options = {
+      threshold: 0.4,
+      order:     [:average, :dice]
+    }.tap do |opts|
+      opts.merge!(needle_read: facet_field_proc) if facet_field?
+      opts.merge!(unique_words: true) if unique_words?
+    end
+    analysed = similarity_analytics.analyse(**options)
+    puts "Got #{analysed.count} results after basic screening with #{options}"
+
+    return analysed if case_options[:only_screening]
+    options = {threshold: 0.5, order: [:average]}
+    puts "Going to rearrange results... with #{options}"
+    similarity_analytics.rearrange(analysed, **options).tap do |analysed|
+      puts "... got #{analysed.count} results after rearranging"
+    end
+  end
+
+  def similarity_analytics
+    @analytics ||= people.similarity
+  end
+
+  def create_people_backup(cut = people, file = results_people_backup)
+    session.file_manager.save_json(cut, file)
+  end
+
+  def to_csv(data = people, file = csv_file)
+    opts = {}
+    opts.deep_merge!(export: {file: {name: file, format: :csv}})
+    opts.deep_merge!(export: {options: {nice_header: true}})
+    opts.deep_merge!(export: {options: {internal_names: true}})
+    #opts.deep_merge!(export: {options: {split_schemas: true}})
+    session.process_case("to-csv", type: :export, people: data, options: opts.merge(options.slice(:export)))
+  end
+
+  def unique_words?
+    case_options[:unique_words]
+  end
+
+  def field_similarity
+    return :name unless use_field?
+    use_field_proc
+  end
+
+  def use_field_proc
+    proc_value_access(use_field)
+  end
+
+  def facet_field_proc
+    proc_value_access(facet_field)
+  end
+
+  def use_field
+    case_options.dig(:use_field)
+  end
+
+  def use_field?
+    !!use_field
+  end
+
+  def facet_field
+    case_options.dig(:facet_field)
+  end
+
+  def facet_field?
+    !!facet_field
+  end
+
+  def csv_file
+    case_options.dig(:csv_file)
+  end
+
+  def to_csv?
+    !!csv_file
+  end
+
+  def results_people_backup
+    case_options.dig(:backup_people)
+  end
+
+  def results_people_backup?
+    !!results_people_backup
+  end
+
+  def case_options
+    options.dig(:usecase, :analyse_people) || {}
+  end
+
+  def output_file
+    @output_file ||= options.dig(:output, :file) || "analytics.txt"
+  end
+
+  def save!(data)
+    ext  = File.extname(output_file).downcase.delete(".")
+    session.logger.info("Generating file '#{output_file}'")
+    File.open(output_file, "w") do |fd|
+      if ext == "txt"
+        fd << data
+      elsif ext == "html"
+        puts "html is still not supported"
+        exit(1)
+      elsif ext == "json"
+        puts "json is still not supported"
+        exit(1)
+      end
+    end
+  end
+
+  # A way to use command line to specify part
+  # => i.e. details[first-name] AND details[surname]
+  def proc_value_access(expression)
+    #return expression.to_sym if expression.start_with?(":")
+    subexpressions = expression.split(" AND ")
+    Proc.new do |person|
+      values = subexpressions.map {|exp| attribute_access(person, exp)}
+      values.compact.join(" ")
+    end
+  end
+
+  # A way to use command line to specify part
+  # => i.e. person.details[first-name]
+  def attribute_access(person, expression)
+    parts = expression.split(".")
+    parts_to_value(person, parts).tap do |value|
+      unless value.is_a?(String) || !value
+        raise "Something is wrong with #{expression} to parts #{parts}. Expecting String, obtained: #{value.class}"
+      end
+    end
+  end
+
+  def parts_to_value(obj, parts)
+    parts.reduce(obj) do |object, part|
+      get_attr(object, part)
+    end
+  end
+
+  def get_attr(obj, part)
+    case
+    when !obj
+      nil
+    when part.is_a?(Symbol) || obj.respond_to?(part.to_sym)
+      obj.send(part.to_sym)
+    when part.start_with?(":")
+      get_attr(obj, part[1..-1])
+    when part.start_with?("details[")
+      if (obj.respond_to?(:details)) && details = obj.details
+        if match = part.match(/details\[(?<field>.*)\]/)
+          details[match[:field]]
+        else
+          raise "Review your -use-field expression. It should read: person.details[target-alt_id]"
+        end
+      end
+    when part.start_with?("account")
+      obj.account if obj.respond_to?(:account)
+    when part.start_with?("person")
+      obj
+    else
+      raise "Review your expression. Cannot recognize '#{part}' as part of '#{obj.class}'"
+    end
+  end
+
+end