eco-helpers 2.0.16 → 2.0.22

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

@@ -40,20 +40,6 @@ 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
@@ -96,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/people.rb

@@ -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

@@ -2,7 +2,7 @@ module Eco
   module API
     class UseCases
 
-      class UnkownCase < Exception
+      class UnkownCase < StandardError
         def initialize(msg = nil, case_name: nil, type: nil)
           msg ||= "Unkown case"
           msg += ". Case name '#{case_name}'" if case_name
@@ -11,7 +11,7 @@ module Eco
         end
       end
 
-      class AmbiguousCaseReference < Exception
+      class AmbiguousCaseReference < StandardError
         def initialize(msg = nil, case_name: nil)
           msg ||= "You must specify type when there are multiple cases with same name"
           msg += ". Case name '#{case_name}'" if case_name

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

@@ -4,7 +4,7 @@ module Eco
       # Core class of UseCases. It basically defines and manages allowed `types`
       class BaseCase
 
-        class InvalidType < Exception
+        class InvalidType < StandardError
           def initialize(msg = nil, type:, types:)
             msg ||= "Invalid type."
             msg = "Given type '#{type}'. Valid types: #{types}"
@@ -13,7 +13,7 @@ module Eco
         end
 
         extend Eco::API::Common::ClassHelpers
-        
+
         @types = [:import, :filter, :transform, :sync, :error_handler, :export, :other]
 
         class << self

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

@@ -5,6 +5,19 @@ module Eco
       class BaseIO < BaseCase
         @types  = BaseCase.types
 
+        class MissingParameter < StandardError
+          attr_reader :type, :required, :given
+
+          def initialize(msg = nil, type: nil, required:, given:)
+            @type     = type
+            @required = required
+            @given    = given
+            msg += " of type '#{type}'" if type
+            msg += " requires an object '#{required}'. Given: #{given}."
+            super(msg)
+          end
+        end
+
         class << self
           def input_required?(type)
             !valid_type?(type) || [:import, :sync].include?(type)
@@ -80,13 +93,13 @@ module Eco
         def validate_args(input:, people:, session:, options:)
           case
           when !session.is_a?(Eco::API::Session)
-            raise "A UseCase needs a Session object. Given: #{session}"
+            raise MissingParameter.new("UseCase", required: :session, given: session.class)
           when input_required? && !input
-            raise "UseCase of type '#{type}' requires a valid input. None given"
+            raise MissingParameter.new("UseCase", type: type, required: :input, given: input.class)
           when people_required? && !people.is_a?(Eco::API::Organization::People)
-            raise "UseCase of type '#{type}' requires a People object. Given: #{people}"
+            raise MissingParameter.new("UseCase", type: type, required: :people, given: people.class)
           when !options || (options && !options.is_a?(Hash))
-            raise "To inject dependencies via ':options' it should be a Hash object. Given: #{options}"
+            raise MissingParameter.new("Use Case options", required: :Hash, given: options.class)
           end
           true
         end

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

@@ -10,8 +10,10 @@ module Eco
 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'
@@ -23,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'

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

@@ -5,10 +5,10 @@ class Eco::API::UseCases::DefaultCases::AbstractPolicyGroupAbilities < Eco::API:
   attr_reader :session, :people, :options
 
   def main(people, session, options, usecase)
+    options[:end_get] = false
     @session = session; @options = options; @people = people
 
     generate_csv!
-    exit(0)
   end
 
   private
@@ -106,10 +106,10 @@ class Eco::API::UseCases::DefaultCases::AbstractPolicyGroupAbilities < Eco::API:
 
     # Scope Relevant Raw Data
     case
-    when sp >= 80
+    when sp >= 3 # >= 80
       sing
-    when sp < 15
-      mult
+    #when sp < 15
+    #  mult
     else # combine
       all_abilities = sing[:abilities].keys | mult[:abilities].keys
       data = {count: sing[:count] + mult[:count], abilities: {}}

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