eco-helpers 3.2.1 → 3.2.3

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

@@ -1,9 +1,51 @@
 class Eco::API::UseCases::GraphQL::Samples::Location
   module Command::DSL
+    include Eco::API::UseCases::GraphQL::Samples::Location::Service::TreeDiff
     include Eco::API::UseCases::GraphQL::Helpers::Location::Command
     include Eco::API::UseCases::GraphQL::Samples::Location::Command::TrackChangedIds
     include Eco::API::UseCases::GraphQL::Samples::Location::Command::Results
 
+    def print_diff_details?
+      false
+    end
+
+    # Default tree tacking behaviour
+    # @note
+    #   1. This aims to optimize the time run
+    #   2. Based on update stage, there are differentiated tracking needs
+    # @note Available options are:
+    #   - :per_request -> on each request
+    #   - :per_batch   -> at the end of each batch / stage (on last page)
+    #   - :once        -> only when the script starts to run
+    # @return [Symbol] the tracking mode
+    def batch_tree_track_mode(stage)
+      case stage
+      when :unarchive, :archive
+        :once
+      when :id, :id_name
+        :per_request
+      when :insert, :move
+        :per_batch
+      else
+        default_tree_tracking_mode
+      end
+    end
+
+    # With given the commands, it generates the input of the endpoint mutation.
+    # @param commands [Array<Hash>]
+    def input(commands, force_continue: force_continue?)
+      return unless (commands || []).any?
+
+      results.draft ||= create_draft(current_tree.id).draft
+
+      {
+        clientMutationId: '',
+        id:               results.draft_id,
+        commands:         commands
+      }
+    end
+
+    # @note this method should be overriden/re-implemented
     # @example of implementation:
     #     def inputs(command_types, force_continue: force_continue?)
     #       {}.tap do |sequence|
@@ -16,14 +58,27 @@ class Eco::API::UseCases::GraphQL::Samples::Location
     #         end
     #       end
     #     end
-    def inputs(*_args, force_continue: force_continue?, **_kargs, &_block) # rubocop:disable Lint/UnusedMethodArgument
-      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
+    def inputs(nodes_diff = comparer, force_continue: force_continue?)
+      {}.tap do |sequence|
+        unless nodes_diff && nodes_diff.respond_to?(:commands)
+          msg  = "You should implement this method in your child class.\n"
+          msg << "Which should yield the input Hash and the stage or descriptor.\n"
+          msg << "Or you should provide the `nodes_diff` object."
+          raise Eco::API::UseCases::GraphQL::Base::NotImplementedMethod, msg
+        end
+
+        nodes_diff.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
 
-    # Main processor
-    def process # rubocop:disable Metrics/AbcSize
+    # MAIN PROCESSOR
+    def process
       self.error = false
 
       with_error_handling do
@@ -32,49 +87,152 @@ class Eco::API::UseCases::GraphQL::Samples::Location
         # this may trigger a backup of the tagtree
         self.current_tree ||= live_tree
 
-        inputs(force_continue: force_continue?) do |input, stage|
-          results[stage] ||= []
-
-          track_mode = batch_tree_track_mode(stage)
-
-          # yields the result of each batch
-          sliced_batches(input, desc: stage, track_tree_mode: track_mode) do |sliced_input, response, page, pages, done, total| # rubocop:disable Metrics/ParameterLists, Layout/LineLength
-            track_current_tree(response&.structure)
-
-            results[stage] << (page_results = request_results_class.new(sliced_input, response))
-            update_tags_remap_table(page_results, stage, current_tree)
+        inputs(
+          force_continue: force_continue?
+        ) do |input, stage|
+          next unless input
 
-            self.error = page_errors?(page_results, page, pages, done, total, stage: stage)
-            break if error
-          end
+          sliced_batches(
+            input,
+            desc:            stage,
+            track_tree_mode: batch_tree_track_mode(stage),
+            &results_tracking_block(stage: stage)
+          )
 
-          break if error
+          break if error?
         rescue StandardError => err
           log(:error) { err.patch_full_message }
           raise
         end
       end
     ensure
-      rescued { self.tags_remap_csv_file = generate_tags_remap_csv }
-      rescued { close_handling_tags_remap_csv }
+      rescued { rearchive } unless exception
+      rescued { delete_or_publish_draft }
+      rescued { manage_remaps_table     }
     end
   end
 
-  # Default tree tacking behaviour
-  # @note
-  #   1. This aims to optimize the time run
-  #   2. Based on update stage, there are differentiated tracking needs
-  # @return [Symbol] the tracking mode
-  def batch_tree_track_mode(stage)
-    case stage
-    when :unarchive, :archive
-      :once
-    when :id, :id_name
-      :per_request
-    when :insert, :move
-      :per_batch
+  def results_tracking_block(stage:)
+    proc do |sliced_input, response, page, pages, done, total|
+      # yields the result of each batch
+
+      input_response = input_unit_response_class.new(
+        sliced_input,
+        response
+      )
+
+      results.add_response(
+        stage,
+        input_response
+      )
+
+      # @todo: might need to set the name and the id by treeifying here.
+      #   Alternatively, add named arguments id and name.
+      track_current_tree(results.structure)
+
+      # early detection of errors
+      self.error ||= page_errors?(
+        input_response,
+        page,
+        pages,
+        done,
+        total,
+        stage: stage
+      )
+    end
+  end
+
+  private
+
+  # Work with adapted diff builders.
+  def nodes_diff_class
+    Eco::API::UseCases::GraphQL::Helpers::Location::Command::Diffs
+  end
+
+  # Before closing, run RE-ARCHIVE: those that where unarchived via archivedToken
+  # that should remain archived.
+  # @note this is an additional necessary step
+  def rearchive
+    return if exception?
+    return unless rearchive_comparer.respond_to?(:stage_commands)
+    return unless rearchive_diffs.any?
+
+    rearchive_commands = rearchive_comparer.stage_commands(:archive)
+    return unless rearchive_commands.any?
+
+    results.draft ||= create_draft(current_tree.id).draft
+
+    stage = :rearchive
+
+    rearchive_comparer.tap do
+      archive_input = input(
+        rearchive_commands,
+        force_continue: true
+      )
+
+      sliced_batches(
+        archive_input,
+        desc:            stage,
+        track_tree_mode: :once,
+        &results_tracking_block(stage: stage)
+      )
+    rescue StandardError => err
+      log(:error) { err.patch_full_message }
+      raise
+    end
+  end
+
+  def rearchive_comparer
+    @rearchive_comparer ||= nodes_diff_class.new(
+      as_nodes_json(current_tree), # hash_list(current_tree),
+      file_nodes_list,
+      original_tree: current_tree,
+      logger:        logger
+    )
+  end
+  alias_method :rearchive_diffs, :rearchive_comparer
+
+  def delete_or_publish_draft
+    return unless results.draft_id
+
+    if simulate? || error? || exception?
+      delete = true
+
+      if simulate?
+        delete = false
+        should_delete? { delete = true}
+      end
+
+      delete_draft(results.draft_id) if delete
     else
-      default_tree_tracking_mode
+      results.final_response(
+        publish_draft(results.draft_id)
+      )
+    end
+  end
+
+  def should_delete?
+    session.prompt_user(
+      'Should delete temporary draft? (Y/n):',
+      default: 'Y',
+      timeout: 5
+    ) do |response|
+      next unless response.upcase.start_with?('Y')
+
+      yield
     end
   end
+
+  def manage_remaps_table
+    return unless results.final_response?
+
+    rescued do
+      results.applied_commands(with_id_change: true) do |result|
+        update_tags_remap_table(result.command)
+      end
+    end
+
+    rescued { self.tags_remap_csv_file = generate_tags_remap_csv }
+    rescued { close_handling_tags_remap_csv }
+  end
 end

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

@@ -5,46 +5,78 @@ class Eco::API::UseCases::GraphQL::Samples::Location
 
     attr_accessor :error
 
-    def request_results_class
+    def error?
+      !!error
+    end
+
+    def input_unit_response_class
+      Eco::API::UseCases::GraphQL::Helpers::Location::Command::InputUnitResponse
+    end
+
+    def run_results_class
       Eco::API::UseCases::GraphQL::Helpers::Location::Command::Results
     end
 
     # Capture results
     def results
-      @results ||= {}
+      @results ||= run_results_class.new
     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 input_unit_response [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)
-      msg = "Expecting CommandResults object. Given: #{page_results.class}"
-      raise msg unless page_results.is_a?(request_results_class)
+    def page_errors?(input_unit_response, page, pages, done, total, stage: nil)
+      msg = "Expecting CommandResults object. Given: #{input_unit_response.class}"
+      raise msg unless input_unit_response.is_a?(input_unit_response_class)
 
       stage_str   = stage ? "'#{stage}' " : ''
       fingerprint = "#{stage_str}#{page} (of #{pages})"
-      errored     = false
 
-      if page_results.error?
+      if (errored = input_unit_response.error?)
+        log(:error) {
+          msg  = "Error on #{fingerprint}: "
+          msg << JSON.pretty_generate(input_unit_response.error_doc)
+          msg
+        }
+      else
+        log(:info) {
+          "Success on #{fingerprint}: #{done} (of #{total}) commands added!"
+        }
+      end
+
+      errored
+    end
+
+    def result_errors?
+      errored = false
+
+      if results.error?
         errored = true
         log(:error) {
-          "Error on #{fingerprint}: #{page_results.error.doc.pretty_inspect}"
+          msg  = "Error on #{fingerprint}: "
+          msg << JSON.pretty_generate(input_unit_response.error_doc)
+          msg
         }
       end
 
-      if page_results.applied?
+      # @todo: intermediate status check on drafts doesn't rely on applied
+      #   This is rather to be done at the very end, when publishing the draft.
+      if input_unit_response.applied?
         log(:info) {
           "Success on #{fingerprint}: #{done} (of #{total}) commands applied!"
         }
-      elsif page_results.errored?
+      elsif input_unit_response.errored?
         errored = true
-        msg     = "Some command failed on #{fingerprint}:\n#{page_results.stats}"
+        msg     = "Some command failed on #{fingerprint}:\n"
+        msg    << input_unit_response.stats
+
         unless force_continue?
-          first_errored = page_results.first_errored
+          first_errored = input_unit_response.first_errored
           msg << "The error(s) - #{first_errored.error_msg}\n"
         end
+
         log(:error) { msg }
       end
 

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

@@ -9,7 +9,6 @@ class Eco::API::UseCases::GraphQL::Samples::Location
         def included(base)
           super
 
-          base.send :include, Eco::API::UseCases::GraphQL::Samples::Location::Service::TreeDiff
           base.send :include, Eco::API::UseCases::GraphQL::Samples::Location::Command::DSL
           base.send :include, Eco::API::UseCases::GraphQL::Utils::Sftp
           base.send :include, InstanceMethods
@@ -22,43 +21,9 @@ class Eco::API::UseCases::GraphQL::Samples::Location
             super
           end
         ensure
-          rescued { re_archive } unless exception?
           rescued { email_digest('TagTree Update') }
         end
 
-        # Before closing, run RE-ARCHIVE: those that where unarchived via archivedToken
-        # that should remain archived.
-        # @note this is an additional necessary step
-        def re_archive
-          return if simulate?
-          return if exception?
-
-          stage = :rearchive
-
-          nodes_diff_class.new(
-            hash_list(current_tree),
-            file_nodes_list,
-            original_tree: current_tree,
-            logger:        logger
-          ).tap do |nodes_diff|
-            archive_input = input(
-              nodes_diff.stage_commands(:archive),
-              force_continue: true
-            )
-
-            sliced_batches(
-              archive_input,
-              desc:            stage,
-              track_tree_mode: :once
-            ) do |sliced_input, response, page, pages, count, total| # rubocop:disable Metrics/ParameterLists
-              page_results = request_results_class.new(sliced_input, response)
-              (results[stage] ||= []) << page_results
-
-              self.error ||= page_errors?(page_results, page, pages, count, total, stage: stage)
-            end
-          end
-        end
-
         private
 
         # Work with adapted diff builders.
@@ -66,18 +31,6 @@ class Eco::API::UseCases::GraphQL::Samples::Location
           Eco::API::UseCases::GraphQL::Helpers::Location::Command::Diffs
         end
 
-        def inputs(nodes_diff = comparer, force_continue: force_continue?)
-          {}.tap do |sequence|
-            nodes_diff.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
-
         # Generates the file and pushes to the SFTP folder
         # @note it also displays the mappings on screen
         # @note the SFTP push only happens if `remote_subfolder` is defined, via:
@@ -106,10 +59,6 @@ class Eco::API::UseCases::GraphQL::Samples::Location
             options.deep_merge!({worfklow: {no_email: true}})
           end
         end
-
-        def print_diff_details?
-          false
-        end
       end
     end
   end

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

@@ -28,7 +28,7 @@ class Eco::API::UseCases::GraphQL::Samples::Location
     # @note this method used to only work if we could run cummulative dry-runs to the back-end.
     #   However, after RS P3, as mappings are one-to-one (not many-to-many per row),
     #   we can just display the mappings in dry-run as well.
-    def close_handling_tags_remap_csv
+    def close_handling_tags_remap_csv # rubocop:disable Naming/PredicateMethod
       if tags_remap_table.any?
         puts "REMAP LOC IDs CSV (content):"
         puts tags_remap_table
@@ -44,21 +44,13 @@ class Eco::API::UseCases::GraphQL::Samples::Location
     # @note The only update operation that generate tag remaps
     #   is `:id` (or `:id_name`).
     # @return [Boolean] whether new maps were inserted to the tracking table
-    def update_tags_remap_table(results, stage, ref_tree = nil)
-      return false unless %i[id id_name].include?(stage)
+    def update_tags_remap_table(command)
+      prev_id, new_id = command.values_at(:nodeId, :newId)
 
-      msg = "Expecting CommandResults object. Given: #{results.class}"
-      raise msg unless results.is_a?(request_results_class)
+      return if new_id.nil? # not an id change
+      return if prev_id == new_id
 
-      target = simulate?? results.results : results.applied
-
-      target.each do |result|
-        prev_id, new_id = result.command_input_data.values_at(:nodeId, :newId)
-        next if new_id.nil? # not an id change
-        next if prev_id == new_id
-
-        tags_remap_table << [[prev_id], [new_id]]
-      end
+      tags_remap_table << [[prev_id], [new_id]]
     end
 
     # Generates the final tags remap file

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

@@ -1,7 +1,7 @@
 # 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"
+    name 'location-command'
 
     require_relative 'command/results'
     require_relative 'command/track_changed_ids'

data/lib/eco/api/usecases/graphql/samples/location/service/tree_diff/convertible/inputable.rb

@@ -38,7 +38,10 @@ module Eco::API::UseCases::GraphQL::Samples::Location::Service
 
         #@note via Eco::Data::Files
         def csv_files
-          self.class.csv_files(input_folder, regexp: input_file_pattern)
+          self.class.csv_files(
+            input_folder,
+            regexp: input_file_pattern
+          )
         end
 
         def input_file_pattern

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

@@ -53,6 +53,8 @@ module Eco::API::UseCases::GraphQL::Samples
 
       def process
         with_error_handling do
+          next unless compare_live_with_file?
+
           compare
         end
       end
@@ -87,6 +89,10 @@ module Eco::API::UseCases::GraphQL::Samples
         Eco::Data::Locations::NodeDiff::NodesDiff
       end
 
+      def compare_live_with_file?
+        true
+      end
+
       def print_diff_details?
         true
       end

data/lib/eco/api/usecases/graphql/samples/location/service/tree_to_list/converter/input.rb

@@ -6,6 +6,7 @@ module Eco::API::UseCases::GraphQL::Samples::Location::Service
 
         private
 
+        # @todo this name is confusing. It is actually the `current_tagtree` :D
         def input_tagtree
           @input_tagtree ||= live_tree
         end

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

@@ -30,7 +30,7 @@ module Eco::API::UseCases::Lib
     def rescued
       yield
     rescue StandardError => err
-      self.exception ||= err
+      @exception ||= err
 
       return unless exception_already_captured?(err)
 

data/lib/eco/api/usecases/ooze_samples/helpers/creatable.rb

@@ -42,6 +42,7 @@ module Eco
             class << self
               def included(base)
                 super
+
                 validate_base_type!(base)
                 base.include(InstanceMethods)
               end

data/lib/eco/api/usecases/ooze_samples/helpers/rescuable.rb

@@ -40,6 +40,7 @@ module Eco
             class << self
               def included(base)
                 super
+
                 validate_base_type!(base)
                 base.include(InstanceMethods)
               end

data/lib/eco/api/usecases/samples/drivers/cli/sftp_cli.rb

@@ -1,4 +1,4 @@
-class  Eco::API::UseCases::Samples::Drivers::Sftp
+class Eco::API::UseCases::Samples::Drivers::Sftp
   class Cli < Eco::API::UseCases::Cli
     desc 'SFTP case: manages remote files that match a file pattern'
 

data/lib/eco/api/usecases/samples/drivers/sftp_sample.rb

@@ -28,7 +28,10 @@ class Eco::API::UseCases::Samples::Drivers::Sftp < Eco::API::Common::Loaders::Us
 
   def list_folder
     puts "Listing remote folder: '#{remote_folder}' (host: #{sftp.host}):"
-    with_remote_files(pattern: file_pattern) {|file| puts file.longname}
+
+    with_remote_files(pattern: file_pattern) do |file|
+      puts file.longname
+    end
   end
 
   def get_files

data/lib/eco/api/usecases/samples/drivers/url_pull_sample.rb

@@ -38,6 +38,7 @@ class Eco::API::UseCases::Samples::Drivers::UrlPull < Eco::API::Common::Loaders:
     base_request(uri, **kargs) do |request|
       http_start(uri) do |http|
         puts "Pulling from url: #{uri}"
+
         return http.request(request)
       end
     end
@@ -73,6 +74,7 @@ class Eco::API::UseCases::Samples::Drivers::UrlPull < Eco::API::Common::Loaders:
   def base_request(uri, user: nil, pass: '')
     Net::HTTP::Get.new(uri).tap do |request|
       request.basic_auth(user, pass) unless user.nil?
+
       yield(request)
     end
   end
@@ -91,6 +93,7 @@ class Eco::API::UseCases::Samples::Drivers::UrlPull < Eco::API::Common::Loaders:
 
   def target_url(required: true)
     fpc = target_url_const
+
     return fpc if fpc
     return     unless required
 
@@ -99,15 +102,15 @@ class Eco::API::UseCases::Samples::Drivers::UrlPull < Eco::API::Common::Loaders:
   end
 
   def target_url_const
-    if (fpc = options.dig(:url_pull, :target_url_const))
-      msg = "(#{self.class}) Invalid file pattern const referral: #{fpc}"
-      raise WrongConst, msg unless fpc.match(CONST_REFERRAL)
-
-      begin
-        self.eval(fpc)
-      rescue NameError
-        self.class.const_get(fpc)
-      end
+    return unless (fpc = options.dig(:url_pull, :target_url_const))
+
+    msg = "(#{self.class}) Invalid file pattern const referral: #{fpc}"
+    raise WrongConst, msg unless fpc.match(CONST_REFERRAL)
+
+    begin
+      self.eval(fpc)
+    rescue NameError
+      self.class.const_get(fpc)
     end
   rescue NameError
     raise WrongConst, "(#{self.class}) Unknown constant: #{fpc}"

data/lib/eco/api/usecases/samples/people/filters/cli/require_id_cli.rb

@@ -0,0 +1,5 @@
+class Eco::API::UseCases::Samples::People::Filters::RequireId
+  class Cli < Eco::API::UseCases::Cli
+    desc 'Import case to discard entries that do NOT have a unique identifier (external_id)'
+  end
+end

data/lib/eco/api/usecases/samples/people/filters/cli/require_min_entries_cli.rb

@@ -0,0 +1,5 @@
+class Eco::API::UseCases::Samples::People::Filters::RequireMinEntries
+  class Cli < Eco::API::UseCases::Cli
+    desc 'Import case to halt if MIN_COUNT is NOT met'
+  end
+end