eco-helpers 2.0.12 → 2.0.17

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

@@ -288,10 +288,13 @@ module Eco
               handlers = session.config.error_handlers
               if status.errors.any? && !handlers.empty? && !error_handler?
                 err_types = status.errors.by_type
+                logger.debug("(#{self.name}) got these error types: #{err_types.keys}")
                 handlers.each do |handler|
                   if entries = err_types[handler.name]
                     handler_job = subjobs_add("#{self.name} => #{handler.name}", usecase: handler)
+                    logger.debug("Running error handler #{handler.name}")
                     handler.launch(people: people(entries), session: session, options: options, job: handler_job)
+                    logger.debug("Launching job of error handler: #{handler_job.name}")
                     handler_job.launch(simulate: simulate)
                   end
                 end

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

@@ -159,6 +159,8 @@ module Eco
         end
 
         def working_directory(mode: nil)
+          return files.working_directory if apis.active_api&.one_off?
+
           unless mode
             wd = files.working_directory
             return wd unless wd.to_s.strip.empty?
@@ -183,12 +185,21 @@ module Eco
         end
 
         def require(file = nil, match: nil)
-          if match
-            file_manager.dir.dir_files(pattern: match).each do |file|
-              require_relative File.expand_path(file)
+          begin
+            if match
+              file_manager.dir.dir_files(pattern: match).each do |file|
+                require_relative File.expand_path(file)
+              end
+            else
+              target = File.expand_path(file_manager.dir.file(file))
+              require_relative target
+            end
+          rescue LoadError => e
+            if apis.active_api.one_off?
+              pp e.to_s
+            else
+              raise
             end
-          else
-            require_relative "#{File.expand_path(file_manager.dir.file(file))}"
           end
         end
         # @!endgroup
@@ -286,16 +297,6 @@ module Eco
           people.default_schema = name
         end
 
-        # Specify the file with the account custom abilities presets
-        def presets_custom=(file)
-          people.presets_custom = file
-        end
-
-        # Specify the file with the usergroup to custom presets mapping
-        def presets_map=(file)
-          people.presets_map = file
-        end
-
         # @see Eco::API::Session::Config::People
         # @param (see Eco::API::Session::Config::People)
         # @return [Eco::API::Common::People::PersonParser] parser/serializer for the defined `format`.

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

@@ -40,6 +40,20 @@ module Eco
             self
           end
 
+          # Method to support CLI one-off API requests
+          def one_off
+            if SCR.get_arg("-api-key")
+              key    = SCR.get_arg("-api-key", with_param: true)
+              enviro = SCR.get_arg("-enviro") ? SCR.get_arg("-enviro", with_param: true) : "live"
+              host   = "#{enviro}.ecoportal.com"
+              org    = SCR.get_arg("-org")    ? SCR.get_arg("-org", with_param: true) : raise("You should specify -org NAME when using -api-key")
+              org    = org.downcase.split(/[^a-z]+/).join("_")
+              org    = org.to_sym
+              add(org, key: key, host: host)
+              return org
+            end
+          end
+
           def active_api
             self["active-api"]
           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.rb

@@ -30,6 +30,7 @@ module Eco
         @usecases      = {}
         @cache_init    = false
         @cases_by_name = {}
+        init_caches
       end
 
       def length
@@ -79,6 +80,7 @@ module Eco
 
       # @return [Eco::API::UseCases] a copy of instance object of `self`.
       def dup
+        init_caches
         self.class.new.merge(self)
       end
 

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

@@ -9,6 +9,8 @@ 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/codes_to_tags_case'
@@ -22,7 +24,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'
@@ -32,6 +33,8 @@ require_relative 'default_cases/reset_landing_page_case'
 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 >= 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,76 @@
+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)
+    @session = session; @options = options; @people = people
+
+    save!(cyclic_sets)
+  end
+
+  private
+
+  def identify_double_ups
+    analytics.similarity
+    
+  end
+
+  def analytics
+    @analytics ||= people.analytics
+  end
+
+  def file
+    @file ||= options.dig(:output, :file) || "analytics.txt"
+  end
+
+  def save!(data)
+    if data.empty?
+      session.logger.info("There were no cyclic supervisors identified!!")
+      return
+    end
+
+    ext  = File.extname(file).downcase.delete(".")
+
+    File.open(file, "w") do |fd|
+      if ext == "txt"
+        create_file(data, file: file, 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/codes_to_tags_case.rb

@@ -16,10 +16,9 @@ class Eco::API::UseCases::DefaultCases::CodesToTagsCase < Eco::API::Common::Load
   end
 
   def main(session, options, usecase)
-    @session = session
-    @options = options
+    options[:end_get] = false
+    @session = session; @options = options
     codes_to_tags
-    exit
   end
 
   private