eco-helpers 2.5.10 → 2.6.0

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

@@ -1,160 +0,0 @@
-class Eco::API::UseCases::DefaultCases::AbstractPolicyGroupAbilities < Eco::API::Common::Loaders::UseCase
-  name "abstract-policygroup-abilities"
-  type :export
-
-  attr_reader :people
-
-  def main(people, session, options, usecase)
-    options[:end_get] = false
-    @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/append_usergroups_case.rb

@@ -1,14 +0,0 @@
-class Eco::API::UseCases::DefaultCases::AppendUsergroupsCase < Eco::API::Common::Loaders::UseCase
-  name "append-usergroups"
-  type :sync
-
-  def main(entries, people, session, options, usecase)
-    micro    = session.micro
-    update   = session.new_job("main", "update", :update, usecase)
-
-    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
-      update.add(person)
-      micro.append_usergroups(entry, person, options)
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-class Eco::API::UseCases::DefaultCases::CleanUnknownTags < Eco::API::Common::Loaders::UseCase
-  name "clean-unknown-tags"
-  type :transform
-
-  UNKNOWN_LOCS_FILE = "unknown_locations.txt"
-
-  REGISTER_TAGS = [
-    "EVENT", "INJURY", "RISK", "CONTRACTOR", "PERMIT",
-    "AUDIT", "JSEA",
-    "TRAINING", "INDUCTION",
-    "MEETING",  "PPE",  "CHEMICAL",
-    "PLANT", "ASSET",
-    "POLICY", "IDEA", "REPORTS"
-  ]
-
-  def main(people, session, options, usecase)
-    update   = session.new_job("main", "update", :update, usecase)
-    people.each do |person|
-      unknown_tags = person.filter_tags.select {|tag| !tag?(tag)}
-      person.filter_tags -= unknown_tags
-      unknown_tag!(*unknown_tags)
-      if (account = person.account) && tag = account.default_tag
-        unless tag?(tag)
-          micro.refresh_default_tag(person.entry, person, options)
-          unknown_tag!(tag)
-        end
-      end
-      update.add(person)
-    end
-  end
-
-  private
-
-  def unknown_tag!(*tags)
-    tags.each do |value|
-      unless unknown.include?(value)
-        unknown << value
-        File.open(unknown_tags_file, 'a') do |fd|
-          fd.write("#{value}\n")
-        end
-        puts "Custom detected: '#{value}'"
-      end
-    end
-  end
-
-  def register_tags
-    REGISTER_TAGS
-  end
-
-  def unknown
-    @unknown ||= []
-  end
-
-  def tag?(value)
-    tagtree.tag?(value).yield_self do |is_loc|
-      next true if is_loc
-      if clean_register_tags?
-        register_tags.any? {|reg| value == reg}
-      end
-    end
-  end
-
-  def tagtree
-    @tagtree ||= ASSETS.config.tagtree
-  end
-
-  def unknown_tags_file
-    File.join(".","#{session.enviro_name}_#{UNKNOWN_LOCS_FILE}")
-  end
-
-  def clean_register_tags?
-    !options.dig(:usecase, :include_register_tags)
-  end
-end

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

@@ -1,20 +0,0 @@
-class Eco::API::UseCases::DefaultCases::CreateDetailsCase < Eco::API::Common::Loaders::UseCase
-  name "create-details"
-  type :sync
-
-  def main(entries, people, session, options, usecase)
-    creation = session.new_job("main", "create",  :create, usecase)
-
-    micro.with_each_starter(entries, people, options, log_present: true, append_created: append_created) do |entry, person|
-      creation.add(person)
-      micro.set_core(entry, person, options)
-      entry.set_details(person) unless options.dig(:exclude, :details)
-    end
-  end
-
-  private
-
-  def append_created
-    options.dig(:people, :append_created)
-  end
-end

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

@@ -1,21 +0,0 @@
-class Eco::API::UseCases::DefaultCases::CreateDetailsWithSupervisorCase < Eco::API::Common::Loaders::UseCase
-  name "create-details-with-supervisor"
-  type :sync
-
-  def main(entries, people, session, options, usecase)
-    creation = session.new_job("main", "create", :create, usecase)
-    supers   = session.new_job("post", "supers", :update, usecase, :core)
-
-    micro.with_each_starter(entries, people, options, log_present: true, append_created: append_created) do |entry, person|
-      creation.add(person)
-      micro.set_core_with_supervisor(entry, person, people, supers, options)
-      entry.set_details(person) unless options.dig(:exclude, :details)
-    end
-  end
-
-  private
-
-  def append_created
-    options.dig(:people, :append_created)
-  end
-end

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

@@ -1,12 +0,0 @@
-class Eco::API::UseCases::DefaultCases::EmailAsIdCase < Eco::API::Common::Loaders::UseCase
-  name "email-as-id"
-  type :transform
-
-  def main(people, session, options, usecase)
-    update   = session.new_job("main", "update", :update, usecase, :core)
-    people.each do |person|
-      person.external_id = person.email
-      update.add(person)
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-class Eco::API::UseCases::DefaultCases::NewEmailCase < Eco::API::Common::Loaders::UseCase
-  name "new-email"
-  type :sync
-
-  def main(entries, people, session, options, usecase)
-    update   = session.new_job("main", "update", :update, usecase, :core)
-
-    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
-      update.add(person)
-      person.email = entry.email
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-class Eco::API::UseCases::DefaultCases::NewIdCase < Eco::API::Common::Loaders::UseCase
-  name "new-id"
-  type :sync
-
-  def main(entries, people, session, options, usecase)
-    update   = session.new_job("main", "update", :update, usecase, :core)
-    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
-      update.add(person)
-      person.external_id = entry.external_id
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-class Eco::API::UseCases::DefaultCases::RemoveAccountSyncCase < Eco::API::UseCases::DefaultCases::RemoveAccountTransCase
-  name "remove-account"
-  type :sync
-
-  def main(entries, people, session, options, usecase)
-    micro    = session.micro
-    found    = micro.with_each_present(entries, people, options, log_starter: true)
-    remove_account(found.users)
-  end
-end

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

@@ -1,16 +0,0 @@
-class Eco::API::UseCases::DefaultCases::RemoveAccountTransCase < Eco::API::Common::Loaders::UseCase
-  name "remove-account"
-  type :transform
-
-  def remove_account(users)
-    update   = session.new_job("main", "update", :update, usecase, :account)
-    users.each do |user|
-      user.account = nil
-      update.add(user)
-    end
-  end
-
-  def main(people, session, options, usecase)
-    remove_account(people.users)
-  end
-end

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

@@ -1,18 +0,0 @@
-class Eco::API::UseCases::DefaultCases::ResetLandingPageCase < Eco::API::Common::Loaders::UseCase
-  name "reset-landing-page"
-  type :transform
-
-  def main(people, session, options, usecase)
-    update = session.new_job("main", "update", :update, usecase, :core)
-    people.users.each do |user|
-      user.account.landing_page_id = page_id
-      update.add(user)
-    end
-  end
-
-  private
-
-  def page_id
-    options[:page_id]
-  end
-end

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

@@ -1,16 +0,0 @@
-class Eco::API::UseCases::DefaultCases::SetSupervisorCase < Eco::API::Common::Loaders::UseCase
-  name "set-supervisor"
-  type :sync
-
-  def main(entries, people, session, options, usecase)
-    update   = session.new_job("main", "update", :update, usecase)
-
-    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
-      if entry.supervisor_id?
-        micro.set_supervisor(person, entry.supervisor_id, people, options) do |unknown_id|
-          session.logger.warn("Supervisor '#{entry.supervisor_id}' does not exist. Entry: #{entry.to_s(:identify)}")
-        end
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-class Eco::API::UseCases::DefaultCases::TagTree < Eco::API::Common::Loaders::UseCase
-  name "tagtree"
-  type :other
-
-  def main(session, options, usecase)
-    puts "Use case still in development"
-    exit
-    options[:end_get] = false
-    operations.keys.each do |key|
-      process(key)
-    end
-  end
-
-  def process(key)
-    case key
-    when :diff
-      require_graphql_auth!
-
-    when :show_backend
-      require_graphql_auth!
-
-    else
-      logger.warn("Operation #{key} not supported")
-    end
-  end
-
-  private
-
-  def require_graphql_auth!
-    unless session.config.api.version_available?(:graphql)
-      logger.error("Missing parameters for to configure a GraphQL connexion.")
-    end
-  end
-
-  def operations
-    (options.dig(:tagtree, :operations) || {})
-  end
-
-  def graphql
-   @graphql ||= session.api(version: :graphql)
-  end
-end

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

@@ -1,15 +0,0 @@
-class Eco::API::UseCases::DefaultCases::UpdateDetailsCase < Eco::API::Common::Loaders::UseCase
-  name "update-details"
-  type :sync
-
-  def main(entries, people, session, options, usecase)
-    update   = session.new_job("main", "update", :update, usecase)
-    supers   = session.new_job("post", "supers", :update, usecase, :core)
-
-    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
-      update.add(person)
-      micro.set_core_with_supervisor(entry, person, people, supers, options)
-      entry.set_details(person) unless options.dig(:exclude, :details)
-    end
-  end
-end

data/lib/eco/cli/config/default.rb

@@ -1,16 +0,0 @@
-module Eco
-  class CLI
-    class Config
-      module Default
-      end
-    end
-  end
-end
-
-require_relative 'default/options'
-require_relative 'default/input'
-require_relative 'default/input_filters'
-require_relative 'default/people'
-require_relative 'default/people_filters'
-require_relative 'default/usecases'
-require_relative 'default/workflow'