eco-helpers 2.5.2 → 2.5.4

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

@@ -0,0 +1,87 @@
+module Eco::API::UseCases::GraphQL::Helpers::Location
+  module Base
+    include Eco::API::UseCases::GraphQL::Helpers::Base
+
+    TAGTREE_BACKUP = 'cache/tagtree.json'.freeze
+
+    attr_reader :current_tree
+    attr_accessor :previous_tree
+
+    # Back-up the tree everytime that it is retrieved anew.
+    def current_tree=(value)
+      return current_tree if current_tree == value
+      @current_tree = value
+      backup_tree(current_tree)
+      value
+    end
+
+    # At any moment we want to know how the live tree is
+    # @note it also does a backup
+    # @return [Eco::API::Organization::TagTree] the latest tree (`current_tree`)
+    def track_current_tree(tree)
+      return if simulate?
+      return unless tree
+      latest_tree = tree if tree.is_a?(Eco::API::Organization::TagTree)
+      if tree.respond_to?(:treeify)
+        args = {  enviro: session.enviro, id: tree.id, name: tree.name}
+        latest_tree ||= Eco::API::Organization::TagTree.new(tree.treeify, **args)
+      end
+      latest_tree.tap do |_tree|
+        next unless latest_tree
+        @previous_tree     = @current_tree
+        self.current_tree  = latest_tree
+      end
+    end
+
+    # @param tree [Eco::API::Organization::TagTree, Hash, Array]
+    # @return [Boolean] whether or not the backup was created
+    def backup_tree(tree = current_tree || live_tree)
+      return false if simulate?
+      case tree
+      when Eco::API::Organization::TagTree
+        tagtree = tree.source
+      when Hash, Array
+        # that's allright
+      else
+        log(:error) {
+          "Can't back up tagtree. Expecting TagTree, Hash or Array. Given: #{tree.class}"
+        }
+        return false
+      end
+      file = session.file_manager.save_json(tree, self.class::TAGTREE_BACKUP, :timestamp)
+      logger.debug("Backed up tagtree saved locally to #{file}.")
+      true
+    end
+
+    def tagtree_id
+      %i[target_structure_id tagtree_id structure_id].find {|key| options.dig(:source, key)}
+    end
+
+    # Scopes the target structure `id`.
+    # @note it is basic that the `id` is correctly identified.
+    def target_structure_id
+      @target_structure_id ||= tagtree_id
+      @target_structure_id ||= self.class.const_get(:TARGET_STRUCTURE_ID) if self.class.const_defined?(:TARGET_STRUCTURE_ID)
+      @target_structure_id ||= current_tree.id                            if current_tree.respond_to?(:id)
+      return @target_structure_id if @target_structure_id
+      msg  = "Const TARGET_STRUCTURE_ID has not been defined, "
+      msg << "nor options(:source, :structure_id). "
+      msg << "Infering active locations structure."
+      log(:warn) { msg }
+      if self.current_tree = session.live_tree
+        @target_structure_id = current_tree.id
+      end
+    end
+
+    # Retrieves the live tree only if `current_tree` hasn't been just retrieved.
+    # @note that `target_structure_id` can retrive the live tree (when `id` is not defined)
+    #   By checking if the current_tree changed after calling `target_structure_id` we
+    #   prevent unnecessary requests.
+    def live_tree
+      tree_init = current_tree
+      target_id = target_structure_id
+      return current_tree if current_tree != tree_init
+      self.current_tree = session.live_tree(id: target_id, include_archived: true)
+    end
+  end
+end

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,92 @@
+module Eco::API::UseCases::GraphQL::Helpers::Location
+  module Command
+    include Eco::Language::AuxiliarLogger
+    include Eco::API::UseCases::GraphQL::Helpers::Location::Base
+
+    DEFAULT_COMMANDS_PER_PAGE = 45
+    DEFAULT_FORCE_CONTINUE    = false
+
+    # Prevents each request from timing out
+    def commands_per_page
+      if self.class.const_defined?(:COMMANDS_PER_PAGE)
+        self.class::COMMANDS_PER_PAGE
+      else
+        DEFAULT_COMMANDS_PER_PAGE
+      end
+    end
+
+    # Whether to stop or continue on command fail
+    def force_continue?
+      if self.class.const_defined?(:FORCE_CONTINUE)
+        self.class::FORCE_CONTINUE
+      else
+        DEFAULT_FORCE_CONTINUE
+      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?)
+      {
+        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/utils/sftp.rb

@@ -0,0 +1,74 @@
+module Eco::API::UseCases::GraphQL::Utils
+  module Sftp
+    include Eco::API::UseCases::GraphQL::Helpers::Base::CaseEnv
+
+
+    def remote_subfolder
+      nil
+    end
+
+    def remote_folder(subfolder = remote_subfolder)
+      "#{sftp_config.remote_folder}/#{subfolder || ''}"
+    end
+
+    def sftp_group_id
+      if self.class.const_defined?(:SFTP_GROUP)
+        self.class.const_get(:TARGET_STRUCTURE_ID)
+      elsif group_id = options.dig(:sftp, :group)
+        group_id
+      end
+    end
+
+    def upload(local_file, remote_folder: self.remote_folder, gid: sftp_group_id)
+      return false unless local_file && File.exists?(local_file)
+      dest_file = "#{remote_folder}/#{File.basename(local_file)}"
+      res       = sftp_session.upload!(local_file, dest_file)
+      attrs     = sftp_session.stat!(dest_file)
+      if gid && gid != attrs.gid
+        stat_res = sftp_session.setstat!(dest_file, {permissions: 0660, uid: attrs.uid, gid: gid})
+      end
+      logger.info("Uploaded '#{local_file}' (#{res})")
+    end
+
+    def ensure_remote_empty
+      files = with_remote_files
+      unless files.empty?
+        msg  = "There are still files in the remote folder that will be deleted: '#{remote_folder}':\n"
+        msg += "  • " + files.map do |file|
+          file.longname
+        end.join("\n  • ") + "\n"
+        session.prompt_user("Do you want to proceed to delete? (Y/n):", explanation: msg, default: "Y", timeout: 3) do |response|
+          if response.upcase.start_with?("Y")
+            files.each do |file|
+              remote_full_path = to_remote_path(file.name)
+              res = sftp_session.remove(remote_full_path)
+              logger.info("Deleted remote file: '#{remote_full_path}' (#{res})")
+            end
+          end
+        end
+      end
+    end
+
+    def with_remote_files
+      sftp.files(remote_folder).each do |remote_file|
+        yield(remote_file) if block_given?
+      end
+    end
+
+    def to_remote_path(file, subfolder: nil)
+      remote_folder(subfolder) + "/" + file
+    end
+
+    def sftp_config
+      session.config.sftp
+    end
+
+    def sftp_session
+      sftp.sftp_session
+    end
+
+    def sftp
+      session.sftp
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Eco::API::UseCases::GraphQL
+  module Utils
+  end
+end
+
+require_relative 'utils/sftp'