eco-helpers 2.6.4 → 2.7.1

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

@@ -1,12 +1,9 @@
 class Eco::API::UseCases::GraphQL::Samples::Location
-  # Logic to:
-  #   1. Track-down results and errors
-  #   2. Create tags remap csv table batch design
+  # Logic to: Track-down results and errors
   module Command::Results
-    include Eco::API::UseCases::GraphQL::Helpers::Location::Base
+    include Eco::API::UseCases::GraphQL::Helpers::Base::CaseEnv
 
     attr_accessor :error, :exception
-    attr_accessor :tags_remap_csv_file
 
     def rescued
       yield
@@ -18,39 +15,35 @@ class Eco::API::UseCases::GraphQL::Samples::Location
       Eco::API::UseCases::GraphQL::Helpers::Location::Command::Results
     end
 
-    def tags_remap_class
-      Eco::API::UseCases::GraphQL::Helpers::Location::TagsRemap
-    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 ||= tags_remap_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 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)
+      msg = "Expecting CommandResults object. Given: #{page_results.class}"
+      raise msg 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}" }
+        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!" }
+        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}"
@@ -63,67 +56,5 @@ class Eco::API::UseCases::GraphQL::Samples::Location
 
       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)
-          prev_path = prev_node.path.reverse
-          new_path  = curr_node.path.reverse
-
-          curr_parent = curr_node.parent.top? ? nil : curr_node.parent
-          unless curr_parent&.id == parent_id
-            msg  = "Node '#{node_id}' was moved under '#{parent_id}', "
-            msg << "but in current structure has parent '#{curr_parent&.id}'"
-            log(:warn) { msg }
-          end
-
-          tags_remap_table << [prev_path, new_path]
-        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 |tags_remap|
-            csv << tags_remap.to_csv_row
-          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/service/tree_update.rb

@@ -0,0 +1,89 @@
+class Eco::API::UseCases::GraphQL::Samples::Location
+  module Command::Service
+    # Service to generate the command updates.
+    module TreeUpdate
+      include Eco::API::UseCases::GraphQL::Samples::Location::Service::TreeDiff
+      include Eco::API::UseCases::GraphQL::Samples::Location::Command::DSL
+      include Eco::API::UseCases::GraphQL::Utils::Sftp
+
+      # Whether to stop or continue on command fail
+      FORCE_CONTINUE = false
+
+      def process
+        super
+      ensure
+        rescued { re_archive }
+        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?
+        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.
+      def nodes_diff_class
+        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 this method can only work if we can run cummulative dry-runs to the back-end.
+      #   This is only possible using a draft, which is not that desired.
+      # @note the SFTP push only happens if `remote_subfolder` is defined, via:
+      #   1. `options.dig(:sftp, :remote_subfolder)`
+      #   2. `REMOTE_FOLDER` const
+      def close_handling_tags_remap_csv
+        return false unless super
+        upload(tags_remap_csv_file) unless remote_subfolder.nil?
+        true
+      end
+
+      def email_digest(title)
+        return if simulate?
+        digest_msgs = logger.cache.logs(level: %i[info error warn])
+        exception   = exception ? " - Exception!" : ''
+        subject     = "#{config.active_enviro} - #{title}#{exception}"
+        session.mail(subject: subject, body: digest_msgs.join)
+      end
+
+      def print_diff_details?
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+require_relative 'service/tree_update'
+
+class Eco::API::UseCases::GraphQL::Samples::Location
+  module Command::Service
+  end
+end

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

@@ -0,0 +1,89 @@
+class Eco::API::UseCases::GraphQL::Samples::Location
+  # Logic to: Create tags remap csv table batch design
+  module Command::TrackChangedIds
+    include Eco::API::UseCases::GraphQL::Helpers::Base::CaseEnv
+
+    attr_accessor :tags_remap_csv_file
+
+    REMAP_LOC_IDS_FOLDER   = 'cache'.freeze
+    REMAP_LOC_IDS_FILENAME = 'remap_loc_ids.csv'.freeze
+
+    def tags_remap_csv_full_filename
+      folder   = self.class::REMAP_LOC_IDS_FOLDER
+      filename = self.class::REMAP_LOC_IDS_FILENAME
+      File.join(folder, filename)
+    end
+
+    def tags_remap_class
+      Eco::API::UseCases::GraphQL::Helpers::Location::TagsRemap
+    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 ||= tags_remap_class.new
+    end
+
+    # Generates the file
+    # @note this method can only work if we can run cummulative dry-runs to the back-end.
+    #   This is only possible using a draft, which is not that desired.
+    def close_handling_tags_remap_csv
+      return false if simulate?
+      if tags_remap_table.any?
+        puts "REMAP LOC IDs CSV (content):"
+        puts tags_remap_table
+        true
+      else
+        log(:info) { "Remap location ids NOT needed :)" }
+        false
+      end
+    end
+
+    # Based on commands that succeded, and the batch stage, it tracks
+    # the tag remaps that should be batches against existing pages
+    # @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)
+
+      msg = "Expecting CommandResults object. Given: #{results.class}"
+      raise msg unless results.is_a?(request_results_class)
+
+      results.applied.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]]
+
+        next unless ref_tree.is_a?(Eco::API::Organization::TagTree)
+        next unless ref_tree.tag?(new_id)
+
+        msg  = "Node '#{prev_id}' was updated to '#{new_id}', "
+        msg << "but in current structure '#{new_id}' is not present"
+        log(:warn) { msg }
+      end
+    end
+
+    # Generates the final tags remap file
+    def generate_tags_remap_csv(filename = tags_remap_csv_full_filename)
+      return nil if tags_remap_table.empty?
+      timestamp_file(filename).tap do |file|
+        CSV.open(file, 'w') do |csv|
+          csv << %w[prev_node_ids new_node_ids]
+          tags_remap_table.each do |tags_remap|
+            csv << tags_remap.to_csv_row
+          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

@@ -4,7 +4,10 @@ module Eco::API::UseCases::GraphQL::Samples
     name "location-command"
 
     require_relative 'command/results'
+    require_relative 'command/track_changed_ids'
     require_relative 'command/dsl'
     include Eco::API::UseCases::GraphQL::Samples::Location::Command::DSL
   end
 end
+
+require_relative 'command/service'

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

@@ -0,0 +1,9 @@
+module Eco::API::UseCases::GraphQL::Samples
+  module Location::Service
+    # Base class to create service classes that work like a use case
+    class Base
+      include Eco::API::UseCases::GraphQL::Samples::Location::DSL
+
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Eco::API::UseCases::GraphQL::Samples::Location::Service
+  module TreeDiff
+    module Convertible
+      # Converting headers
+      module Heading
+        # Define the maps src -> dst heading name
+        # @example {'parent_id' => 'parentId' }
+        HEADER_MAPS = {}.freeze
+
+        private
+
+        def header_maps
+          self.class::HEADER_MAPS
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Eco::API::UseCases::GraphQL::Samples::Location::Service
+  module TreeDiff
+    module Convertible
+      module Inputable
+        class << self
+          def included(base)
+            super(base)
+            base.send :include, Eco::Data::Files
+          end
+        end
+
+        include Eco::API::UseCases::GraphQL::Helpers::Base::CaseEnv
+
+        IN_FILENAME  = /requested_tree\.csv/.freeze
+        IN_FOLDER    = 'sftp'.freeze
+
+        private
+
+        def input_encoding
+          options.dig(:input, :file, :encoding) || 'utf-8'
+        end
+
+        def input_file
+          @input_file ||= (options.dig(:input, :file, :name) || newest_file).tap do |file|
+            if file
+              log(:info) { "Using input file '#{file}'" }
+            else
+              log(:warn) { "Could not find any input file" }
+              exit(1)
+            end
+          end
+        end
+
+        def newest_file
+          @newest_file ||= csv_files.last
+        end
+
+        #@note via Eco::Data::Files
+        def csv_files
+          self.class.csv_files(input_folder, regexp: input_file_pattern)
+        end
+
+        def input_file_pattern
+          self.class::IN_FILENAME
+        end
+
+        def input_folder
+          "#{config.active_enviro}/#{self.class::IN_FOLDER}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Eco::API::UseCases::GraphQL::Samples::Location::Service
+  module TreeDiff
+    module Convertible
+      module Parsing
+        module Classifications
+          include Helpers
+
+          # Input classification values into actual
+          # classification values
+          CLASSIFICATION_MAPS = {}.freeze
+
+          private
+
+          def transform_classifications(row)
+            return row if node_classifications_maping.empty?
+            row['classifications'] = into_a(row['classifications']).map do |type|
+              node_classifications_map(type)
+            end.join('|')
+          end
+
+          # Helper to map classifications
+          def node_classifications_map(value)
+            return value unless node_classifications_maping.key?(value)
+            node_classifications_maping[value]
+          end
+
+          def node_classifications_maping
+            self.class::CLASSIFICATION_MAPS
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Eco::API::UseCases::GraphQL::Samples::Location::Service
+  module TreeDiff
+    module Convertible
+      module Parsing
+        module Helpers
+          private
+
+          def as_boolean(value)
+            return false if value.nil? || value == false
+            return true  if value == true
+            return false if value.to_s.strip.empty?
+            return true  if %w[yes x true].include?(value.downcase)
+            false
+          end
+
+          # Helper to convert to array
+          def into_a(value)
+            if value.is_a?(String)
+              value.split('|')
+            else
+              [value].flatten
+            end.compact
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require_relative 'parsing/helpers'
+require_relative 'parsing/classifications'
+module Eco::API::UseCases::GraphQL::Samples::Location::Service
+  module TreeDiff
+    module Convertible
+      # Helpers for transform
+      module Parsing
+        include Helpers
+        include Classifications
+
+        private
+
+        # Custom callback to some required convertions to the input file
+        # provided that it fits to the required input format.
+        def transform_input_csv(csv)
+          row_transform = custom_input_row_transform_block
+          csv_transform = custom_input_csv_transform_block
+
+          csv = csv_transform.call(csv) if csv_transform
+
+          msg  = "Expecting Eco::CSV::Table (i.e. from  'custom_input_csv_transform')."
+          msg << "Given: #{csv.class}"
+          raise ArgumentError, msg unless csv.is_a?(Eco::CSV::Table)
+
+          csv.each do |row|
+            row_transform&.call(row)
+            transform_classifications(row)
+          end
+          csv
+        end
+
+        # The user define block for row transformation
+        def custom_input_row_transform_block
+          return nil unless respond_to?(:custom_input_row_transform, true)
+          method(:custom_input_row_transform)
+        end
+
+        # The user define block for row transformation
+        def custom_input_csv_transform_block
+          return nil unless respond_to?(:custom_input_csv_transform, true)
+          method(:custom_input_csv_transform)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require_relative 'convertible/heading'
+require_relative 'convertible/parsing'
+require_relative 'convertible/inputable'
+module Eco::API::UseCases::GraphQL::Samples::Location::Service
+  module TreeDiff
+    # Offers a way to convert the values and keys/headers
+    # of the input csv file/rows
+    module Convertible
+      class << self
+        def included(base)
+          super(base)
+          base.send :include, Inputable
+        end
+      end
+
+      include Parsing
+      include Heading
+
+      private
+
+      def input_csv
+        @input_csv ||= Eco::CSV.read(input_file, encoding: input_encoding).then do |csv|
+          next csv unless header_maps&.any?
+
+          csv.transform_headers do |name|
+            next name unless header_maps.key?(name)
+            header_maps[name]
+          end
+        end.then do |csv|
+          transform_input_csv(csv).tap do |res|
+            next if res.is_a?(Eco::CSV::Table)
+            raise ArgumentError, "Expecting and Eco::CSV::Table. Given: #{res.class}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module Eco::API::UseCases::GraphQL::Samples
+  module Location::Service
+    # Service to spot the differences between an input file and a locations tree.
+    # @example
+    #    class Custom::UseCase::TagtreeDiff < Eco::API::UseCases::GraphQL::Samples::Location
+    #      name 'tagtree-diff'
+    #      type :other
+
+    #      require_relative 'cli/10_tagtree_diff_cli'
+
+    #      include Eco::API::UseCases::GraphQL::Samples::Location::Service::TreeDiff
+
+    #      IN_FILENAME  = /requested_tree\.csv/.freeze
+    #      IN_FOLDER    = 'sftp'.freeze
+    #      HEADER_MAPS  = {
+    #        'Code'             => 'id',
+    #        'Description'      => 'name',
+    #        'ParentCode'       => 'parent_id',
+    #        'IsActive'         => 'active',
+    #        'LevelDescription' => 'classifications'
+    #      }.freeze
+    #      CLASSIFICATION_MAPS = {
+    #        'Directorate' => 'agency',
+    #        'Subsection'  => 'sub-section',
+    #        'WorkUnit'    => 'work-unit'
+    #      }.freeze
+    #
+    #   def process
+    #     compare
+    #   end
+    #
+    #   private
+    #
+    #   def custom_input_csv_transform(csv)
+    #     csv.add_column('archived')
+    #   end
+    #
+    #   def custom_input_row_transform(row)
+    #     row['archived'] = !as_boolean(row['active'])
+    #   end
+    # end
+    module TreeDiff
+      include Eco::API::UseCases::GraphQL::Samples::Location::Service::TreeToList
+
+      require_relative 'tree_diff/convertible'
+      include Convertible
+
+      def process
+        compare
+      end
+
+      def compare
+        comparer.tap do |cmp|
+          puts comparer.diffs_details if print_diff_details? && cmp.diffs?
+          log(:info) { cmp.diffs_summary }
+          sleep(5)
+        end
+      end
+
+      def comparer(source_1 = live_nodes_list, source_2 = file_nodes_list)
+        @comparer ||= nodes_diff_class.new(
+          source_1,
+          source_2,
+          original_tree: input_tagtree,
+          logger:        logger
+        ).tap do
+          log(:info) {
+            "Comparing #{source_1.count} nodes with #{source_2.count} file nodes."
+          }
+        end
+      end
+
+      private
+
+      def nodes_diff_class
+        Eco::Data::Locations::NodeDiff::NodesDiff
+      end
+
+      def print_diff_details?
+        true
+      end
+
+      def generate_live_nodes_file?
+        false
+      end
+
+      def live_nodes_list
+        @live_nodes_list ||= as_nodes_json(input_tagtree).tap do |list|
+          log(:info) { "Converted live tree to list of #{list.count} hash-nodes" }
+        end
+      end
+
+      # We accept csv input as a `:tree` or as `:nodes`
+      # @note
+      #   1. uses custom converter inherited from base case '01_tatree_to_list_case'
+      #     - `as_nodes_json`
+      #   2. `org_tree` is native from `Eco::Data::Locations::NodeBase::CsvConvert`
+      def file_nodes_list
+        @file_nodes_list ||= as_nodes_json(org_tree(input_csv)).tap do |list|
+          log(:info) { "Converted input csv file to list of #{list.count} hash-nodes" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Eco::API::UseCases::GraphQL::Samples::Location::Service
+  module TreeToList
+    module Converter
+      module Discarded
+        # List of discarded node ids
+        DISCARDED_NODES = [].freeze
+
+        private
+
+        def discarded?(tag)
+          self.class::DISCARDED_NODES.include?(tag)
+        end
+      end
+    end
+  end
+end