eco-helpers 2.6.3 → 2.7.0

data/lib/eco/api/usecases/default/locations/cli/tagtree_extract_cli.rb

@@ -1,7 +1,7 @@
 class Eco::API::UseCases::Default::Locations::TagtreeExtract
   # Class to define the CLI integration of a usecase anywhere it suits.
   class Cli < Eco::API::UseCases::Cli
-    desc "Exports the tagtree in a specific format"
+    desc "Converts a tagtree into a specific format"
 
     add_option("-include-archived", "Whether the archived nodes should be included") do |options|
       options.deep_merge!(output: {include: {archived: true}})
@@ -17,7 +17,7 @@ class Eco::API::UseCases::Default::Locations::TagtreeExtract
       options.deep_merge!(output: {attrs: attrs.split('|').map(&:to_sym)})
     end
 
-    add_option("-with-ancestors", "Include ancestors in tree csv/excel_tree") do |options|
+    add_option("-with-ancestors", "Include full path of ancestors in tree csv/excel_tree") do |options|
       options.deep_merge!(output: {include: {ancestors: true}})
     end
 
@@ -25,5 +25,10 @@ class Eco::API::UseCases::Default::Locations::TagtreeExtract
       indent = SCR.get_arg("-indent", with_param: true) || ""
       options.deep_merge!(output: {indent: indent})
     end
+
+    add_option("-file-as-source", "Use a file as locations input (rather than the live locations)") do |options|
+      file = SCR.get_file("-file-as-source", required: true, should_exist: true)
+      options.deep_merge!(source: {file: file})
+    end
   end
 end

data/lib/eco/api/usecases/default/locations/cli/tagtree_upload_cli.rb

@@ -0,0 +1,21 @@
+class Eco::API::UseCases::Default::Locations::TagtreeUpload
+  # Class to define the CLI integration of a usecase anywhere it suits.
+  class Cli < Eco::API::UseCases::Cli
+    desc "Uploads the tagtree (assumes nodes don't exist!)"
+
+    callback do |_sess, options, _case|
+      file = SCR.get_file(cli_name, required: true, should_exist: true)
+      options.deep_merge!(source: {file: file})
+    end
+
+    add_option("-top-id", "To nest the upload under some existing node (i.e. top node)") do |options|
+      format = SCR.get_arg("-top-id", with_param: true)
+      options.deep_merge!(input: {top_id: format})
+    end
+
+    add_option("-structure-id", "Target structure id") do |options|
+      id = SCR.get_arg("-structure-id", with_param: true)
+      options.deep_merge!(source: {structure_id: id})
+    end
+  end
+end

data/lib/eco/api/usecases/default/locations/csv_to_tree_case.rb

@@ -4,9 +4,9 @@ class Eco::API::UseCases::Default::Locations::CsvToTree < Eco::API::Common::Load
 
   include Eco::Data::Locations::DSL
 
-  TIME_FORMAT = '%Y%m%dT%H%M%S'
+  TIME_FORMAT = '%Y%m%dT%H%M%S'.freeze
 
-  def main(session, options, usecase)
+  def main(_session, options, _usecase)
     options[:end_get] = false
     tree_struct = org_tree(input_csv)
 
@@ -27,7 +27,7 @@ class Eco::API::UseCases::Default::Locations::CsvToTree < Eco::API::Common::Load
   end
 
   def input_file
-    @input_file   ||= options.dig(:source, :file)
+    @input_file ||= options.dig(:source, :file)
   end
 
   def input_encoding

data/lib/eco/api/usecases/default/locations/tagtree_extract_case.rb

@@ -3,14 +3,14 @@ class Eco::API::UseCases::Default::Locations::TagtreeExtract < Eco::API::UseCase
   require_relative 'cli/tagtree_extract_cli'
   #cli self::Cli
 
-  name "export-tree"
+  name "tagtree-extract"
   type :other
 
   include Eco::Data::Files
 
-  OUT_FOLDER      = "sftp"
-  OUT_TIME_FORMAT = '%Y%m%dT%H%M%S'
-  OUT_FILENAME    = "live_tree"
+  OUT_FOLDER      = "sftp".freeze
+  OUT_TIME_FORMAT = '%Y%m%dT%H%M%S'.freeze
+  OUT_FILENAME    = "live_tree".freeze
 
   def process
     case format
@@ -18,7 +18,7 @@ class Eco::API::UseCases::Default::Locations::TagtreeExtract < Eco::API::UseCase
       excel(output_filename) do |workbook|
         tag_trees.each do |tree|
           excel_sheet(workbook, compact_name(tree.name), header: format == :excel_nodes) do |sheet|
-            tree_extract(tree).each_with_index do |row, idx|
+            tree_extract(tree).each_with_index do |row, _idx|
               sheet.append_row(row)
             end
           end
@@ -39,7 +39,7 @@ class Eco::API::UseCases::Default::Locations::TagtreeExtract < Eco::API::UseCase
   private
 
   def compact_name(str)
-    str.gsub(/\s+/, "_")[0..30]
+    str.gsub(/\s+/, "_").gsub(/\W/, '')[0..30]
   end
 
   def str_node_attrs
@@ -85,25 +85,58 @@ class Eco::API::UseCases::Default::Locations::TagtreeExtract < Eco::API::UseCase
 
   def output_file_format
     case format
-    when :list; 'txt'
-    when :nodes; 'csv'
-    when :csv_tree; 'csv'
-    when :json; 'json'
-    when :excel_tree; 'xlsx'
-    when :excel_nodes; 'xlsx'
-    else
+    when :nodes, :csv_tree
+      'csv'
+    when :json then 'json'
+    when :excel_tree, :excel_nodes
+      'xlsx'
+    else # :list
       'txt'
     end
   end
 
   def tag_trees
-    @tag_trees ||= session.live_trees(include_archived: include_archived?).reject do |tree|
+    @tag_trees ||=
+      if file_as_source?
+        [org_tree(input_csv).tap do |tree|
+          tree.name = file_as_source
+        end]
+      else
+        retrieve_live_trees
+      end
+  end
+
+  def retrieve_live_trees
+    session.live_trees(include_archived: include_archived?).reject do |tree|
       tree.empty?.tap do |rejected|
         log(:warn) { "Tree '#{tree.name}' does NOT have location nodes. Skipping..." } if rejected
       end
     end
   end
 
+  def input_csv
+    return unless file_as_source?
+    @input_csv ||= Eco::CSV.read(file_as_source, encoding: input_encoding)
+  end
+
+  def input_encoding
+    options.dig(:input, :file, :encoding) || 'utf-8'
+  end
+
+  def file_as_source?
+    return true unless file_as_source.nil?
+    false
+  end
+
+  def file_as_source
+    @file_as_source ||= options.dig(:source, :file).tap do |file|
+      next if file.nil?
+      next if File.exist?(file)
+      log(:error) { "File '#{file}' does not exist" }
+      exit 1
+    end
+  end
+
   def include_ancestors?
     options.dig(:output, :include, :ancestors)
   end
@@ -150,10 +183,8 @@ class Eco::API::UseCases::Default::Locations::TagtreeExtract < Eco::API::UseCase
     log(:info) { "Created file: #{filename}" }
   end
 
-  def file(filename)
-    File.open(filename, "w") do |fd|
-      yield(fd)
-    end
+  def file(filename, &block)
+    File.open(filename, "w", &block)
   ensure
     log(:info) { "Created file: #{filename}" }
   end
@@ -169,13 +200,13 @@ class Eco::API::UseCases::Default::Locations::TagtreeExtract < Eco::API::UseCase
 
   def excel_sheet(workbook, name, header: true)
     #unless sheet = workbook.get_worksheet_by_name(name)
-      sheet = workbook.add_worksheet(name)
+    sheet = workbook.add_worksheet(name)
     #end
     sheet.auto_width = true
     yield(sheet)
-    if header
-      sheet.set_row(0, 30, workbook.bold_format)
-      sheet.freeze_panes(1, 0)
-    end
+
+    return unless header
+    sheet.set_row(0, 30, workbook.bold_format)
+    sheet.freeze_panes(1, 0)
   end
 end

data/lib/eco/api/usecases/default/locations/tagtree_upload_case.rb

@@ -0,0 +1,87 @@
+class Eco::API::UseCases::Default::Locations::TagtreeUpload < Eco::API::UseCases::GraphQL::Samples::Location::Command
+  require_relative 'cli/tagtree_upload_cli'
+
+  name "tagtree-upload"
+  type :other
+
+  COMMANDS_PER_PAGE = 45
+  TOP_ID            = nil
+
+  def track_current_tree?
+    false
+  end
+
+  # We only define the `:insert` stage
+  def inputs(force_continue: force_continue?)
+    {}.tap do |stages|
+      stages[:insert] = input(insert_commands, force_continue: force_continue)
+    end.each do |stage, input|
+      yield(input, stage) if block_given?
+    end
+  end
+
+  def insert_commands(tree = input_tree, pid: nil)
+    [].tap do |comms|
+      unless tree.top?
+        pid    = top_id                         if top_id? && pid.nil?
+        comms << insert_command(tree, pid: pid) unless top_id?(tree.id)
+        pid    = tree.id
+      end
+      tree.nodes.map do |node|
+        insert_commands(node, pid: pid)
+      end.flatten(1).tap do |subs|
+        comms.concat(subs)
+      end
+    end
+  end
+
+  def insert_command(node, pid: nil)
+    {
+      insert: {
+        nodeId:   node.id,
+        name:     node.name,
+        parentId: pid
+      }.tap do |node_hash|
+        classification_ids = to_classification_ids(node.classifications)
+        next unless classification_ids.any?
+
+        node_hash.merge!({
+          classificationIds: node.classifications.dup
+        })
+      end
+    }
+  end
+
+  def top_id?(node_id = nil)
+    return top_id.is_a?(String) if node_id.nil?
+    node_id == top_id
+  end
+
+  def top_id
+    options.dig(:input, :top_id) || self.class::TOP_ID
+  end
+
+  def input_tree
+    @input_tree ||= Eco::API::Organization::TagTree.new(tree_json).tap do |tree|
+      log(:info) {
+        "Loaded input locations structure (#{tree.count} nodes)"
+      }
+    end
+  end
+
+  def tree_json
+    hash_tree(input_csv)
+  end
+
+  def input_csv
+    @input_csv ||= csv_from(input_file).tap do |table|
+      log(:info) {
+        "#{table.count} data rows loaded from #{input_file}"
+      }
+    end
+  end
+
+  def input_file
+    @input_file ||= options.dig(:source, :file)
+  end
+end

data/lib/eco/api/usecases/default/locations.rb

@@ -13,3 +13,4 @@ require_relative 'locations/codes_to_tags_case'
 require_relative 'locations/create_tag_paths_case'
 require_relative 'locations/csv_to_tree_case'
 require_relative 'locations/tagtree_extract_case'
+require_relative 'locations/tagtree_upload_case'

data/lib/eco/api/usecases/default/people/analyse_people_case.rb

@@ -4,22 +4,20 @@ class Eco::API::UseCases::Default::People::Analyse < Eco::API::Common::Loaders::
 
   attr_reader :people
 
-  def main(people, session, options, usecase)
+  def main(_people, _session, options, _usecase)
     options[:end_get] = false
-    @people = people
 
-    case
-    when case_options[:identify_duplicates]
+    if case_options[:identify_duplicates]
       identify_duplicates
-    when case_options[:identify_unnamed]
+    elsif case_options[:identify_unnamed]
       identify_unnamed
     else
-      session.logger.info("No analysis operation was specified")
+      log(:info) { "No analysis operation was specified" }
     end.tap do |people_involved|
-      if people_involved
-        to_csv(people_involved) if to_csv?
-        create_people_backup(people_involved) if results_people_backup?
-      end
+      next unless people_involved
+
+      to_csv(people_involved)               if to_csv?
+      create_people_backup(people_involved) if results_people_backup?
     end
   end
 
@@ -27,22 +25,21 @@ class Eco::API::UseCases::Default::People::Analyse < Eco::API::Common::Loaders::
 
   def identify_unnamed
     similarity_analytics.unnamed.tap do |unnamed|
-      if unnamed.empty?
-        session.logger.info("There were no people with no name!!")
-      end
+      next unless unnamed.empty?
+      log(:info) { "There were no people with no name!!" }
     end
   end
 
   def identify_duplicates
     analysed = similarity_screening
     if case_options[:ignore_matching_words]
-      puts "Fine tune results by ignoring matching words..."
+      log(:info) { "Fine tune results by ignoring matching words..." }
       analysed = strict_similarity(analysed)
     end
 
     similarity_analytics.newSimilarity(analysed).tap do |related_people|
       if related_people.empty?
-        session.logger.info("There were no possible duplicates identified!!")
+        log(:info) { "There were no possible duplicates identified!!" }
       else
         report = similarity_analytics.report(analysed, format: :txt)
         save!(report)
@@ -51,34 +48,38 @@ class Eco::API::UseCases::Default::People::Analyse < Eco::API::Common::Loaders::
   end
 
   def strict_similarity(analysed)
-    similarity_analytics.ignore_matching_words(analysed, **{
+    similarity_analytics.ignore_matching_words(
+      analysed,
       threshold: 0.5,
-      order: [:ngrams]
-    })
+      order:     [:ngrams]
+    )
   end
 
   def similarity_screening
     similarity_analytics.attribute = field_similarity
     options = {
       threshold: 0.4,
-      order:     [:average, :dice]
+      order:     %i[average dice]
     }.tap do |opts|
       opts.merge!(needle_read: facet_field_proc) if facet_field?
-      opts.merge!(unique_words: true) if unique_words?
+      opts.merge!(unique_words: true)            if unique_words?
     end
     analysed = similarity_analytics.analyse(**options)
-    puts "Got #{analysed.count} results after basic screening with #{options}"
+    log(:info) {
+      "Got #{analysed.count} results after basic screening with #{options}"
+    }
 
     return analysed if case_options[:only_screening]
     options = {threshold: 0.5, order: [:average]}
-    puts "Going to rearrange results... with #{options}"
-    similarity_analytics.rearrange(analysed, **options).tap do |analysed|
-      puts "... got #{analysed.count} results after rearranging"
+    log(:info) { "Going to rearrange results... with #{options}" }
+
+    similarity_analytics.rearrange(analysed, **options).tap do |results|
+      log(:info) { "... got #{results.count} results after rearranging" }
     end
   end
 
   def similarity_analytics
-    @analytics ||= people.similarity
+    @similarity_analytics ||= people.similarity
   end
 
   def create_people_backup(cut = people, file = results_people_backup)
@@ -90,7 +91,8 @@ class Eco::API::UseCases::Default::People::Analyse < Eco::API::Common::Loaders::
     opts.deep_merge!(export: {file: {name: file, format: :csv}})
     opts.deep_merge!(export: {options: {nice_header: true}})
     opts.deep_merge!(export: {options: {internal_names: true}})
-    #opts.deep_merge!(export: {options: {split_schemas: true}})
+    # opts.deep_merge!(export: {options: {split_schemas: true}})
+
     session.process_case("to-csv", type: :export, people: data, options: opts.merge(options.slice(:export)))
   end
 
@@ -112,7 +114,7 @@ class Eco::API::UseCases::Default::People::Analyse < Eco::API::Common::Loaders::
   end
 
   def use_field
-    case_options.dig(:use_field)
+    case_options[:use_field]
   end
 
   def use_field?
@@ -120,7 +122,7 @@ class Eco::API::UseCases::Default::People::Analyse < Eco::API::Common::Loaders::
   end
 
   def facet_field
-    case_options.dig(:facet_field)
+    case_options[:facet_field]
   end
 
   def facet_field?
@@ -128,7 +130,7 @@ class Eco::API::UseCases::Default::People::Analyse < Eco::API::Common::Loaders::
   end
 
   def csv_file
-    case_options.dig(:csv_file)
+    case_options[:csv_file]
   end
 
   def to_csv?
@@ -136,7 +138,7 @@ class Eco::API::UseCases::Default::People::Analyse < Eco::API::Common::Loaders::
   end
 
   def results_people_backup
-    case_options.dig(:backup_people)
+    case_options[:backup_people]
   end
 
   def results_people_backup?
@@ -152,15 +154,16 @@ class Eco::API::UseCases::Default::People::Analyse < Eco::API::Common::Loaders::
   end
 
   def save!(data)
-    ext  = File.extname(output_file).downcase.delete(".")
+    ext = File.extname(output_file).downcase.delete(".")
     session.logger.info("Generating file '#{output_file}'")
     File.open(output_file, "w") do |fd|
-      if ext == "txt"
+      case ext
+      when "txt"
         fd << data
-      elsif ext == "html"
+      when "html"
         puts "html is still not supported"
         exit(1)
-      elsif ext == "json"
+      when "json"
         puts "json is still not supported"
         exit(1)
       end
@@ -172,7 +175,7 @@ class Eco::API::UseCases::Default::People::Analyse < Eco::API::Common::Loaders::
   def proc_value_access(expression)
     #return expression.to_sym if expression.start_with?(":")
     subexpressions = expression.split(" AND ")
-    Proc.new do |person|
+    proc do |person|
       values = subexpressions.map {|exp| attribute_access(person, exp)}
       values.compact.join(" ")
     end
@@ -196,27 +199,28 @@ class Eco::API::UseCases::Default::People::Analyse < Eco::API::Common::Loaders::
   end
 
   def get_attr(obj, part)
-    case
-    when !obj
-      nil
-    when part.is_a?(Symbol) || obj.respond_to?(part.to_sym)
-      obj.send(part.to_sym)
-    when part.start_with?(":")
-      get_attr(obj, part[1..-1])
-    when part.start_with?("details[")
-      if (obj.respond_to?(:details)) && details = obj.details
-        if match = part.match(/details\[(?<field>.*)\]/)
-          details[match[:field]]
-        else
-          raise "Review your -use-field expression. It should read: person.details[target-alt_id]"
-        end
-      end
-    when part.start_with?("account")
-      obj.account if obj.respond_to?(:account)
-    when part.start_with?("person")
-      obj
-    else
-      raise "Review your expression. Cannot recognize '#{part}' as part of '#{obj.class}'"
+    return unless obj
+
+    is_method = part.is_a?(Symbol) || obj.respond_to?(part.to_sym)
+    return obj.send(part.to_sym)    if is_method
+    return get_attr(obj, part[1..]) if part.start_with?(":")
+
+    if part.start_with?("details[")
+      via_details = obj.respond_to?(:details) && (details = obj.details)
+      return unless via_details
+
+      match = part.match(/details\[(?<field>.*)\]/)
+      return details[match[:field]] if match
+
+      raise "Review your -use-field expression. It should read: person.details[target-alt_id]"
     end
+
+    if part.start_with?("account")
+      return obj.respond_to?(:account) ? obj.account : nil
+    end
+
+    return obj if part.start_with?("person")
+
+    raise "Review your expression. Cannot recognize '#{part}' as part of '#{obj.class}'"
   end
 end

data/lib/eco/api/usecases/default/people/change_email_case.rb

@@ -4,10 +4,9 @@ class Eco::API::UseCases::Default::People::ChangeEMailCase < Eco::API::Common::L
 
   # Target people with non-up-to-date emails will be updated to the new email
   def main(entries, people, session, options, usecase)
-    micro    = session.micro
-    remove   = session.new_job("main", "remove account", :update, usecase, :account)
-    change   = session.new_job("main", "change email",   :update, usecase, :core)
-    invite   = session.new_job("post", "add account",    :update, usecase, [:core, :account])
+    remove = session.new_job("main", "remove account", :update, usecase, :account)
+    change = session.new_job("main", "change email",   :update, usecase, :core)
+    invite = session.new_job("post", "add account",    :update, usecase, %i[core account])
 
     micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
       if entry.email != person.email
@@ -15,11 +14,11 @@ class Eco::API::UseCases::Default::People::ChangeEMailCase < Eco::API::Common::L
         s_account_doc = person.account&.doc
         account_doc   = s_account_doc ? JSON.parse(s_account_doc.to_json) : nil
 
-        remove.add(person) {|person| person.account = nil        }
-        change.add(person) {|person| person.email   = entry.email}
-        invite.add(person) do |person|
-          person.account       = account_doc if account_doc
-          person.supervisor_id = super_id
+        remove.add(person) {|pers| pers.account = nil         }
+        change.add(person) {|pers| pers.email   = entry.email }
+        invite.add(person) do |pers|
+          pers.account       = account_doc if account_doc
+          pers.supervisor_id = super_id
         end
       end
     end

data/lib/eco/api/usecases/default/people/clean_unknown_tags_case.rb

@@ -2,17 +2,17 @@ class Eco::API::UseCases::Default::People::CleanUnknownTags < Eco::API::Common::
   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"
-  ]
+  REGISTER_TAGS = %w[
+    EVENT INJURY RISK CONTRACTOR PERMIT
+    AUDIT JSEA
+    TRAINING INDUCTION
+    MEETING PPE CHEMICAL
+    PLANT ASSET
+    POLICY IDEA REPORTS
+  ].freeze
 
   def main(people, session, options, usecase)
-    update   = session.new_job("main", "update", :update, usecase)
+    update = session.new_job("main", "update", :update, usecase)
     people.each do |person|
       unknown_tags = person.filter_tags.reject { |tag| tag?(tag) }
       person.filter_tags -= unknown_tags
@@ -25,8 +25,10 @@ class Eco::API::UseCases::Default::People::CleanUnknownTags < Eco::API::Common::
     end
 
     log(:info) {
-      msg = "Here list of the #{removed_tags.count} removed locations..."
-      msg + "\n  • " + removed_tags.sort.join("\n  • ")
+      msg  = "Here list of the #{removed_tags.count} removed locations..."
+      msg << "\n  • "
+      msg << removed_tags.sort.join("\n  • ")
+      msg
     }
   end
 

data/lib/eco/api/usecases/default/people/clear_abilities_case.rb

@@ -2,14 +2,14 @@ class Eco::API::UseCases::Default::People::ClearAbilitiesTransCase < Eco::API::C
   name "clear-abilities"
   type :transform
 
-  def main(people, session, options, usecase)
+  def main(people, _session, _options, _usecase)
     clear_abilities(people.users)
   end
 
   private
 
   def clear_abilities(users)
-    update   = session.new_job("main", "clear-abilities", :update, usecase, :account)
+    update = session.new_job("main", "clear-abilities", :update, usecase, :account)
     users.each do |person|
       person.account.permissions_custom = nil_abilities.dup
       update.add(person)