eco-helpers 3.0.4 → 3.0.6

data/lib/eco/cli/scripting/args_helpers.rb

@@ -30,7 +30,8 @@ module Eco
             all_available: all_available
           }
           unknown = arguments.unknown(**args) do |key, correct|
-            suggestions[key] = correct unless correct.empty?
+            next suggestions[key] = correct unless correct.empty?
+            suggstions[key] = '-- not known similar options! --'
           end
           unknown = unknown.select {|arg| is_modifier?(arg)} if only_options
 
@@ -38,7 +39,7 @@ module Eco
 
           suggestions_str = suggestions.slice(*unknown).map do |key, correct|
             str      = "Unknown option '#{key}'."
-            str_corr = correct.map {|key| "'#{key}'"}
+            str_corr = correct.map {|ky| "'#{ky}'"}
             str     << " Did you mean: #{str_corr.join(', ')}" unless correct.empty?
             str
           end.join("\n  * ")

data/lib/eco/cli/scripting/argument.rb

@@ -2,12 +2,11 @@ module Eco
   class CLI
     class Scripting
       class Argument
-
         attr_reader :key
 
         class << self
           def is_modifier?(value)
-           value&.start_with?("-")
+            value&.start_with?("-")
           end
         end
 
@@ -19,6 +18,7 @@ module Eco
         def args_slice(*args)
           #pp "known arg '#{key}' => included? #{args.include?(key)}"
           return args unless args.include?(key)
+
           i = args.index(key)
           j = with_param?? i+1 : i
           args - args.slice(i..j)

data/lib/eco/cli_default/input.rb

@@ -21,61 +21,65 @@ ASSETS.cli.config do |cnf|
 
   cnf.input(default_option: "-entries-from") do |session, str_opt, options|
     input = []
-    if SCR.get_arg(str_opt)
-      file = SCR.get_file(str_opt, required: true)
 
-      # Command line check
-      format = formats.reduce(nil) do |matched, (frm, selectors)|
-        used = selectors[:option].reduce(false) {|us, option| SCR.get_arg(option) || us}
-        next matched if matched
-        next frm     if used
-      end
+    next input unless SCR.get_arg(str_opt)
+
+    file = SCR.get_file(str_opt, required: true)
 
-      # File/Folder check
-      file = File.expand_path(file)
-      if File.directory?(file)
-        folder = file
-        file   = Dir.glob("#{file}/*").reject {|f| File.directory?(f)}
-        ext    = (format && formats[format][:extname]) || [File.extname(file.first)]
-        file   = file.select {|f| ext.any? {|e| File.extname(f) == e}}.tap do |files|
-          if files.empty?
-            session.logger.error("Could not find any file with extension: #{ext} in folder '#{folder}'")
-            exit(1)
-          end
+    # Command line check
+    format = formats.reduce(nil) do |matched, (frm, selectors)|
+      used = selectors[:option].reduce(false) {|us, option| SCR.get_arg(option) || us}
+      next matched if matched
+      next frm     if used
+    end
+
+    # File/Folder check
+    file = File.expand_path(file)
+    if File.directory?(file)
+      folder = file
+      file   = Dir.glob("#{file}/*").reject {|f| File.directory?(f)}
+      ext    = (format && formats[format][:extname]) || [File.extname(file.first)]
+      file   = file.select {|f| ext.any? {|e| File.extname(f) == e}}.tap do |files|
+        if files.empty?
+          session.log(:error) {
+            "Could not find any file with extension: #{ext} in folder '#{folder}'"
+          }
+          exit(1)
         end
-      else
-        ext = File.extname(file)
       end
+    else
+      ext = File.extname(file)
+    end
 
-      format ||= formats.reduce(nil) do |matched, (frm, selectors)|
-        next matched if matched
-        next frm     if selectors[:extname].any? {|e| ext == e}
-      end
-      format ||= :csv
+    format ||= formats.reduce(nil) do |matched, (frm, selectors)|
+      next matched if matched
+      next frm     if selectors[:extname].any? {|e| ext == e}
+    end
+    format ||= :csv
 
-      options.deep_merge!(input: {file: {name: file}})
-      options.deep_merge!(input: {file: {format: format}})
+    options.deep_merge!(input: {file: {name: file}})
+    options.deep_merge!(input: {file: {format: format}})
 
-      encoding = options.dig(:input, :file, :encoding)
+    encoding = options.dig(:input, :file, :encoding)
 
-      case format
-      when :xml
-        [file].flatten.each {|f| session.config.files.validate(:xml, f)}
-        kargs = {file: file, format: format}
-        kargs.merge!(encoding: encoding) if encoding
-        input = session.entries(**kargs)
-      when :xls
-        input = session.entries(file: file, format: format)
-      when :json
-        input = [file].flatten.reduce(Eco::API::Organization::People.new([])) do |people, filename|
-          people.merge(JSON.parse(File.read(filename)))
-        end
-      else # :csv
-        kargs = {check_headers: true}
-        kargs.merge!(encoding: encoding) if encoding
-        input = session.csv_entries(file, **kargs)
+    case format
+    when :xml
+      [file].flatten.each {|f| session.config.files.validate(:xml, f)}
+      kargs = {file: file, format: format}
+      kargs.merge!(encoding: encoding) if encoding
+      input = session.entries(**kargs)
+    when :xls
+      input = session.entries(file: file, format: format)
+    when :json
+      input = [file].flatten.reduce(Eco::API::Organization::People.new([])) do |people, filename|
+        people.merge(JSON.parse(File.read(filename)))
       end
+    else # :csv
+      kargs = {check_headers: true}
+      kargs.merge!(encoding: encoding) if encoding
+      input = session.csv_entries(file, **kargs)
     end
+
     input
   end
 end

data/lib/eco/cli_default/input_filters.rb

@@ -1,47 +1,62 @@
 ASSETS.cli.config do |cnf|
   cnf.input_filters do |filters|
-
-    filters.add("-input-filter-tags-all", "only those that have ALL the specified tags separated by '|'") do |input, session, options|
+    desc = "only those that have ALL the specified tags separated by '|'"
+    filters.add("-input-filter-tags-all", desc) do |input, session, options|
       tags = SCR.get_arg("-input-filter-tags-all", with_param: true).upcase.split("|")
+
       options.deep_merge!(input: {filter: {filter_tags: {all: tags}}})
+
       input.filter_tags_all(tags).tap do |filtered|
-        msg = "Filtered #{filtered.count} entries (out of #{input.count}) with 'all' filter_tags #{tags}"
-        session.logger.info(msg)
+        msg  = "Filtered #{filtered.count} entries (out of #{input.count})"
+        msg << " with 'all' filter_tags #{tags}"
+        session.log(:info) { msg }
       end
     end
 
-    filters.add("-input-filter-tags-any", "only those that have ANY the specified tags separated by '|'") do |input, session, options|
+    desc = "only those that have ANY the specified tags separated by '|'"
+    filters.add("-input-filter-tags-any", desc) do |input, session, options|
       tags = SCR.get_arg("-input-filter-tags-any", with_param: true).upcase.split("|")
+
       options.deep_merge!(input: {filter: {filter_tags: {any: tags}}})
+
       input.filter_tags_any(tags).tap do |filtered|
-        msg = "Filtered #{filtered.count} entries (out of #{input.count}) with 'any' filter_tags #{tags}"
-        session.logger.info(msg)
+        msg  = "Filtered #{filtered.count} entries (out of #{input.count})"
+        msg << " with 'any' filter_tags #{tags}"
+        session.log(:info) { msg }
       end
     end
 
-    filters.add("-input-filter-tags-tree", "only those that have ANY tag in the specified subtrees separated by '|'") do |input, session, options|
+    desc = "only those that have ANY tag in the specified subtrees separated by '|'"
+    filters.add("-input-filter-tags-tree", desc) do |input, session, options|
       top_tags = SCR.get_arg("-input-filter-tags-tree", with_param: true).upcase.split("|")
-      tags     = top_tags.each_with_object([])  do |top, tags|
-        tags.concat(session.tagtree.node(top).tags)
+      tags     = top_tags.each_with_object([])  do |top, tgs|
+        tgs.concat(session.tagtree.node(top).tags)
       end.uniq
+
       options.deep_merge!(input: {filter: {filter_tags: {tree: top_tags, any: tags}}})
+
       input.filter_tags_any(tags).tap do |filtered|
-        msg = "Filtered #{filtered.count} entries (out of #{input.count}) with 'any' filter_tags in subtrees #{top_tags}"
-        session.logger.info(msg)
+        msg  = "Filtered #{filtered.count} entries (out of #{input.count})"
+        msg << " with 'any' filter_tags in subtrees #{top_tags}"
+        session.log(:info) { msg }
       end
     end
 
-    filters.add("-input-no-id", "only those that do not have 'id' or 'external_id' specified") do |input, session, options|
+    desc = "only those that do not have 'id' or 'external_id' specified"
+    filters.add("-input-no-id", desc) do |input, _sess, options|
       options.deep_merge!(input: {filter: {external_id: nil}})
+
       input.select do |entry|
-        !!(entry.id || entry.external_id)
-      end.yield_self do |filtered|
+        entry.id || entry.external_id
+      end.then do |filtered|
         input.newFrom filtered
       end
     end
 
-    filters.add("-input-supervisor-id", "only those with certain supervisor id or external_id") do |input, session, options|
-      id     = SCR.get_arg("-input-supervisor-id", with_param: true)
+    desc = "only those with certain supervisor id or external_id"
+    filters.add("-input-supervisor-id", desc) do |input, _sess, options|
+      id = SCR.get_arg("-input-supervisor-id", with_param: true)
+
       options.deep_merge!(input: {filter: {supervisor_id: id}})
       #unless sup = entries.find({"id" => id, "external_id" => id})
       #  raise "Could not find anyone in the input with that id '#{id}'"

data/lib/eco/cli_default/options.rb

@@ -7,18 +7,22 @@ ASSETS.cli.config do |cnf| # rubocop:disable Metrics/BlockLength
         if (there = SCR.get_arg(opt))
           refine = SCR.get_arg(opt, with_param: true)
         end
+
         refine || there
       end
 
       if (hpf = active.call("-filters"))
         puts conf.people_filters.help(refine: hpf)
       end
+
       if (hif = active.call("-input-filters"))
         puts conf.input_filters.help(refine: hif)
       end
+
       if (ho = active.call("-options"))
         puts conf.options_set.help(refine: ho)
       end
+
       if (huc = active.call("-usecases"))
         puts conf.usecases.help(refine: huc)
       end
@@ -64,13 +68,13 @@ ASSETS.cli.config do |cnf| # rubocop:disable Metrics/BlockLength
 
       unless sch_id
         msg = "You need to specify a correct schema id or name. '#{sch_name}' does not exist"
-        session.logger.error(msg)
+        session.log(:error) { msg }
         exit(1)
       end
-
       options.deep_merge!(people: {filter: {details: {schema_id: sch_id}}})
-      session.logger.info("Setting schema #{session.schemas.to_name(sch_id)}")
-
+      session.log(:info) {
+        "Setting schema #{session.schemas.to_name(sch_id)}"
+      }
       session.schema = sch_id
     end
 

data/lib/eco/cli_default/people.rb

@@ -24,7 +24,7 @@ ASSETS.cli.config do |cnf|
         msg  = "(Optimization) "
         msg << "Switching from partial to full people download. "
         msg << "Input (#{input.count}) surpases MAX_GET_PARTIAL (#{MAX_GET_PARTIAL}) entries."
-        session.logger.info(msg)
+        session.log(:info) { msg }
 
         options.deep_merge!(people: {
           get: {

data/lib/eco/cli_default/people_filters.rb

@@ -1,22 +1,21 @@
-ASSETS.cli.config do |cnf|
-  cnf.people_filters do |filters|
-
-    filters.add("-only-users", "only those with account") do |people, session, options|
+ASSETS.cli.config do |cnf| # rubocop:disable Metrics/BlockLength
+  cnf.people_filters do |filters| # rubocop:disable Metrics/BlockLength
+    filters.add("-only-users", "only those with account") do |people, _sess, options|
       options.deep_merge!(people: {filter: {account: true}})
       people.users
     end
 
-    filters.add("-no-account", "only those with no account") do |people, session, options|
+    filters.add("-no-account", "only those with no account") do |people, _sess, options|
       options.deep_merge!(people: {filter: {account: false}})
       people.account_present(false)
     end
 
-    filters.add("-with-details", "only those with details") do |people, session, options|
+    filters.add("-with-details", "only those with details") do |people, _sess, options|
       options.deep_merge!(people: {filter: {details: true}})
       people.details_present
     end
 
-    filters.add("-no-id", "only those with no external_id") do |people, session, options|
+    filters.add("-no-id", "only those with no external_id") do |people, _sess, options|
       options.deep_merge!(people: {filter: {external_id: nil}})
       people.external_id_present(false)
     end
@@ -27,25 +26,29 @@ ASSETS.cli.config do |cnf|
     # end
 
     filters.add("-supervisor-id", "only those with certain supervisor") do |people, session, options|
-      id     = SCR.get_arg("-supervisor-id", with_param: true)
+      id  = SCR.get_arg("-supervisor-id", with_param: true)
       options.deep_merge!(people: {filter: {supervisor_id: id}})
-      unless sup = session.micro.with_supervisor(id, people, strict: true)
+
+      unless (sup = session.micro.with_supervisor(id, people, strict: true))
         status = session.batch.search([{"id" => id}])
         sup    = status.people.first
       end
+
       unless sup
-        session.logger.error("Supervisor with id '#{id}' does not exist")
+        session.log(:error) {
+          "Supervisor with id '#{id}' does not exist"
+        }
         exit(1)
       end
 
       people.supervisor_id(sup.id)
     end
 
-    filters.add("-no-default-tag", "only those users with no default tag") do |people, session, options|
+    filters.add("-no-default-tag", "only those users with no default tag") do |people, _sess, options|
       options.deep_merge!(people: {filter: {account: {default_tag: nil}}})
-      people.users.select do |person|
-        !person.account.default_tag
-      end.yield_self do |filtered|
+      people.users.reject do |person|
+        person.account.default_tag
+      end.then do |filtered|
         people.newFrom filtered
       end
     end
@@ -56,7 +59,7 @@ ASSETS.cli.config do |cnf|
       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}"
-        session.logger.info(msg)
+        session.log(:info) { msg }
       end
     end
 
@@ -66,20 +69,21 @@ ASSETS.cli.config do |cnf|
       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}"
-        session.logger.info(msg)
+        session.log(:info) { msg }
       end
     end
 
     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("|").compact
-      tags     = top_tags.each_with_object([])  do |top, tags|
-        tags.concat(session.tagtree.node(top).tags)
+      tags     = top_tags.each_with_object([]) do |top, tgs|
+        tgs.concat(session.tagtree.node(top).tags)
       end.uniq
       options.deep_merge!(input: {filter: {filter_tags: {tree: top_tags, any: tags}}})
       people.filter_tags_any(tags).tap do |filtered|
-        msg = "Filtered #{filtered.count} people (out of #{people.count}) with 'any' filter_tags in subtrees #{top_tags}"
-        session.logger.info(msg)
+        msg  = "Filtered #{filtered.count} people (out of #{people.count})"
+        msg << " with 'any' filter_tags in subtrees #{top_tags}"
+        session.log(:info) { msg }
       end
     end
 
@@ -89,17 +93,21 @@ ASSETS.cli.config do |cnf|
 
       unless sch_id
         msg = "You need to specify a correct schema id or name. '#{sch_name}' does not exist"
-        session.logger.error(msg)
+        session.log(:error) { msg }
         exit(1)
       end
 
       options.deep_merge!(people: {filter: {details: {schema_id: sch_id}}})
-      session.logger.info("Filtering people records with schema #{session.schemas.to_name(sch_id)}")
+      session.log(:info) {
+        "Filtering people records with schema #{session.schemas.to_name(sch_id)}"
+      }
 
       people.select do |person|
         person.details && (person.details.schema_id == sch_id)
-      end.yield_self do |filtered|
-        session.logger.info("Filtered #{filtered.count} people out of #{people.count} total")
+      end.then do |filtered|
+        session.log(:info) {
+          "Filtered #{filtered.count} people out of #{people.count} total"
+        }
         people.newFrom filtered
       end
     end

data/lib/eco/cli_default/usecases.rb

@@ -1,55 +1,5 @@
-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 = "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
-
+ASSETS.cli.config do |cnf| # rubocop:disable Metrics/BlockLength
+  cnf.usecases do |cases| # rubocop:disable Metrics/BlockLength
     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)
@@ -69,25 +19,6 @@ ASSETS.cli.config do |cnf|
       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")
-    .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 = "Creates a CSV with the paths to each tag"
-    cases.add("-create-tag-paths", :other, desc, case_name: "create-tag-paths")
-
-    desc = "Creates a JSON file with the tagtree from a CSV file"
-    cases.add("-csv-to-tree", :other, desc, case_name: "csv-to-tree") do |session, options, usecase|
-      file = SCR.get_file("-csv-to-tree", required: true, should_exist: true)
-      options.deep_merge!(source: {file: file})
-    end
-
     desc = "Forces a change of email in the same org. It won't succeed if email taken by an org member user"
     cases.add("-change-email-from", :sync, desc, case_name: "change-email")
 
@@ -95,12 +26,12 @@ ASSETS.cli.config do |cnf|
     cases.add("-switch-supervisor", :transform, desc, case_name: "switch-supervisor") do |people, session, options|
       unless options[:super]&.key?(:old)
         msg = "You must specify an -old-super to target whose supervisor is changing"
-        session.logger.error(msg)
+        session.log(:error) { msg }
         exit(1)
       end
       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)
+        session.log(:error) { msg }
         exit(1)
       end
     end.add_option("-old-super", "The supervisor id to be replaced on the subordinates") do |options|
@@ -115,59 +46,13 @@ ASSETS.cli.config do |cnf|
       end
     end
 
-    desc  = "Input file dump into a CSV as is."
+    desc = "Input file dump into a CSV as is."
     cases.add("-entries-to-csv", :import, desc, case_name: "entries-to-csv")
     .add_option("-out") do |options|
       file  = SCR.get_file("-out")
       options.deep_merge!(export: {file: file})
     end
 
-    desc  = "Usage '-org-data-convert backup.json -restore-db-from'."
-    desc += " Transforms an input .json file to the values of the destination environment "
-    desc += " (names missmatch won't solve: i.e. usergroups)"
-    cases.add("-org-data-convert", :import, desc, case_name: "org-data-convert") do |input, session, options|
-      unless input && input.is_a?(Eco::API::Organization::People)
-        file  = SCR.get_file("-org-data-convert", required: true)
-        input = Eco::API::Organization::People.new(JSON.parse(File.read(file)))
-        session.logger.info("Source DB: loaded #{input.length} entries.")
-      end
-
-      unless options[:source_enviro]
-        session.logger.error("You need to specify a -source-enviro for the conversion to work out")
-        exit(1)
-      end
-
-    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"
-    cases.add("-restore-db-from", :sync, desc, case_name: "restore-db") do |input, people, session, options|
-      unless input && input.is_a?(Eco::API::Organization::People)
-        file  = SCR.get_file("-restore-db-from", required: true)
-        input = Eco::API::Organization::People.new(JSON.parse(File.read(file)))
-        session.logger.info("Source DB: loaded #{input.length} entries.")
-      end
-    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")
-    .add_option("-force", "If also send an invite email to those that have accepted the invite") do |options|
-      options.deep_merge!(force: {invite: true})
-    end
-
-    desc = "Re-sends invites to target users that have not accepted the invite as yet"
-    cases.add("-reinvite-from", :sync, desc, case_name: "reinvite")
-    .add_option("-force", "If also send an invite email to those that have accepted the invite") do |options|
-      options.deep_merge!(force: {invite: true})
-    end
-
     desc  = "Clears the `permissions_custom`, provided that Policy Group abilities alone apply."
     desc += " Please be mindfull if you use this option (there may be users that have been upgraded in ad-hoc manner)."
     cases.add("-clear-abilities", :transform, desc, case_name: "clear-abilities")
@@ -219,7 +104,9 @@ ASSETS.cli.config do |cnf|
       options.deep_merge!(export: {file: {name: file || "RegisterExport.csv", format: :csv}})
 
       unless options.dig(:source, :register_id)
-        session.logger.error "You should specify the target register id"
+        session.log(:error) {
+          "You should specify the target register id"
+        }
         exit(1)
       end
     end.add_option("-register-id", "Target register id") do |options|

data/lib/eco/cli_default/workflow.rb

@@ -38,6 +38,7 @@ ASSETS.cli do |cli| # rubocop:disable Metrics/BlockLength
 
         wf_in.on(:filter) do |_wf_if, io|
           next unless input && !input.empty?
+
           io.new(input: cli.config.input_filters.process(io: io))
         end
       end
@@ -47,6 +48,7 @@ ASSETS.cli do |cli| # rubocop:disable Metrics/BlockLength
           cases_with_people = cli.config.usecases.active(io: io).select do |usecase, _data|
             io.class.people_required?(usecase.type)
           end
+
           next if cases_with_people.empty? && !options.dig(:people, :get)
 
           io.new(people: cli.config.people(io: io))
@@ -78,7 +80,7 @@ ASSETS.cli do |cli| # rubocop:disable Metrics/BlockLength
       end
     end
 
-    wf.before(:launch_jobs) do |_wf_jobs, io|
+    wf.before(:launch_jobs) do |_wf_jobs, _io|
       available_args = cli.config.available_option_args
       SCR.stop_on_unknown!(all_available: available_args)
     end
@@ -95,7 +97,7 @@ ASSETS.cli do |cli| # rubocop:disable Metrics/BlockLength
         wf_post.skip!
         log(:info) {
           msg  = "Although there are post_launch cases, they will NOT be RUN"
-          msg += ", because we are in dry-run (simulate)." if options[:dry_run]
+          msg << ", because we are in dry-run (simulate)." if options[:dry_run]
           msg
         }
         next
@@ -109,9 +111,9 @@ ASSETS.cli do |cli| # rubocop:disable Metrics/BlockLength
         log(:info) {
           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)."
+            msg << ", because we are in dry-run (simulate)."
           elsif !partial_update
-            msg += ", because it is not a partial update (-get-partial option not present)."
+            msg << ", because it is not a partial update (-get-partial option not present)."
           end
           msg
         }

data/lib/eco/csv/split.rb

@@ -21,11 +21,13 @@ module Eco
       def copy_count
         @copy_count ||= 0
       end
+      attr_writer :copy_count
 
       # @return [Integer] number of total input rows
       def total_count
         @total_count ||= 0
       end
+      attr_writer :total_count
 
       # @return [Array<String>] list of created files
       def out_files