eco-helpers 2.0.12 → 2.0.17

data/lib/eco/cli.rb

@@ -23,16 +23,6 @@ module Eco
     def run(session:)
       io = Eco::API::UseCases::BaseIO.new(session: session, options: options)
       session.workflow(io: io).run(io: io)
-      #session.workflow(io: io) do |wf, io|
-      #  io = wf.run(:options, io: io)
-      #  io = wf.run(:load, io: io)
-      #  io = wf.run(:usecases, io: io)
-      #  io = wf.run(:launch_jobs, io: io)
-      #  io = wf.run(:post_launch, io: io)
-      #  io = wf.run(:report, io: io)
-      #  io = wf.run(:end, io: io)
-      #  io = wf.run(:close, io: io)
-      #end
     end
 
   end

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

@@ -1,6 +1,6 @@
 ASSETS.cli.config do |cnf|
   cnf.options_set do |options_set, options|
-    options_set.add("--help", "offers a help") do |options, sesssion|
+    options_set.add("--help", "Offers a HELP") do |options, sesssion|
       conf = ASSETS.cli.config
       puts conf.people_filters.help if hpf = SCR.get_arg("-filters")
       puts conf.input_filters.help  if hif = SCR.get_arg("-input-filters")
@@ -11,12 +11,14 @@ ASSETS.cli.config do |cnf|
         "  -filters       to display available filters on people",
         "  -input-filters to display available filters on input data",
         "  -options       to dislpay available options",
-        "  -usecases      to display available usecases"
+        "  -usecases      to display available usecases",
+        "",
+        "You may specify the usecase to know its specific options by: -usecase_name --help -options"
       ].join("\n") unless hpf || hif || ho || huc
       exit
     end
 
-    desc = "fix the current session to work with this schema"
+    desc = "Fix the current session to work with this schema"
     options_set.add("-schema-id", desc) do |options, session|
       sch_name = SCR.get_arg("-schema-id", with_param: true)
       sch_id   = session.schemas.to_id(sch_name)
@@ -33,67 +35,67 @@ ASSETS.cli.config do |cnf|
       session.schema = sch_id
     end
 
-    desc = "deprecated: used to be used to specify the input file when using -get-partial"
+    desc = "Deprecated: used to be used to specify the input file when using -get-partial"
     options_set.add("-entries-from", desc) do |options, session|
       options.deep_merge!(input: {entries_from: true})
     end
 
-    desc = "locally cache all the people manager by retrieving from the server"
+    desc = "Locally cache all the people manager by retrieving from the server"
     options_set.add("-get-people", desc) do |options, session|
       options.deep_merge!(people: {
         get: {from: :remote, type: :full}
       })
     end
 
-    options_set.add(["-dry-run", "-simulate"], "runs in dry-run (no requests sent to server)") do |options, session|
+    options_set.add(["-dry-run", "-simulate"], "Runs in dry-run (no requests sent to server)") do |options, session|
       options[:dry_run]  = true
       options[:simulate] = true
       session.config.dry_run!
     end
 
-    desc = "ignores threshold limitations on requests for this session (skip batch belt)"
+    desc = "Ignores threshold limitations on requests for this session (skip batch belt)"
     options_set.add("-skip-batch-policy", desc) do |options|
       options.deep_merge!(skip: {batch_policy: true})
     end
 
-    desc = "will not run the api policies defined for the enviro"
+    desc = "Will not run the api policies defined for the enviro"
     options_set.add("-skip-api-policies", desc) do |options|
       options.deep_merge!(skip: {api_policies: true})
     end
 
-    options_set.add("-feed-only-stats", "shows only stats when giving feedback") do |options|
+    options_set.add("-feed-only-stats", "Shows only stats when giving feedback") do |options|
       options.deep_merge!(feedback: {only_stats: true})
     end
 
-    desc = "deprecated: used to be used to avoid reloading people after launch"
+    desc = "Deprecated: used to be used to avoid reloading people after launch"
     options[:end_get] = true
     options_set.add("-no-get", desc) do |options|
       options[:end_get] = false
     end
 
-    desc  = "force search mode to 'strict' when pairing input entries with existing people."
+    desc  = "Force search mode to 'strict' when pairing input entries with existing people."
     desc += " Besides id and external_id it will not try to find by email unless external_id is not specified"
     options_set.add("-search-strict", desc) do |options|
       options.deep_merge!(search: {strict: true})
     end
 
-    desc  = "search mode that will try to find people using email when id and external_id have failed"
+    desc  = "Search mode that will try to find people using email when id and external_id have failed"
     desc += " This option could identify existing people by their email addresses"
     desc += " (it should not be used in orgs where multiple people usually have the same email address)"
     options_set.add("-search-soft", desc) do |options|
       options.deep_merge!(search: {soft: true, strict: false})
     end
 
-    desc = "silence notifications on account creation or invites"
+    desc = "Silence notifications on account creation or invites"
     options_set.add(["-no-invites", "-exclude-invites"], desc) do |options|
       options.merge!(send_invites: false)
     end
-    desc = "people with account will be reinvited if they haven't accepted the invitation"
+    desc = "People with account will be reinvited if they haven't accepted the invitation"
     options_set.add("-send-invites", desc) do |options|
       options.merge!(send_invites: true)
     end
 
-    options_set.add("-exclude-core", "core input data is not used on the update") do |options|
+    options_set.add("-exclude-core", "Core input data is not used on the update") do |options|
       options.deep_merge!(exclude: {core: true})
     end
     options_set.add("-exclude-filter-tags", "filter_tags is not set with the input data") do |options|
@@ -112,11 +114,11 @@ ASSETS.cli.config do |cnf|
       options.deep_merge!(exclude: {name: true})
     end
 
-    options_set.add("-exclude-details", "details are not set with the input data") do |options|
+    options_set.add("-exclude-details", "Details are not set with the input data") do |options|
       options.deep_merge!(exclude: {details: true})
     end
 
-    options_set.add("-exclude-account", "account is not set with the input data") do |options|
+    options_set.add("-exclude-account", "Account is not set with the input data") do |options|
       options.deep_merge!(exclude: {account: true})
     end
     options_set.add("-exclude-policy-groups", "policy_group_ids is not set with the input data") do |options|

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

@@ -52,7 +52,7 @@ ASSETS.cli.config do |cnf|
 
     desc = "only those that have ALL the specified tags separated by '|'"
     filters.add("-filter-tags-all", desc) do |people, session, options|
-      tags = SCR.get_arg("-filter-tags-all", with_param: true).upcase.split("|")
+      tags = SCR.get_arg("-filter-tags-all", with_param: true).upcase.split("|").compact
       options.deep_merge!(input: {filter: {filter_tags: {any: tags}}})
       people.filter_tags_all(tags).tap do |filtered|
         msg = "Filtered #{filtered.count} people (out of #{people.count}) with 'all' filter_tags #{tags}"
@@ -62,7 +62,7 @@ ASSETS.cli.config do |cnf|
 
     desc = "only those that have ANY the specified tags separated by '|'"
     filters.add("-filter-tags-any", desc) do |people, session, options|
-      tags = SCR.get_arg("-filter-tags-any", with_param: true).upcase.split("|")
+      tags = SCR.get_arg("-filter-tags-any", with_param: true).upcase.split("|").compact
       options.deep_merge!(input: {filter: {filter_tags_any: tags}})
       people.filter_tags_any(tags).tap do |filtered|
         msg = "Filtered #{filtered.count} people (out of #{people.count}) with 'any' filter_tags #{tags}"
@@ -72,7 +72,7 @@ ASSETS.cli.config do |cnf|
 
     desc = "only those that have ANY tag in the specified subtrees separated by '|'"
     filters.add("-filter-tags-tree", desc) do |people, session, options|
-      top_tags = SCR.get_arg("-filter-tags-tree", with_param: true).upcase.split("|")
+      top_tags = SCR.get_arg("-filter-tags-tree", with_param: true).upcase.split("|").compact
       tags     = top_tags.each_with_object([])  do |top, tags|
         tags.concat(session.tagtree.node(top).tags)
       end.uniq

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

@@ -1,27 +1,72 @@
 ASSETS.cli.config do |cnf|
   cnf.usecases do |cases|
 
+    desc = "Draws the Supervisors hiearchy in a file"
+    cases.add("-supers-hierarchy", :export, desc, case_name: "supers-hierarchy") do |people, session, options|
+      options.deep_merge!(output: {file: "supers_hierarchy.txt"}) unless options.dig(:output, :file)
+    end.add_option("-to", "Specify the output file") do |options|
+      file = SCR.get_file("-to", required: true, should_exist: false)
+      options.deep_merge!(output: {file: file})
+    end
+
+    desc = "Draws the Cyclic Supervisors when identified"
+    cases.add("-identify-cyclic-supers", :export, desc, case_name: "identify-cyclic-supers") do |people, session, options|
+      options.deep_merge!(output: {file: "cyclic_supers.txt"}) unless options.dig(:output, :file)
+    end.add_option("-to", "Specify the output file") do |options|
+      file = SCR.get_file("-to", required: true, should_exist: false)
+      options.deep_merge!(output: {file: file})
+    end
+
+    desc = "Abstracts the Abilities that each Usergroup should probably have"
+    cases.add("-abstract-policygroup-abilities", :export, desc, case_name: "abstract-policygroup-abilities") do |people, session, options|
+      options.deep_merge!(output: {file: "suggested_usergroup_abilities.txt"}) unless options.dig(:output, :file)
+    end.add_option("-to", "Specify the output file") do |options|
+      file = SCR.get_file("-to", required: true, should_exist: false)
+      options.deep_merge!(output: {file: file})
+    end
+
+    desc = "Provides a set of tools to analyse a set of people (i.e. detect duplicates)"
+    cases.add("-analyse-people", :export, desc, case_name: "-analyse-people") do |people, session, options|
+      options.deep_merge!(output: {file: "people_analysis.txt"}) unless options.dig(:output, :file)
+    end.add_option("-to", "Specify the output file") do |options|
+      file = SCR.get_file("-to", required: true, should_exist: false)
+      options.deep_merge!(output: {file: file})
+    end
+
     desc = "It exports to a CSV the (filtered) people"
     cases.add("-people-to-csv", :export, desc) do |people, session, options|
       file = SCR.get_file("-people-to-csv", required: true, should_exist: false)
       options.deep_merge!(export: {file: {name: file, format: :csv}})
-      options.deep_merge!(export: {options: {nice_header: true}}) if SCR.get_arg("-nice-header")
 
-      case_name = SCR.get_arg("-detailed")? "to-csv-detailed" : "to-csv"
+      case_name = options.dig(:export, :options, :detailed) ? "to-csv-detailed" : "to-csv"
       session.usecases.case(case_name)
+    end.add_option("-nice-header", "Outputs more descriptive standard headers") do |options|
+      options.deep_merge!(export: {options: {nice_header: true}})
+    end.add_option("-internal-names", "It is the most raw export. Useful to see all the data when name mappings override/overlap") do |options|
+      options.deep_merge!(export: {options: {internal_names: true}})
+    end.add_option("-detailed", "Includes much more information to the file (i.e. permissions_merged abilities, preferences)") do |options|
+      options.deep_merge!(export: {options: {detailed: true}})
+    end.add_option("-permissions-custom", "Used with -detailed. Adds the permissions_custom abilities") do |options|
+      options.deep_merge!(export: {options: {permissions_custom: true}})
     end
 
     desc = "Adds a column 'ecoPortalTag' to the input CSV with the tags that the location codes map to"
-    cases.add("-codes-to-tags-from", :other, desc, case_name: "codes-to-tags-from") do |session, options|
+    cases.add("-codes-to-tags-from", :other, desc, case_name: "codes-to-tags-from")
+    .add_option("-codes-to-tags-from", "Specify the input 'csv' file") do |options|
       file = SCR.get_file("-codes-to-tags-from", required: true, should_exist: true)
       options.deep_merge!(other: {file: {name: file, format: :csv}})
-
+    end.add_option("-column", "Specify the input column header with the codes") do |options|
       col_codes = SCR.get_arg("-column", with_param: true)
       options.deep_merge!(other: {file: {codes_column: col_codes}})
     end
 
-    desc = "Removes the landing page"
+    desc = "Removes the landing page or sets it to -page-id"
     cases.add("-reset-landing-page", :transform, desc, case_name: "reset-landing-page")
+    .add_option("-page-id", "Target landing page to set to the users") do |options|
+      SCR.get_arg("-page-id", with_param: true).tap do |new_id|
+        options.deep_merge!({page_id: new_id})
+      end
+    end
 
     desc = "Sets as external_id the email of the person"
     cases.add("-email-as-id", :transform, desc, case_name: "email-as-id")
@@ -36,23 +81,29 @@ ASSETS.cli.config do |cnf|
 
     desc = "Sets the supervisor_id"
     cases.add("-set-supervisor-from", :sync, desc, case_name: "set-supervisor")
+
     desc = "Sets to -new-super the supervisor_id of the -old-super's subordinates"
     cases.add("-switch-supervisor", :transform, desc, case_name: "switch-supervisor") do |people, session, options|
-      unless old_id = SCR.get_arg("-old-super", with_param: true)
+      unless options[:super]&.key?(:old)
         msg = "You must specify an -old-super to target whose supervisor is changing"
         session.logger.error(msg)
         exit(1)
       end
-
-      options.deep_merge!(super: {old: old_id})
-
-      unless new_id = SCR.get_arg("-new-super", with_param: true)
+      unless options[:super]&.key?(:new)
         msg = "You must specify the -new-super id. To reset to nil the supervisor, please, specify nil."
         session.logger.error(msg)
         exit(1)
       end
-      new_id = new_id == "nil"? nil : new_id
-      options.deep_merge!(super: {new: new_id})
+    end.add_option("-old-super", "The supervisor id to be replaced on the subordinates") do |options|
+      if old_id = SCR.get_arg("-old-super", with_param: true)
+        old_id = old_id == "nil"? nil : old_id
+        options.deep_merge!(super: {old: old_id})
+      end
+    end.add_option("-new-super", "The new supervisor id") do |options|
+      if new_id = SCR.get_arg("-new-super", with_param: true)
+        new_id = new_id == "nil"? nil : new_id
+        options.deep_merge!(super: {new: new_id})
+      end
     end
 
     desc  = "Usage '-org-data-convert backup.json -restore-db-from'."
@@ -65,15 +116,15 @@ ASSETS.cli.config do |cnf|
         session.logger.info("Source DB: loaded #{input.length} entries.")
       end
 
-      if source_enviro = SCR.get_arg("-source-enviro", with_param: true)
-        options.merge!(source_enviro: source_enviro)
-      else
+      unless options[:source_enviro]
         session.logger.error("You need to specify a -source-enviro for the conversion to work out")
         exit(1)
       end
 
-      options.deep_merge!(ignore: {missing: {policy_groups: true}}) if SCR.get_arg("-ignore-missing-policy-groups")
-      
+    end.add_option("-source-enviro", "The defined -source-enviro API configuration that the backup file was generated from") do |options|
+      options.merge!(source_enviro: SCR.get_arg("-source-enviro", with_param: true))
+    end.add_option("-ignore-missing-policy-groups", "Prevents the script to crash when backup file has missing usergroups in the org") do |options|
+      options.deep_merge!(ignore: {missing: {policy_groups: true}})
     end
 
     desc = "Restores the people manager by using a backup.json file"
@@ -83,13 +134,15 @@ ASSETS.cli.config do |cnf|
         input = Eco::API::Organization::People.new(JSON.parse(File.read(file)))
         session.logger.info("Source DB: loaded #{input.length} entries.")
       end
-
-      options.deep_merge!(include: {delete: true}) if SCR.get_arg("-include-delete")
-      options.deep_merge!(include: {create: true}) if SCR.get_arg("-include-create")
+    end.add_option("-include-delete", "If it should DELETE people that do not exist in the backup file") do |options|
+      options.deep_merge!(include: {delete: true})
+    end.add_option("-include-create", "If it should CREATE people that do not exist in the people manager") do |options|
+      options.deep_merge!(include: {create: true})
     end
 
     desc = "Re-sends invites to all filtered users that have not accepted the invite as yet"
     cases.add("-reinvite", :transform, desc, case_name: "reinvite")
+
     desc = "Re-sends invites to target users that have not accepted the invite as yet"
     cases.add("-reinvite-from", :sync, desc, case_name: "reinvite")
 
@@ -112,8 +165,6 @@ ASSETS.cli.config do |cnf|
 
     desc = "It just adds everybody to an update job without doing any change. If the org has policies, it will refresh"
     cases.add("-refresh", :transform, desc, case_name: "refresh")
-    desc = "Remaps the abilities of every user based on their usergroups mappings thereof in the org api configuration"
-    cases.add("-refresh-abilities", :transform, desc, case_name: "refresh-abilities")
 
     desc = "Updates details and core (including supervisor) to target people"
     cases.add("-update-details-from", :sync, desc, case_name: "update-details")
@@ -123,9 +174,10 @@ ASSETS.cli.config do |cnf|
     desc = "Updates the people specified in the input data"
     cases.add("-update-from", :sync, desc, case_name: "update")
 
-    desc = "Does an actual transfer of user from id|external_id account to 'destination-id' person"
-    cases.add("-transfer-account-from", :sync, desc, case_name: "transfer-account") do |input, people, session, options|
-      options.deep_merge!(include: {email: SCR.get_arg("-include-email")})
+    desc = "Does an actual transfer of USER from id|external_id account to 'destination-id' person"
+    cases.add("-transfer-account-from", :sync, desc, case_name: "transfer-account")
+    .add_option("-include-email", "Specifies if the email should also be moved. Otherwise it only moves the account") do |options|
+      options.deep_merge!(include: {email: true})
     end
 
     desc = "Tries to find the input entries and update them. It creates them if not found"

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

@@ -2,8 +2,13 @@ ASSETS.cli.config do |config|
   ASSETS.config.workflow do |wf|
 
     io = nil
+    rescued = false
+
     # default rescue
     wf.rescue do |exception, io|
+      next io if rescued
+      rescued = true
+
       io.session.logger.debug(exception.patch_full_message)
       wf.run(:close, io: io)
       io
@@ -24,7 +29,7 @@ ASSETS.cli.config do |config|
           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]
+            opt_case = cases_with_input.values.first.option
             io = io.new(input: config.input.get(io: io, option: opt_case))
           end
           io

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

@@ -16,6 +16,7 @@ module Eco
         # Creatas a well aligned line
         def help_line(key, desc, keys_max_len = key.length, line_len = 100)
           blanks    = keys_max_len + 3 - key.length
+          blanks    = blanks < 0 ? 0 : blanks
           top_line  = "  #{key}#{" "*blanks} "
           indent    = top_line.length
           first     = true

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

@@ -5,31 +5,53 @@ module Eco
         include Eco::CLI::Config::Help
         attr_reader :core_config
 
+        class OptConfig < Struct.new(:name, :namespace, :description, :callback)
+        end
+
         def initialize(core_config:)
           @core_config = core_config
-          @options_set = {}
-          @description = {}
+          @sets        = {}
         end
 
         # @return [String] summary of the options.
         def help
+          indent = 2
+          spaces = any_non_general_space_active? ? active_namespaces : namespaces
+
           ["The following are the available options:"].yield_self do |lines|
-            max_len = keys_max_len(@options_set.keys)
-            @options_set.keys.each do |key|
-              lines << help_line(key, @description[key], max_len)
+            max_len = keys_max_len(options_args(spaces)) + indent
+            spaces.each do |namespace|
+              is_general = (namespace == :general)
+              str_indent = is_general ? "" : " " * indent
+              lines << help_line(namespace, "", max_len) unless is_general
+              options_set(namespace).each do |arg, option|
+                lines << help_line(" " * indent + "#{option.name}", option.description, max_len)
+              end
             end
             lines
           end.join("\n")
         end
 
-        # @param option [String] the command line option.
+        # @return [Array<String>] all the argument of the options in `namespaces`
+        def options_args(namespaces)
+          namespaces.each_with_object([]) do |space, args|
+            args.concat(options_set(space).keys)
+          end.uniq
+        end
+
+        # @param option [String, Array<String>] the command line option(s).
+        # @param namespace [String] preceding command(s) argument that enables this option.
         # @param desc [String] description of the option.
-        def add(option, desc = nil)
+        def add(option, desc = nil, namespace: :general)
           raise "Missing block to define the options builder" unless block_given?
-          callback = Proc.new
-          [option].flatten.compact.each do |opt|
-            @options_set[opt] = callback
-            @description[opt] = desc
+
+          opts = [option].flatten.compact
+          unless opts.empty?
+            callback = Proc.new
+            opts.each do |opt|
+              puts "Overriding option '#{option}' in '#{namespace}' namespace" if option_exists?(opt, namespace)
+              options_set(namespace)[opt] = OptConfig.new(opt, namespace, desc, callback)
+            end
           end
           self
         end
@@ -39,12 +61,83 @@ module Eco
             raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
           end
 
-          @options_set.each do |arg, callback|
-            callback.call(io.options, io.session) if SCR.get_arg(arg)
+          active_options.each do |option|
+            option.callback.call(io.options, io.session)
           end
+
           io.options
         end
 
+        def active_options
+          @active_options ||= sets.select do |namespace, opts_set|
+            active_namespace?(namespace)
+          end.each_with_object([]) do |(namespace, opts_set), options|
+            opts_set.each do |arg, option|
+              options << option if active_option?(arg, namespace)
+            end
+          end
+        end
+
+        def all_options
+          sets.each_with_object([]) do |(namespace, opts_set), options|
+            options << opts_set.values
+          end
+        end
+
+        def namespaces
+          sets.keys.sort_by do |key|
+            key == :general
+          end
+        end
+
+        def any_non_general_space_active?
+          (active_namespaces - [:general]).length > 0
+        end
+
+        def active_namespaces
+          @active_namespaces ||= [].tap do |active|
+            active << :general
+            other = (namespaces - [:general]).select {|nm| SCR.arg?(nm)}
+            active.concat(other)
+          end
+        end
+
+
+        private
+
+        def active_namespace?(namespace)
+          (namespace == :general) || SCR.get_arg(namespace)
+        end
+
+        # Is the option active?
+        #   1. If :general namespace, it does just a direct check
+        #   2. Otherwise, the `namespace` wording should come first in the `cli` or it is considered inactive
+        def active_option?(opt, namespace = :general)
+          if namespace == :general
+            SCR.get_arg(opt)
+          else
+            active_namespace?(namespace) && SCR.arg_order?(namespace, opt) && SCR.get_arg(opt)
+          end
+        end
+
+        def option_exists?(opt, namespace = :general)
+          options_set(namespace).key?(opt)
+        end
+
+        def sets
+          @sets ||= {
+            general: {}
+          }
+        end
+
+        def namespaces
+          @sets.keys
+        end
+
+        def options_set(namespace = :general)
+          @sets[namespace] ||= {}
+        end
+
       end
     end
   end