eco-helpers 2.5.10 → 2.6.1

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/workflow.rb

@@ -1,188 +0,0 @@
-ASSETS.cli.config do |config|
-  ASSETS.config.workflow do |wf|
-    io                = nil
-    rescued           = false
-    cases_with_input  = nil
-    cases_with_output = nil
-
-    # default rescue
-    wf.rescue do |exception, io|
-      begin
-        next io if rescued
-        rescued = true
-
-        io.session.logger.debug(exception.patch_full_message)
-        wf.run(:close, io: io)
-      rescue Exception => e
-        puts "Some problem in workflow.rescue: #{e}"
-      end
-      io
-    end
-
-    wf.on(:options) do |wf_options, io|
-      io = io.new(options:   config.options_set.process(io: io))
-    end
-
-    wf.for(:load) do |wf_load|
-      wf_load.for(:input) do |wf_input|
-        wf_input.on(:get) do |wf_input_get, io|
-          cases_with_input =  config.usecases.active(io: io).select do |usecase, data|
-            io.class.input_required?(usecase.type)
-          end
-
-          input_is_required = !cases_with_input.empty? || io.options.dig(:input, :entries_from)
-          missing_input     = !io.input || io.input.empty?
-          next io unless missing_input && input_is_required
-
-          if io.options.dig(:input, :entries_from)
-            io = io.new(input: config.input.get(io: io))
-          else
-            opt_case = cases_with_input.values.first.option
-            io = io.new(input: config.input.get(io: io, option: opt_case))
-          end
-          io
-        end
-
-        wf_input.on(:filter) do |wf_input_filter, io|
-          next io unless io.input && !io.input.empty?
-          io = io.new(input:  config.input_filters.process(io: io))
-        end
-      end
-
-      wf_load.for(:people) do |wf_people|
-        wf_people.on(:get) do |wf_people_get, io|
-          cases_with_people = config.usecases.active(io: io).select do |usecase, data|
-            io.class.people_required?(usecase.type)
-          end
-          next io if cases_with_people.empty? && !io.options.dig(:people, :get)
-          io = io.new(people:  config.people(io: io))
-        end
-
-        wf_people.on(:filter) do |wf_people_filter, io|
-          next io unless io.people && !io.people.empty?
-          io = io.new(people:  config.people_filters.process(io: io))
-        end
-      end
-    end
-
-    wf.before(:usecases) do |wf_cases, io|
-      # save partial entries -> should be native to session.workflow
-      get_people     = io.options.dig(:people, :get)
-      partial_update = get_people && get_people.dig(:type) == :partial
-      if !io.options[:dry_run] && partial_update
-        partial_file = io.session.config.people.partial_cache
-        io.session.file_manager.save_json(io.people, partial_file, :timestamp)
-      end
-      io
-    end
-
-    wf.on(:usecases) do |wf_cases, io|
-      unless config.usecases.process(io: io)
-        msg = "No update operation specified... quitting"
-        io.session.logger.info(msg)
-        exit(0)
-      end
-      io
-    end
-
-    wf.before(:launch_jobs) do |wf_jobs, io|
-      SCR.stop_on_unknown!
-      io
-    end
-
-    wf.on(:launch_jobs) do |wf_jobs, io|
-      io.session.jobs_launch(simulate: io.options[:dry_run])
-      io
-    end
-
-    wf.before(:post_launch) do |wf_post, io|
-      if io.session.post_launch.empty?
-        wf_post.skip!
-      else
-        get_people     = io.options.dig(:people, :get)
-        partial_update = get_people && get_people.dig(:type) == :partial
-        run_it         = !io.options[:dry_run] || io.options.dig(:post_launch, :run)
-        refresh_data   = !io.options[:dry_run] && partial_update
-        if run_it
-          if refresh_data
-            # get target people afresh
-            people = io.session.micro.people_refresh(people: io.people, include_created: true)
-            io     = io.base.new(people: people)
-          else
-            msg = "Although there are post_launch cases, data will not be refreshed before their run"
-            if io.options[:dry_run]
-              msg += ", because we are in dry-run (simulate)."
-            elsif !partial_update
-              msg += ", because it is not a partial update (-get-partial option not present)."
-            end
-            io.session.logger.warn(msg)
-          end
-        else
-          wf_post.skip!
-          msg = "Although there are post_launch cases, they will NOT be RUN"
-          if io.options[:dry_run]
-            msg+= ", because we are in dry-run (simulate)."
-          end
-          io.session.logger.info(msg)
-        end
-      end
-      io
-    end
-
-    wf.for(:post_launch) do |wf_post|
-
-      wf_post.on(:usecases) do |wf_postcases, io|
-        io.session.post_launch.each do |use|
-          begin
-            io = use.launch(io: io).base
-          rescue Eco::API::UseCases::BaseIO::MissingParameter => e
-            if e.required == :people
-              io.session.logger.debug("Skipping use case '#{use.name}' -- no base people detected for the current run")
-            else
-              raise
-            end
-          end
-        end
-        io
-      end
-
-      wf_post.on(:launch_jobs) do |wf_postlaunch, io|
-        io.session.jobs_launch(simulate: io.options[:dry_run])
-        io
-      end
-    end
-
-    wf.on(:report) do |wf_report, io|
-      io.tap do |_io|
-        if file = io.options.dig(:report, :people, :csv)
-          io.options.deep_merge!(export: {
-            options: {internal_names: true, nice_header: true, split_schemas: true},
-            file: {name: file, format: :csv}
-          })
-          aux_io = io.new(people: io.people.updated_or_created)
-          io.session.process_case("to-csv", io: aux_io, type: :export)
-        end
-      end
-    end
-
-    wf.on(:end) do |wf_end, io|
-      get_people     = io.options.dig(:people, :get)
-      partial_update = get_people && get_people.dig(:type) == :partial
-
-      unless !io.options[:end_get] || io.options[:dry_run] || partial_update
-        people_update_cases = config.usecases.active(io: io).any? do |usecase, data|
-          [:transform, :sync].any? {|type| usecase.type == type}
-        end
-
-        if !people_update_cases
-          # Prevent getting people when there were no use cases that used them
-          io.session.logger.info("Won't be recaching people, as there haven't been any targetted updates")
-        elsif !io.people
-          people = io.session.micro.people_cache
-          io     = io.new(people: people)
-        end
-      end
-      io
-    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'