eco-helpers 2.0.16 → 2.0.22

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,20 @@ 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 = "Redirect Standard Ouput to file"
+    options_set.add("-stdout", desc) do |options, session|
+      file = SCR.get_arg("-stdout", with_param: true) || "output.txt"
+      STDOUT.reopen(file, "w+")
+    end
+
+    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 +41,90 @@ 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  = "Used to be used to specify the input file or folder when using -get-partial."
+    desc += "It can also be useful to obtain `-get-partial` of people base on `:export` use cases (i.e. -people-to-csv)"
     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  = "Used to only get the people from the input file. It will also include their current and new supervisors."
+    options_set.add("-get-partial", desc) do |options, session|
+      options.deep_merge!(people: {
+        get: {from: :remote, type: :partial}
+      })
+    end
+
+    desc  = "Do not load any people for this run."
+    options_set.add("-no-people", desc) do |options, session|
+      options.deep_merge!(people: {get: false})
+    end
+
+    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|
+    desc  = "Used to specify the cache file of people to be used. "
+    desc += "It is useful to use as people reference those stored in cached file diffrent to the last one."
+    options_set.add("-people-from-backup", desc) do |options, session|
+      file = SCR.get_file("-people-from-backup", required: true, should_exist: true)
+      options.deep_merge!(people: {
+        get: {from: :local, type: :file, file: file}
+      })
+    end
+
+    desc  = "Runs in dry-run (no requests sent to server)"
+    options_set.add(["-dry-run", "-simulate"], desc) 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 +143,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.rb

@@ -1,29 +1,23 @@
 ASSETS.cli.config do |cnf|
   cnf.people do |input, session, options|
-    people = Eco::API::Organization::People.new([])
-    if SCR.get_arg("-get-people")
-      options.deep_merge!(people: {
-        get: {from: :remote, type: :full}
-      })
-      people = session.micro.people_cache
-    elsif SCR.get_arg("-no-people")
-      people = Eco::API::Organization::People.new([])
-    elsif SCR.get_arg("-people-from-backup")
-      file = SCR.get_arg("-people-from-backup", with_param: true)
-      options.deep_merge!(people: {
-        get: {from: :local, type: :backup}
-      })
-      people = JSON.parse(File.read(file))
-      people = Eco::API::Organization::People.new(people)
-    elsif SCR.get_arg("-get-partial")
-      unless input && input.is_a?(Enumerable)
+    get = options.dig(:people, :get) || {}
+    case
+    when get == false
+      Eco::API::Organization::People.new([])
+    when (get[:from] == :remote) && get[:type] == :full
+      # -get-people
+      session.micro.people_cache
+    when (get[:from] == :remote) && get[:type] == :partial
+      # -get-partial
+      unless (input && input.is_a?(Enumerable))
         raise "To use -get-partial (partial updates), you need to use -entries-from"
       end
-      options.deep_merge!(people: {
-        get: {from: :remote, type: :partial}
-      })
-
-      people = session.micro.people_search(input, options: options)
+      session.micro.people_search(input, options: options)
+    when (get[:from] == :local)  && get[:type] == :file
+      # -people-from-backup
+      session.micro.people_load(get[:file], modifier: :file)
+      #people = JSON.parse(File.read(get[:file]))
+      #Eco::API::Organization::People.new(people)
     else
       options.deep_merge!(people: {
         get: {from: :local, type: :full}
@@ -33,9 +27,9 @@ ASSETS.cli.config do |cnf|
         options.deep_merge!(people: {
           get: {from: :remote, type: :full}
         })
-        people = session.micro.people_cache if people.empty?
+        people = session.micro.people_cache
       end
+      people
     end
-    people
   end
 end

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,45 +1,103 @@
 ASSETS.cli.config do |cnf|
   cnf.usecases do |cases|
 
-    desc = "Draws the Supervisors hiearchy in a file (use option -to file.ext)"
+    desc = "Draws the Supervisors hiearchy in a file"
     cases.add("-supers-hierarchy", :export, desc, case_name: "supers-hierarchy") do |people, session, options|
-      file = (SCR.get_arg("-to") && SCR.get_file("-to", required: true, should_exist: false)) || "supers_hierarchy.txt"
+      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 (use option -to file.ext)"
+    desc = "Draws the Cyclic Supervisors when identified"
     cases.add("-identify-cyclic-supers", :export, desc, case_name: "identify-cyclic-supers") do |people, session, options|
-      file = (SCR.get_arg("-to") && SCR.get_file("-to", required: true, should_exist: false)) || "supers_hierarchy.txt"
+      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 (use option -to file.ext)"
+    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|
-      file = (SCR.get_arg("-to") && SCR.get_file("-to", required: true, should_exist: false)) || "suggested_abilities.txt"
+      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)
+      #unless options.dig(:usecase, :analyse_people, :use_field)
+      #  options.deep_merge!(usecase: {analyse_people: {use_field: :name}})
+      #end
+    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.add_option("-identify-duplicates", "Generates a list of people with possible duplicates.") do |options|
+      options.deep_merge!(usecase: {analyse_people: {identify_duplicates: true}})
+    end.add_option("-use-field", "Works with -identify-duplicates. Sets field to be used in the comparison.") do |options|
+      expression = SCR.get_arg("-use-field", with_param: true)
+      options.deep_merge!(usecase: {analyse_people: {use_field: expression}})
+    end.add_option("-facet-field", "Works with -identify-duplicates. Adds an additional layer of comparison.") do |options|
+      expression = SCR.get_arg("-facet-field", with_param: true)
+      options.deep_merge!(usecase: {analyse_people: {facet_field: expression}})
+    end.add_option("-only-screening", "Works with -identify-duplicates. Skips the rearrangement stage.") do |options|
+      options.deep_merge!(usecase: {analyse_people: {only_screening: true}})
+    end.add_option("-ignore-matching-words", "Works with -identify-duplicates. Re-adjust scores ignoring matching words.") do |options|
+      options.deep_merge!(usecase: {analyse_people: {ignore_matching_words: true}})
+    end.add_option("-unique-words", "Works with -identify-duplicates. Re-adjust the comparing strings to do not have repeated words.") do |options|
+      options.deep_merge!(usecase: {analyse_people: {unique_words: true}})
+    end.add_option("-identify-unnamed", "Identifies all people with no names.") do |options|
+      options.deep_merge!(usecase: {analyse_people: {identify_unnamed: true}})
+    end.add_option("-backup-people-results", "Generates a json file with all the people involved in the final results of the analysis.") do |options|
+      file = SCR.get_file("-backup-people-results", required: true, should_exist: false)
+      options.deep_merge!(usecase: {analyse_people: {backup_people: File.expand_path(file)}})
+    end.add_option("-to-csv", "Genarates a CSV file with all people of the final results.") do |options|
+      file = SCR.get_file("-to-csv", required: true, should_exist: false) || "Results.csv"
+      options.deep_merge!(usecase: {analyse_people: {csv_file: File.expand_path(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")
-      options.deep_merge!(export: {options: {internal_names: true}})  if SCR.get_arg("-internal-names")
-      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.add_option("-split-schemas", "It will generate 1 file per each schema") do |options|
+      options.deep_merge!(export: {options: {split_schemas: 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  = "Cleans from filter_tags those tags that are not present in the tagtree (as per tagtree.json file)."
+    desc += " It will preserve standard register tags of most common registers (i.e. EVENT, RISK)."
+    cases.add("-clean-unknown-tags", :transform, desc, case_name: "clean-unknown-tags")
+
+    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")
@@ -54,23 +112,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'."
@@ -83,15 +147,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"
@@ -101,13 +165,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")
 
@@ -130,8 +196,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")
@@ -141,9 +205,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

@@ -6,11 +6,15 @@ ASSETS.cli.config do |config|
 
     # 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)
+      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
 
@@ -24,12 +28,15 @@ ASSETS.cli.config do |config|
           cases_with_input =  config.usecases.active(io: io).select do |usecase, data|
             io.class.input_required?(usecase.type)
           end
-          next io unless (!io.input || io.input.empty?) && !cases_with_input.empty?
+
+          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]
+            opt_case = cases_with_input.values.first.option
             io = io.new(input: config.input.get(io: io, option: opt_case))
           end
           io
@@ -46,8 +53,7 @@ ASSETS.cli.config do |config|
           cases_with_people = config.usecases.active(io: io).select do |usecase, data|
             io.class.people_required?(usecase.type)
           end
-          get_people = io.options.dig(:people, :get, :from) == :remote
-          next io unless !cases_with_people.empty? || get_people
+          next io if cases_with_people.empty? && !io.options.dig(:people, :get)
           io = io.new(people:  config.people(io: io))
         end
 
@@ -60,7 +66,8 @@ ASSETS.cli.config do |config|
 
     wf.before(:usecases) do |wf_cases, io|
       # save partial entries -> should be native to session.workflow
-      partial_update = io.options.dig(:people, :get, :type) == :partial
+      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)
@@ -91,11 +98,12 @@ ASSETS.cli.config do |config|
       if io.session.post_launch.empty?
         wf_post.skip!
       else
-        partial_update = io.options.dig(:people, :get, :type) == :partial
+        get_people     = io.options.dig(:people, :get)
+        partial_update = get_people && get_people.dig(:type) == :partial
         if !io.options[:dry_run] && partial_update
           # get target people afresh
           people = io.session.micro.people_refresh(people: io.people, include_created: true)
-          io     = io.new(people: people)
+          io     = io.base.new(people: people)
         else
           wf_post.skip!
           msg = "Although there are post_launch cases, they will NOT be RUN"
@@ -132,7 +140,8 @@ ASSETS.cli.config do |config|
     end
 
     wf.on(:end) do |wf_end, io|
-      partial_update = io.options.dig(:people, :get, :type) == :partial
+      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 = io.session.micro.people_cache
         io     = io.new(people: people)