eco-helpers 2.0.13 → 2.0.18

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

@@ -1,53 +1,79 @@
-class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::UseCases::DefaultCases::ToCsvCase
   name "to-csv-detailed"
   type :export
 
-  def main(people, session, options, usecase)
-    unless people && !people.empty?
-      session.logger.warn("No source people to create the file... aborting!")
-      return false
-    end
+  private
+
+  def to_row(person)
+    entry = to_entry_type(person)
+    data = entry.values_at(*keys(entry))
+    data << person.subordinates
+    data << person_supervisor(person)
+    data += user_abilities(person)
+    data += user_permissions_custom(person) if options.dig(:export, :options, :permissions_custom)
+    account = person.account
+    data << account&.landing_page_id
+    data += user_preferences(person)
+    data
+  end
 
-    unless file = options[:file] || options.dig(:export, :file, :name)
-      session.logger.error("Destination file not specified")
-      return false
+  def person_supervisor(person)
+    session.micro.with_supervisor(person.supervisor_id, people) do |supervisor|
+      return supervisor ? supervisor.name : ""
     end
+  end
 
-    login_providers = session.login_providers
-    abilities       = session.presets_factory.keys
+  def user_abilities(person)
+    account_abilities = (person.account && person.account.permissions_merged) || {}
+    abilities.map {|key| account_abilities[key] || "no access"}
+  end
 
-    session.logger.info("going to create file: #{file}")
-    CSV.open(file, "w") do |csv|
-      deps    = {"supervisor_id" => {people: people}}
+  def user_permissions_custom(person)
+    account_abilities = (person.account && person.account.permissions_custom) || {}
+    abilities.map {|key| account_abilities[key] || "no access"}
+  end
 
-      person_model = people.first
-      person_entry = session.new_entry(person_model, dependencies: deps)
-      header  = person_entry.external_entry.keys
-      header += ["Subordinates"]
-      header += ["Supervisor Name"]
-      header += abilities
-      header += ["Landing Page"]
+  def user_preferences(person)
+    user_preferences = (person.account && person.account.preferences&.doc) || {}
+    preferences.map {|key| user_preferences[key] || false}
+  end
 
-      csv << header
-      people.each do |person|
-        data = session.new_entry(person, dependencies: deps).external_entry.values
+  def spot_header
+    super do |header|
+      header << "Subordinates"
+      header << "Supervisor Name"
+      header += abilities_header
+      header += abilities_header("custom") if options.dig(:export, :options, :permissions_custom)
+      header << "Landing Page"
+      header += preferences
+      header
+    end
+  end
 
-        data.push(person.subordinates)
-        session.micro.with_supervisor(person.supervisor_id, people) do |supervisor|
-          data.push supervisor ? supervisor.name : ""
-        end
+  def keys(entry)
+    super(entry) + ["freemium"]
+  end
 
-        person_abilities = (person.account && person.account.permissions_custom) || {}
-        data += abilities.map {|key| person_abilities[key] || "no access"}
+  def login_providers
+    session.login_providers
+  end
 
-        if person.account && landing_id = person.account.landing_page_id
-          data.push(landing_id)
-        end
+  def abilities
+    @abilities ||= session.presets_factory.keys
+  end
 
-        csv << data
-      end
+  def abilities_header(prefix = nil)
+    abilities.map do |key|
+      prefix ? "#{prefix}_#{key}" : key
     end
-    exit(0)
+  end
+
+  def preferences
+    @preferences ||= [
+      "show_sidebar", "show_shortcuts", "show_coming_soon", "show_recently_visited_forms",
+      "show_tasks", "show_task_bubbles",
+      "kiosk_enabled"
+    ]
   end
 
 end

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"