eco-helpers 2.0.18 → 2.0.24

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

@@ -0,0 +1,37 @@
+class Eco::API::UseCases::DefaultCases::CleanUnknownTags < Eco::API::Common::Loaders::UseCase
+  name "clean-unknown-tags"
+  type :transform
+
+  REGISTER_TAGS = [
+    "EVENT", "INJURY", "RISK", "CONTRACTOR", "PERMIT",
+    "AUDIT", "JSEA",
+    "TRAINING", "INDUCTION",
+    "MEETING",  "PPE",  "CHEMICAL",
+    "PLANT", "ASSET",
+    "POLICY", "IDEA", "REPORTS"
+  ]
+
+  attr_reader :session, :options
+
+  def main(people, session, options, usecase)
+    @session = session; @options = options
+
+    update   = session.new_job("main", "update", :update, usecase)
+    people.each do |person|
+      unknown_tags = person.filter_tags.select {|tag| !tag?(tag)}
+      person.filter_tags -= unknown_tags
+      update.add(person)
+    end
+  end
+
+  private
+
+  def tag?(value)
+    tagtree.tag?(value) || REGISTER_TAGS.any? {|reg| value == reg}
+  end
+
+  def tagtree
+    @tagtree ||= ASSETS.config.tagtree
+  end
+
+end

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

@@ -13,28 +13,42 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
       return false
     end
 
-    session.logger.info("going to create file: #{file}")
-    header = spot_header
-
-    CSV.open(file, "w") do |csv|
-      csv << header
-      people.each do |person|
-        csv << to_row(person)
+    if options.dig(:export, :options, :split_schemas)
+      by_schema.each do |id, people|
+        sch_name = schemas.to_name(id)
+        prefix = sch_name ? sch_name.gsub(" ", "_") : "No_Schema"
+        create_file!("#{prefix}_#{file}", people)
       end
+    else
+      create_file!(file, people)
     end
   end
 
   private
 
+  def create_file!(filename = file, data = people)
+    session.logger.info("going to create file: #{filename}")
+
+    CSV.open(filename, "w") do |csv|
+      csv << spot_header(data.first)
+      data.each do |person|
+        csv << to_row(person)
+      end
+    end
+  end
+
   def to_row(person)
     entry = to_entry_type(person)
-    entry.values_at(*keys(entry))
+    entry.values_at(*keys(entry)).tap do |row|
+      row << schemas.to_name(person.details&.schema_id) || "No Schema"
+    end
   end
 
-  def spot_header
-    header = keys(to_entry_type(people.first))
+  def spot_header(person = people.first)
+    header = keys(to_entry_type(person))
+    header << "Schema"
     header = yield(header) if block_given?
-    header = nice_header_names(header) if nice_header_names?
+    header = nice_header_names(header, schema: schema(person.details)) if nice_header_names?
     header
   end
 
@@ -46,10 +60,62 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
      options.dig(:nice_header) || options.dig(:export, :options, :nice_header)
   end
 
-  def nice_header_names(header)
-    name_maps = session.schema.fields_by_alt_id.each_with_object({}) do |(alt_id, fld), mappings|
+  def nice_header_names(header, schema: nil)
+    schema ||= session.schema
+    name_maps = schema.fields_by_alt_id.each_with_object({}) do |(alt_id, fld), mappings|
       mappings[alt_id] = fld.name
-    end.merge({
+    end.merge(nice_header_maps)
+    header.map {|name| name_maps[name] ? name_maps[name] : name}
+  end
+
+  def to_entry_type(person)
+    session.new_entry(person, dependencies: deps).yield_self do |person_entry|
+      options.dig(:export, :options, :internal_names) ? person_entry.mapped_entry : person_entry.external_entry
+    end
+  end
+
+  def deps
+    @deps ||= {"supervisor_id" => {people: people}}
+  end
+
+  def file
+    @file ||= (options[:file] || options.dig(:export, :file, :name)).tap do |filename|
+      unless filename
+        session.logger.error("Destination file not specified")
+        return false
+      end
+    end
+  end
+
+  def by_schema
+    people.group_by do |person|
+      if details = person.details
+        details.schema_id
+      end
+    end.transform_values do |persons|
+      people.newFrom persons
+    end
+  end
+
+  def schema(value)
+    case value
+    when Ecoportal::API::V1::Person
+      schema(value.details&.schema_id)
+    when String
+      schemas[value]
+    when Ecoportal::API::V1::PersonDetails
+      schema(value.schema_id)
+    when Ecoportal::API::V1::PersonSchema
+      value
+    end
+  end
+
+  def schemas
+    session.schemas
+  end
+
+  def nice_header_maps
+    @nice_header_maps ||= {
       "policy_group_ids"   => "User Group(s)",
       "email"              => "Email",
       "name"               => "Name",
@@ -96,28 +162,7 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
       "custom_person_details"     => "(min) on People Schema Details",
       "custom_person_account"     => "(min) on Users",
       "custom_person_abilities"   => "(min) on Users' Abilities"
-    })
-    header.map {|name| name_maps[name] ? name_maps[name] : name}
-  end
-
-  def to_entry_type(person)
-    session.new_entry(person, dependencies: deps).yield_self do |person_entry|
-      options.dig(:export, :options, :internal_names) ? person_entry.mapped_entry : person_entry.external_entry
-    end
-  end
-
-  def deps
-    @deps ||= {"supervisor_id" => {people: people}}
+    }
   end
 
-  def file
-    @file ||= (options[:file] || options.dig(:export, :file, :name)).tap do |filename|
-      unless filename
-        session.logger.error("Destination file not specified")
-        return false
-      end
-    end
-  end
-
-
 end

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

@@ -5,8 +5,7 @@ class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::UseCases::
   private
 
   def to_row(person)
-    entry = to_entry_type(person)
-    data = entry.values_at(*keys(entry))
+    data = super(person)
     data << person.subordinates
     data << person_supervisor(person)
     data += user_abilities(person)
@@ -38,8 +37,8 @@ class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::UseCases::
     preferences.map {|key| user_preferences[key] || false}
   end
 
-  def spot_header
-    super do |header|
+  def spot_header(person = people.first)
+    super(person) do |header|
       header << "Subordinates"
       header << "Supervisor Name"
       header += abilities_header

data/lib/eco/api/usecases/ooze_samples/ooze_update_case.rb

@@ -124,8 +124,9 @@ class Eco::API::UseCases::OozeSamples::OozeUpdateCase < Eco::API::Common::Loader
   end
 
   def prompt_to_confirm!
-    print "\nDo you want to proceed (y/N)?  "
-    exit(1) unless $stdin.gets.chomp.to_s.downcase == "y"
+    prompt_user("Do you want to proceed (y/N)?", default: "Y") do |response|
+      exit(1) unless response.upcase.start_with?("Y")
+    end
   end
 
 end

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

@@ -1,18 +1,71 @@
 ASSETS.cli.config do |cnf|
+  formats = {
+    csv: {
+      option: ["-csv"],
+      extname: [".csv", ".txt"]
+    },
+    xml: {
+      option: ["-xml"],
+      extname: [".xml"]
+    },
+    xls:  {
+      option: ["-xls", "-xlsx", "-excel"],
+      extname: [".xls", ".xlsx", ".xlsm"]
+    },
+    json: {
+      option: ["-json"],
+      extname: [".json"]
+    }
+  }
+
   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, (format, selectors)|
+        used = selectors[:option].reduce(false) {|used, option| SCR.get_arg(option) || used}
+        next matched if matched
+        next format  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.logger.error("Could not find any file with extension: #{ext} in folder '#{folder}'")
+            exit(1)
+          end
+        end
+      else
+        ext    = File.extname(file)
+      end
+
+      format ||= formats.reduce(nil) do |matched, (format, selectors)|
+        next matched if matched
+        next format  if selectors[:extname].any? {|e| ext == e}
+      end
+      format ||= :csv
+
       options.deep_merge!(input: {file: {name: file}})
-      if SCR.get_arg("-xml")
-        options.deep_merge!(input: {file: {format: :xml}})
-        session.config.files.validate(:xml, file)
-        input = session.entries(file: file, format: :xml)
-      elsif SCR.get_arg("-json")
-        options.deep_merge!(input: {file: {format: :json}})
-        input = Eco::API::Organization::People.new(JSON.parse(File.read(file)))
+      options.deep_merge!(input: {file: {format: format}})
+
+      case format
+      when :xml
+        [file].flatten.each {|f| session.config.files.validate(:xml, f)}
+        input = session.entries(file: file, format: format)
+      when :xls
+        input = session.entries(file: file, format: format)
+      when :json
+        input = [file].flatten.reduce(Eco::API::Organization::People.new([])) do |people, file|
+          people.merge(JSON.parse(File.read(file)))
+        end
       else
-        options.deep_merge!(input: {file: {format: :csv}})
         input = session.csv_entries(file)
       end
     end

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

@@ -18,6 +18,12 @@ ASSETS.cli.config do |cnf|
       exit
     end
 
+    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)
@@ -35,11 +41,24 @@ 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  = "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: {
@@ -47,12 +66,38 @@ ASSETS.cli.config do |cnf|
       })
     end
 
-    options_set.add(["-dry-run", "-simulate"], "Runs in dry-run (no requests sent to server)") do |options, session|
+    desc = "Saves the requests's body even though running in dry-run (-simulate)"
+    options_set.add("-save-requests", desc) do |options, session|
+      options.deep_merge!(requests: {backup: true})
+    end
+
+    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  = "(careful with this option)  This will include everybody as part of the update (including those that are api excluded). "
+    desc += "Only launch with this option when only api excluded people are included in your update."
+    options_set.add("-include-excluded", desc) do |options|
+      options.deep_merge!(include: {excluded: true})
+    end
+
+    desc = "Includes in API updates ONLY people that evaluate true as people excluded from periodic upates."
+    options_set.add("-include-only-excluded", desc) do |options|
+      options.deep_merge!(include: {only_excluded: true})
+    end
+
     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})

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

@@ -26,11 +26,36 @@ ASSETS.cli.config do |cnf|
     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|
+    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|
+      #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"
@@ -48,6 +73,8 @@ ASSETS.cli.config do |cnf|
       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"
@@ -60,6 +87,10 @@ ASSETS.cli.config do |cnf|
       options.deep_merge!(other: {file: {codes_column: col_codes}})
     end
 
+    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|