eco-helpers 2.5.2 → 2.5.3

data/lib/eco/api/usecases/graphql/helpers/location/command/result.rb

@@ -0,0 +1,69 @@
+module Eco::API::UseCases::GraphQL::Helpers::Location::Command
+  class Result
+    attr_reader :input, :result
+
+    def initialize(input, result)
+      @input  = input
+      @result = result
+    end
+
+    def command
+      input.keys.first
+    end
+
+    def command_input_data
+      input[command]
+    end
+
+    def node_id
+      command_input_data[:nodeId]
+    end
+
+    def pending?
+      !result || !success?
+    end
+
+    def applied?
+      !pending?
+    end
+
+    def success?
+      result&.ok
+    end
+
+    def error
+      result&.error
+    end
+
+    def error?
+      !!error
+    end
+
+    def error_msg
+      return nil unless error?
+      msg  = ''
+      msg << "(#{command} '#{node_id}') #{error.message}\n" || ''
+      return msg if error.validationErrors.empty?
+      msg << "  • " + error.validationErrors.map do |err|
+        err.message
+      end.join("\n  • ")
+      msg
+    end
+
+    def command_result
+      result&.command
+    end
+
+    def command_id
+      return nil unless result
+      command_result["id"]
+    end
+
+    def as_json
+      {
+        "request"  => input,
+        "response" => result.doc
+      }
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/location/command/results.rb

@@ -0,0 +1,126 @@
+module Eco::API::UseCases::GraphQL::Helpers::Location::Command
+  class Results
+    attr_reader :input, :response
+
+    def initialize(input, response)
+      @input    = input
+      @response = response
+    end
+
+    def stats
+      msg  = ''
+      first_err = force? ? '' : "(stopped on node: '#{first_errored&.node_id}' - idx: #{first_errored_idx})"
+      msg << "  • Errored: #{errored.count} #{first_err}\n" if errored?
+      last_okay = force? ? '' : "(last node done: '#{last_applied&.node_id}' - idx: #{last_applied_idx})"
+      msg << "  • Applied: #{errored.count} #{last_okay}\n" if some_applied?
+      msg << "  • Pending: #{pending.count}\n"              if some_pending?
+      msg
+    end
+
+    # Was this configured to force-continue on command error?
+    def force?
+      input[:force]
+    end
+
+    # # Offers a summary. If anything went wrong, it's `false`.
+    # # If everything went right, it's `true`.
+    # def ok?
+    #   response&.ok
+    # end
+
+    # Overal errors (i.e. ID clashes between different structures)
+    def error
+      response&.error
+    end
+
+    def error?
+      !!error
+    end
+
+    def success?
+      !error? && results.all? {|r| r.success?}
+    end
+
+    def results
+      @results ||= input_commands.zip(response_results).each_with_object([]) do |(i, r), results|
+        results << Result.new(i, r)
+      end
+    end
+
+    def count
+      results.count
+    end
+
+    def input_result(input)
+      results_by_input[input]
+    end
+
+    def input_idx(input)
+      results.index(input_result(input))
+    end
+
+    def idx(result)
+      results.index(result)
+    end
+
+    def errored
+      @errored ||= results.select {|r| r.error?}
+    end
+
+    def errored?
+      !errored.empty?
+    end
+
+    def first_errored
+      errored.first
+    end
+
+    def first_errored_idx
+      idx(first_errored)
+    end
+
+    def applied
+      @applied ||= results.select {|r| r.applied?}
+    end
+
+    def applied?
+      results.all? {|r| r.applied?}
+    end
+
+    def some_applied?
+      applied.count > 0
+    end
+
+    def last_applied
+      applied.last
+    end
+
+    def last_applied_idx
+      idx(last_applied)
+    end
+
+    def pending
+      @pending ||= results.select {|r| r.pending?}
+    end
+
+    def some_pending?
+      !pending.empty?
+    end
+
+    private
+
+    def results_by_input
+      @results_by_input ||= results.each_with_object({}) do |r, h|
+        h[r.input] = r
+      end
+    end
+
+    def input_commands
+      input[:commands]
+    end
+
+    def response_results
+      response&.results || []
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/location/command.rb

@@ -0,0 +1,84 @@
+module Eco::API::UseCases::GraphQL::Helpers::Location
+  module Command
+    include Eco::Language::AuxiliarLogger
+    include Eco::API::UseCases::GraphQL::Helpers::Location::Base
+
+    # Prevents each request from timing out
+    COMMANDS_PER_PAGE  = 45
+    # Whether to stop or continue on command fail
+    FORCE_CONTINUE     = false
+
+    def commands_per_page
+      self.class::COMMANDS_PER_PAGE
+    end
+
+    def force_continue?
+      self.class::FORCE_CONTINUE
+    end
+
+    # With given the commands, it generates the input of the endpoint mutation.
+    # @param commands [Array<Hash>]
+    def input(commands, force_continue: force_continue?)
+      {
+        clientMutationId: "",
+        id:       target_structure_id,
+        force:    force_continue,
+        commands: commands
+      }
+    end
+
+    # @return see #with_sliced_input
+    def sliced_batches(batch_input, size: commands_per_page, desc: :input, logging: true)
+      dry_run_msg = simulate? ? '(dry-run) ' : ''
+
+      if batch_input[:commands].empty?
+        msg  = "#{dry_run_msg}No commands for '#{desc}'."
+        msg << " Skipping batch..." unless simulate?
+        log(:info) { msg }
+        return
+      end
+
+      done = 0
+      with_sliced_input(batch_input, size: size) do |sliced_input, page, pages, count, total|
+        msg  = "#{dry_run_msg}Launching '#{desc}' request #{page} (of #{pages}) "
+        msg << "with #{count} commands (done #{done} of #{total})..."
+        logger.info { msg }
+
+        response = nil
+        unless simulate? && !options.dig(:requests, :backup)
+          backup(sliced_input, type: "tree_update_#{desc}_request_#{page}_of_#{pages}")
+        end
+
+        if simulate?
+          log(:info) { sliced_input.pretty_inspect } if page < 3
+        else
+          response = graphql.locationStructure.applyCommands(input: sliced_input)
+          backup(response, type: "tree_update_#{desc}_response_#{page}_of_#{pages}")
+        end
+
+        done += count
+        yield(sliced_input, response, page, pages, done, total) if block_given?
+      end
+    end
+
+    # @param input_data [Hash] input for the endpoint `mutation.ApplyCommandsToLocationStructure`.
+    # @return [Array<Array>] pairs of `sliced_input` and `response` thereof.
+    def with_sliced_input(input_data, size: commands_per_page)
+      comms = input_data[:commands]
+      total = comms.count
+      pages = (total.to_f / size).ceil.to_i
+      page  = 1; out = []
+      comms.each_slice(size) do |comms_slice|
+        sliced_input = input_data.slice(:clientMutationId, :id).merge(commands: comms_slice)
+        yield(sliced_input, page, pages, comms_slice.count, total).tap do |response|
+          out.push([sliced_input, response])
+          page += 1
+        end
+      end
+      out
+    end
+  end
+end
+
+require_relative 'command/result'
+require_relative 'command/results'

data/lib/eco/api/usecases/graphql/helpers/location.rb

@@ -0,0 +1,7 @@
+module Eco::API::UseCases::GraphQL::Helpers
+  module Location
+  end
+end
+
+require_relative 'location/base'
+require_relative 'location/command'

data/lib/eco/api/usecases/graphql/helpers.rb

@@ -3,4 +3,5 @@ module Eco::API::UseCases::GraphQL
   end
 end
 
-require_relative 'helpers/locations'
+require_relative 'helpers/base'
+require_relative 'helpers/location'

data/lib/eco/api/usecases/graphql/samples/location/command/dsl.rb

@@ -0,0 +1,54 @@
+class Eco::API::UseCases::GraphQL::Samples::Location
+  module Command::DSL
+    include Eco::API::UseCases::GraphQL::Helpers::Location::Command
+    include Eco::API::UseCases::GraphQL::Samples::Location::Command::Results
+
+    # @example of implementation:
+    #     def inputs(command_types, force_continue: force_continue?)
+    #       {}.tap do |sequence|
+    #         command_types.commands do |comms, stage|
+    #           sequence[stage] = input(comms, force_continue: force_continue)
+    #         end
+    #       end.tap do |sequence|
+    #         sequence.each do |stage, input|
+    #           yield(input, stage) if block_given?
+    #         end
+    #       end
+    #     end
+    def inputs(*args, force_continue: force_continue?, **kargs, &block)
+      msg  = "You should implement this method in your child class.\n"
+      msg << "Which should yield the input Hash and the stage or descriptor."
+      raise Eco::API::UseCases::GraphQL::Base::NotImplementedMethod, msg
+    end
+
+    # Main processor
+    def process
+      begin
+        super if defined?(super)
+      rescue Eco::API::UseCases::GraphQL::Base::NotImplementedMethod
+      end
+
+      self.error = false
+      # this triggers a backup of the tagtree
+      self.current_tree ||= live_tree
+
+      inputs(force_continue: force_continue?) do |input, stage|
+        results[stage] ||= []
+        sliced_batches(input, desc: stage) do |sliced_input, response, page, pages, done, total|
+          track_current_tree(response&.structure)
+          page_results = nil
+          results[stage] << (page_results = request_results_class.new(sliced_input, response))
+          update_tags_remap_table(page_results, stage)
+          break if self.error = page_errors?(page_results, page, pages, done, total, stage: stage)
+        end
+
+        break if error
+      end
+    rescue StandardError => e
+      log(:error) { self.exception ||= e.patch_full_message }
+      raise
+    ensure
+      rescued { self.tags_remap_csv_file = generate_tags_remap_csv }
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/samples/location/command/results.rb

@@ -0,0 +1,125 @@
+class Eco::API::UseCases::GraphQL::Samples::Location
+  # Logic to:
+  #   1. Track-down results and errors
+  #   2. Create tags remap csv table batch design
+  module Command::Results
+    include Eco::API::UseCases::GraphQL::Helpers::Location::Base
+
+    attr_accessor :error, :exception
+    attr_accessor :tags_remap_csv_file
+
+    def rescued
+      yield
+    rescue StandardError => e
+      log(:error) { self.exception ||= e.patch_full_message }
+    end
+
+    def request_results_class
+      Eco::API::UseCases::GraphQL::Helpers::Location::Command::Results
+    end
+
+    # Capture results
+    def results
+      @results ||= {}
+    end
+
+    # The maps of tags to be used in batch remap tags
+    # @return [Array<Array>] source/destination pairs of `Array<String>`
+    def tags_remap_table
+      @tags_remap_table ||= []
+    end
+
+    # Errors tracking/logging.
+    # @note it gives feedback on where an error has occurred.
+    # @param page_results [Eco::API::UseCases::GraphQL::Helpers::Locations::Commands::CommandResults]
+    # @param stage [Symbol] used when we launch an update in different phases (i.e. rename, move, etc.)
+    # @return [Boolean] whether or not there was an error
+    def page_errors?(page_results, page, pages, done, total, stage: nil)
+      raise "Expecting CommandResults object. Given: #{page_results.class}" unless page_results.is_a?(request_results_class)
+      stage_str   = stage ? "'#{stage}' " : ''
+      fingerprint = "#{stage_str}#{page} (of #{pages})"
+      errored     = false
+
+      if page_results.error?
+        errored = true
+        log(:error) { "Error on #{fingerprint}: #{page_results.error.doc.pretty_inspect}" }
+      end
+
+      if page_results.applied?
+        log(:info) { "Success on #{fingerprint}: #{done} (of #{total}) commands applied!" }
+      elsif page_results.errored?
+        errored = true
+        msg     = "Some command failed on #{fingerprint}:\n#{page_results.stats}"
+        unless force_continue?
+          first_errored = page_results.first_errored
+          msg << "The error(s) - #{first_errored.error_msg}\n"
+        end
+        log(:error) { msg }
+      end
+
+      errored
+    end
+
+    # Based on commands that succeded, and the batch stage, it tracks
+    # the tag remaps that should be batches against existing pages
+    # @note
+    #   1. This requires to have available the `current_tree` locations structure
+    #     - Fortunatelly this is being tracked, as it is returned as payload of the response.
+    #   2. Based on the assumption that the order of the commands (stages) happens like this:
+    #     - :unarchive, :id_name, :insert, :move, :archive
+    #   3. The only update operations that generate tag remaps are `:id` (or `:id_name`) and `:move`.
+    def update_tags_remap_table(results, stage)
+      return false if [:unarchive, :archive].include?(stage)
+      raise "Expecting CommandResults object. Given: #{results.class}" unless results.is_a?(request_results_class)
+      results.applied.each do |result|
+        case stage
+        when :id, :id_name
+          prev_id, curr_id = result.command_input_data.values_at(:nodeId, :newId)
+
+          unless current_tree.tag?(curr_id)
+            msg  = "Node '#{prev_id}' was updated to '#{curr_id}', "
+            msg << "but in current structure '#{curr_id}' is not present"
+            log(:warn) { msg }
+          end
+
+          tags_remap_table << [[prev_id], [curr_id]]
+        when :move
+          node_id, parent_id = result.command_input_data.values_at(:nodeId, :parentId)
+          prev_node = previous_tree.node(node_id)
+          curr_node = current_tree.node(node_id)
+          lost_tags = prev_node.path - curr_node.path
+          new_tags  = curr_node.path - prev_node.path
+
+          curr_parent = curr_node.parent.top? ? nil : curr_node.parent
+          unless curr_parent&.id == parent_id
+            msg  = "Node '#{node_id}' was moved uner '#{parent_id}', "
+            msg << "but in current structure has parent '#{curr_parent&.id}'"
+            log(:warn) { msg }
+          end
+
+          tags_remap_table << [lost_tags.unshift(node_id), new_tags.unshift(node_id)]
+        end
+      end
+    end
+
+    # Generates the final tags remap file
+    def generate_tags_remap_csv(filename = "cache/remap_tags.csv")
+      return nil if tags_remap_table.empty?
+      timestamp_file(filename).tap do |file|
+        CSV.open(file, 'w') do |csv|
+          csv << ["source_tags", "destination_tags"]
+          tags_remap_table.each do |(src_tags, dst_tags)|
+            csv << [src_tags.join('|'), dst_tags.join('|')]
+          end
+        end
+        log(:info) { "Generated file '#{file}'" }
+      end
+    end
+
+    # Makes the file relative to the enviro
+    def timestamp_file(filename, enviro_relative: true)
+      filename = session.file_manager.dir.file(filename) if enviro_relative
+      Eco::Data::Files.timestamp_file(filename)
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/samples/location/command.rb

@@ -0,0 +1,10 @@
+# Use case to launch updates to a tagtree (i.e. upload new locations)
+module Eco::API::UseCases::GraphQL::Samples
+  class Location::Command < Eco::API::UseCases::GraphQL::Samples::Location
+    name "location-command"
+
+    require_relative 'command/results'
+    require_relative 'command/dsl'
+    include Eco::API::UseCases::GraphQL::Samples::Location::Command::DSL
+  end
+end

data/lib/eco/api/usecases/graphql/samples/location/dsl.rb

@@ -0,0 +1,6 @@
+module Eco::API::UseCases::GraphQL::Samples
+  module Location::DSL
+    include Eco::API::UseCases::GraphQL::Helpers::Location::Base
+    include Eco::Data::Locations::DSL
+  end
+end

data/lib/eco/api/usecases/graphql/samples/location.rb

@@ -0,0 +1,10 @@
+module Eco::API::UseCases::GraphQL
+  class Samples::Location < Eco::API::UseCases::GraphQL::Base
+    name "location-base"
+
+    require_relative 'location/dsl'
+    include Eco::API::UseCases::GraphQL::Samples::Location::DSL
+  end
+end
+
+require_relative 'location/command'

data/lib/eco/api/usecases/graphql/samples.rb

@@ -0,0 +1,6 @@
+module Eco::API::UseCases::GraphQL
+  module Samples
+  end
+end
+
+require_relative 'samples/location'

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

@@ -7,5 +7,6 @@ module Eco
   end
 end
 
-require_relative 'graphql/base'
 require_relative 'graphql/helpers'
+require_relative 'graphql/base'
+require_relative 'graphql/samples'

data/lib/eco/api/usecases/ooze_cases/export_register_case.rb

@@ -5,7 +5,6 @@ class Eco::API::UseCases::OozeCases::ExportRegisterCase < Eco::API::UseCases::Oo
   batch_size 5
 
   def main(session, options, usecase)
-
     super(session, options, usecase) do
       # Save the File
       CSV.open(filename, "w") do |csv|

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

@@ -5,7 +5,6 @@ class Eco::API::UseCases::OozeSamples::OozeBaseCase < Eco::API::Common::Loaders:
 
   include Eco::API::UseCases::OozeSamples::Helpers
 
-  attr_reader :session, :options, :usecase
   attr_reader :target
 
   SAVE_PATCH = "ooze_patch_update.json"
@@ -14,7 +13,6 @@ class Eco::API::UseCases::OozeSamples::OozeBaseCase < Eco::API::Common::Loaders:
   def main(session, options, usecase)
     options[:end_get] = false
     raise "You need to inherit from this class ('#{self.class}') and call super with a block" unless block_given?
-    @session = session; @options = options; @usecase = usecase
     @target  = nil
     yield
   end

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

@@ -40,11 +40,9 @@ class Eco::API::UseCases::OozeSamples::RegisterMigrationCase < Eco::API::UseCase
 
   include Eco::API::UseCases::OozeSamples::HelpersMigration
 
-  attr_reader :session, :options
   attr_reader :csv
 
   def main(session, options, usecase, &block)
-    @session = session; @options = options
     if options[:dry_run]
       @csv = []
       super(session, options, usecase, &block)

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

@@ -75,10 +75,10 @@ module Eco
           return false unless callback_from_loader?
           use_case_self = self
           callback_self.instance_eval do
-            next unless self.is_a?(Eco::API::Common::Loaders::CaseBase)
-            # `self` is the use case itself (when used the Loader)
             @session = session
             @options = options
+            # `self` is the use case itself (when used the Loader)
+            next unless self.is_a?(Eco::API::Common::Loaders::CaseBase)
             @usecase = use_case_self
           end
           true

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

@@ -1,8 +1,7 @@
 ASSETS.cli.config do |config|
   ASSETS.config.workflow do |wf|
-
-    io = nil
-    rescued = false
+    io                = nil
+    rescued           = false
     cases_with_input  = nil
     cases_with_output = nil
 
@@ -183,6 +182,5 @@ ASSETS.cli.config do |config|
       end
       io
     end
-
   end
 end

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

@@ -2,7 +2,6 @@ module Eco
   class CLI
     class Scripting
       module ArgsHelpers
-
         # @return [Array<String] the command line arguments.
         def argv
           @argv || ARGV
@@ -91,7 +90,6 @@ module Eco
         def file_exists?(filename)
           File.exists?(filename) || File.exists?(File.expand_path(filename))
         end
-
       end
     end
   end

data/lib/eco/csv/table.rb

@@ -11,6 +11,25 @@ module Eco
         end
       end
 
+      # It ensures blank strings are set to `nil`
+      # @note assumes there are no repeated header names
+      # @return [Eco::CSV::Table]
+      def nil_blank_cells!
+        self.each do |row|
+          row.dup.each do |header, value|
+            value       = value.to_s.strip
+            row[header] = value.empty?? nil : value
+          end
+        end
+        self
+      end
+
+      # A new table from `self` where blank strings are have been set to `nil`
+      # @return [Eco::CSV::Table]
+      def nil_blank_cells
+        self.class.new(self).nil_blank_cells!
+      end
+
       # @return [Hash] where keys are the groups and the values a `Eco::CSV::Table`
       def group_by(&block)
         rows.group_by(&block).transform_values do |rows|
@@ -111,11 +130,29 @@ module Eco
       end
 
       # Adds a new column at the end
+      # @note by default it adds it to the end.
       # @param header_name [String] header of the new column
+      # @param pos [Integer] index where to add the column (i.e. `0` for first)
       # @return [Eco::CSV::Table] with a new empty column
-      def add_column(header_name)
+      def add_column(header_name, pos: -1)
+        header_name = header_name.to_s.strip
+        raise ArgumentError, "header_name can't be blank" if header_name.empty?
         new_col = Array.new(length).unshift(header_name)
-        columns_to_table(columns.push(new_col))
+        columns_to_table(columns.insert(pos, new_col))
+      end
+
+      # @note by default it adds as a first column
+
+      # @param header_name [String] header of the new column
+      # @param pos [Integer] index where to add the column (i.e. `-1` for last)
+      # @return [Eco::CSV::Table] with a new column named `name` with the row number
+      def add_index_column(header_name = 'idx', pos: 0)
+        header_name = header_name.to_s.strip
+        add_column(header_name, pos: pos).tap do |table|
+          table.each.with_index do |row, idx|
+            row[header_name] = idx + 2
+          end
+        end
       end
 
       # @return [Array<::CSV::Row>]
@@ -221,7 +258,6 @@ module Eco
           raise "Input type not supported. Given: #{data.class}"
         end
       end
-
     end
   end
 end

data/lib/eco/data/files/helpers.rb

@@ -119,6 +119,7 @@ module Eco
       end
 
       class << self
+        include Files::InstanceMethods
         include Files::ClassMethods
       end
     end