eco-helpers 2.6.4 → 2.7.1

data/lib/eco/api/usecases/base_io.rb

@@ -11,7 +11,7 @@ module Eco
         class MissingParameter < StandardError
           attr_reader :type, :required, :given
 
-          def initialize(msg = nil, type: nil, required:, given:)
+          def initialize(msg = nil, required:, given:, type: nil)
             @type     = type
             @required = required
             @given    = given
@@ -23,11 +23,11 @@ module Eco
 
         class << self
           def input_required?(type)
-            !valid_type?(type) || [:import, :sync].include?(type)
+            !valid_type?(type) || %i[import sync].include?(type)
           end
 
           def people_required?(type)
-            !valid_type?(type) || [:filter, :transform, :sync, :error_handler, :export].include?(type)
+            !valid_type?(type) || %i[filter transform sync error_handler export].include?(type)
           end
         end
 
@@ -40,10 +40,14 @@ module Eco
         # @param people [Eco::API::Organization::People] people object.
         # @param session [Eco::API:Session]
         # @param options [Hash] hash with symbol keys (i.e. behaviour modifiers, cli trackers, filters, etc.)
-        def initialize(type: nil, input: nil, people: nil, session:, options: {}, output: nil, validate: true)
-          self.type    = type if type
-
-          if self.type && validate
+        def initialize( # rubocop:disable Lint/MissingSuper
+          session:,
+          type:    nil, input:  nil, people: nil,
+          options: {},  output: nil, validate: true
+        )
+          self.type = type if type
+
+          if self.type && validate # rubocop:disable Style/IfUnlessModifier
             validate_args(input: input, people: people, session: session, options: options)
           end
 
@@ -64,8 +68,8 @@ module Eco
         # @return [Eco::API::UseCases::BaseIO]
         def base
           kargs = params(keyed: true).merge({
-            type:   self.type,
-            output: self.output,
+            type:   type,
+            output: output
           }).slice(:type, :input, :people, :session, :options, :output) # :validate <- ?
           Eco::API::UseCases::BaseIO.new(**kargs)
         end
@@ -74,12 +78,12 @@ module Eco
         # @return [Eco::API::UseCases::BaseIO]
         def new(**kargs)
           default = {
-            type:     self.type,
-            input:    self.input,
-            people:   self.people,
-            session:  self.session,
-            options:  self.options,
-            output:   self.output,
+            type:     type,
+            input:    input,
+            people:   people,
+            session:  session,
+            options:  options,
+            output:   output,
             validate: true
           }
           self.class.new(**default.merge(kargs))
@@ -88,7 +92,7 @@ module Eco
         # Helper to build a `Hash` of symbol keys or `Array` with params to do callbacks.
         def params(keyed: false, all: false)
           kargs = {}
-          kargs.merge!(input:    input)  if input_required?  || all
+          kargs.merge!(input:   input)   if input_required?  || all
           kargs.merge!(people:  people)  if people_required? || all
           kargs.merge!(session: session, options: options)
           keyed ? kargs : kargs.values
@@ -108,7 +112,7 @@ module Eco
         #   provided that it preserves the target parameter
         #   (otherise it would blank it)
         # @return [Eco::API::UseCases::BaseIO]
-        def chained(as: self.type)
+        def chained(as: type) # rubocop:disable Naming/MethodParameterName
           base.tap do |io_base|
             next unless io_base.output
             case as
@@ -116,7 +120,7 @@ module Eco
               io_base.output_be_input!
             when :filter
               io_base.output_be_people!
-            when :transform, :sync, :export, :error_handler, :other
+              # when :transform, :sync, :export, :error_handler, :other
             end
           end
         end
@@ -124,26 +128,25 @@ module Eco
         protected
 
         def output_be_input!
-          @input, @output = output, nil
+          @input, @output = output, nil # rubocop:disable Style/ParallelAssignment
           input
         end
 
         def output_be_people!
-          @people, @output = output, nil
+          @people, @output = output, nil # rubocop:disable Style/ParallelAssignment
           people
         end
 
         private
 
         def validate_args(input:, people:, session:, options:)
-          case
-          when !session.is_a?(Eco::API::Session)
+          if !session.is_a?(Eco::API::Session)
             raise MissingParameter.new("UseCase", required: :session, given: session.class)
-          when input_required? && !input
+          elsif input_required? && !input
             raise MissingParameter.new("UseCase", type: type, required: :input, given: input.class)
-          when people_required? && !people.is_a?(Eco::API::Organization::People)
+          elsif people_required? && !people.is_a?(Eco::API::Organization::People)
             raise MissingParameter.new("UseCase", type: type, required: :people, given: people.class)
-          when !options || (options && !options.is_a?(Hash))
+          elsif !options || (options && !options.is_a?(Hash))
             raise MissingParameter.new("Use Case options", required: :Hash, given: options.class)
           end
           true

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