eco-helpers 2.6.3 → 2.7.0

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

@@ -0,0 +1,15 @@
+module Eco::API::UseCases::GraphQL::Samples::Location::Service
+  module TreeToList
+    module Converter
+      module Input
+        include Eco::API::UseCases::GraphQL::Samples::Location::DSL
+
+        private
+
+        def input_tagtree
+          @input_tagtree ||= live_tree
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Eco::API::UseCases::GraphQL::Samples::Location::Service
+  module TreeToList
+    module Converter
+      module NodeAttrMaps
+        # Basic mappints to create NodeDiff
+        NODE_ATTR_MAPS = {
+          'id'             => 'nodeId',
+          'parent_id'      => 'parentId',
+          'parent_name'    => 'parentName',
+          'archived_token' => 'archivedToken',
+          'level'          => 'level_reference'
+        }.freeze
+
+        private
+
+        def node_attr_maps
+          self.class::NODE_ATTR_MAPS
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Eco::API::UseCases::GraphQL::Samples::Location::Service
+  module TreeToList
+    module Converter
+      module Parser
+        private
+
+        # Adds up to the generic_node_parser
+        # def custom_node_parser(node_hash)
+        #   node_hash.each do |key, val|
+        #   end
+        # end
+
+        def node_parser_block
+          return @node_parser_block if instance_variable_defined?(:@node_parser_block)
+          custom_before = custom_node_parser_before_block
+          custom_after  = custom_node_parser_block
+          @node_parser_block = proc do |node_hash|
+            node_hash.tap do
+              custom_before&.call(node_hash)
+              default_node_parse(node_hash)
+              custom_after&.call(node_hash)
+            end
+          end
+        end
+
+        # Grabs the custom node parser that runs after the generic one
+        def custom_node_parser_block
+          return nil unless respond_to?(:custom_node_parser, true)
+          method(:custom_node_parser)
+        end
+
+        def custom_node_parser_before_block
+          return nil unless respond_to?(:custom_node_parser_before, true)
+          method(:custom_node_parser_before)
+        end
+
+        # Generic parsing
+        def default_node_parse(node_hash)
+          class_ids = to_classification_ids(node_hash['classifications'])
+          node_hash['classifications'] = class_ids
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require_relative 'converter/parser'
+require_relative 'converter/input'
+require_relative 'converter/node_attr_maps'
+require_relative 'converter/discarded'
+
+module Eco::API::UseCases::GraphQL::Samples::Location::Service
+  module TreeToList
+    module Converter
+      include Parser
+      include Input
+      include NodeAttrMaps
+      include Discarded
+
+      private
+
+      # Converter. Transforms an org tagtree to a list of hash nodes
+      # @note it ensures `DISCARDED_NODES` are excluded
+      # @return [Array<Hash>] list of hash nodes
+      def as_nodes_json(tree = input_tagtree)
+        tree.reject do |node|
+          discarded?(node.id)
+        end.each_with_object([]) do |node, list|
+          list << node.as_json(include_children: false).transform_keys do |key|
+            next key unless node_attr_maps.key?(key)
+            node_attr_maps[key]
+          end.tap do |node_hash|
+            node_parser_block&.call(node_hash)
+            yield(node_hash) if block_given?
+          end
+        end.tap do |list|
+          list.each(&node_parser_block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Eco::API::UseCases::GraphQL::Samples::Location::Service
+  module TreeToList
+    module Output
+      OUT_FOLDER      = 'sftp'.freeze
+      OUT_TIME_FORMAT = '%Y%m%dT%H%M%S'.freeze
+      OUT_FILENAME    = 'Location_Nodes.csv'.freeze
+      OUT_HEADER      = %w[
+        nodeId
+        name
+        parentId
+        parentName
+        archived
+        archivedToken
+        weight
+        level_reference
+      ].freeze
+
+      private
+
+      def generate_live_nodes_file(nodes_list)
+        return unless generate_live_nodes_file?
+        CSV.open(output_filename, "w") do |csv|
+          csv << output_header
+          nodes_list do |item|
+            csv << item.values_at(*output_header)
+          end
+        end
+        log(:info) { "Created file: #{output_filename}" }
+      end
+
+      def output_header
+        self.class::OUT_HEADER
+      end
+
+      def generate_live_nodes_file?
+        true
+      end
+
+      def output_filename
+        @output_filename ||= File.join(output_folder, "#{timestamp}_#{output_file}")
+      end
+
+      def output_folder
+        "#{config.active_enviro}/#{self.class::OUT_FOLDER}"
+      end
+
+      def output_file
+        options.dig(:output, :file) || self.class::OUT_FILENAME
+      end
+
+      def timestamp(date = Time.now)
+        date.strftime(self.class::OUT_TIME_FORMAT)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Eco::API::UseCases::GraphQL::Samples
+  module Location::Service
+    # Service to transform (CONVERT or PARSE) an input locations structure into a list
+    # of hash nodes.
+    # @note it can have multiple usages
+    #   1. Live locations tree structure into a nodes list file (nodeId, parendId, name,...)
+    #   2. A locations tree built from an input csv into a nodes list hash
+    #   3. Change the keys of the hash nodes
+    #   4. Parse the values
+    # @note this use case can be inherited from to provision **parsed** input to other
+    #   use cases.
+    # @note it allows to define `custom_node_parser` and `custom_node_parser_after`
+    #   methods (param: `node_hash`), to allow custom parsing.
+    #   - It has a generic parser that validates the `classifications`
+    # As this format allows to easily compare what has changed in the locations structure.
+    # @example
+    #     class Custom::UseCase::TagtreeToList < Eco::API::UseCases::GraphQL::Samples::Location
+    #       name 'tagtree-to-list'
+    #       type :other
+    #
+    #       include Eco::API::UseCases::GraphQL::Samples::Location::Service::TreeToList
+    #
+    #     end
+    module TreeToList
+      include Eco::API::UseCases::GraphQL::Samples::Location::DSL
+
+      require_relative 'tree_to_list/output'
+      require_relative 'tree_to_list/converter'
+
+      include Output
+      include Converter
+
+      def process
+        as_nodes_json(input_tagtree).tap do |list|
+          next generate_live_nodes_file(list) unless list.empty?
+          log(:error) { "There are no location nodes!" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+require_relative 'service/base'
+require_relative 'service/tree_to_list'
+require_relative 'service/tree_diff'
+
+module Eco::API::UseCases::GraphQL::Samples
+  module Location::Service
+  end
+end

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

@@ -7,4 +7,5 @@ module Eco::API::UseCases::GraphQL
   end
 end
 
+require_relative 'location/service'
 require_relative 'location/command'

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

@@ -2,61 +2,121 @@ 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 || ''}"
+    def upload(local_file, subfolder: remote_subfolder, gid: sftp_group_id)
+      sftp_session.upload(
+        local_file,
+        remote_folder: remote_folder(subfolder),
+        gid:           gid
+      )
     end
+    alias_method :sftp_upload, :upload
 
     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)
+        self.class.const_get(:SFTP_GROUP)
+      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.exist?(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})
+    def sftp_download_files(subfolder: remote_subfolder, pattern: nil, local_folder: self.local_folder)
+      with_remote_files(subfolder: subfolder, pattern: pattern).tap do |files|
+        next if files.empty?
+        file_names = files.map {|file| to_remote_path(file.name, subfolder: subfolder)}
+
+        log(:info) {
+          msg  = "Getting the following files into the local folder '#{local_folder}':\n"
+          msg << "  • "
+          msg << files_names.join("\n  • ")
+          msg
+        }
+
+        sftp.download(file_names, local_folder: local_folder)
       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
+    def sftp_move_file(source, dest)
+      sftp.move(source, dest, 0x0001) do |response|
+        if response.ok?
+          log(:info) { "#{source}\n  -to-> #{dest}"    }
+        else
+          log(:info) { "Could not move file #{source}" }
+        end
+      end
+    end
+
+    def ensure_remote_empty(subfolder: remote_subfolder, pattern: nil)
+      files = with_remote_files(subfolder: subfolder, pattern: pattern)
+      return if files.empty?
+
+      msg  = "There are still files in the remote folder that will be deleted: '#{subfolder}':\n"
+      msg << "  • "
+      str  = files.map(&:longname).join("\n  • ")
+      str << "\n"
+      msg << str
+
+      session.prompt_user(
+        "Do you want to proceed to delete? (Y/n):",
+        explanation: msg,
+        default:     "Y",
+        timeout:     3
+      ) do |response|
+        next unless response.upcase.start_with?("Y")
+
+        files.each do |file|
+          remote_full_path = to_remote_path(file.name, subfolder: subfolder)
+          res              = sftp_session.remove(remote_full_path)
+          log(:info) {
+            "Deleted remote file: '#{remote_full_path}' (#{res})"
+          }
         end
       end
     end
 
-    def with_remote_files
-      sftp.files(remote_folder).each do |remote_file|
+    # @param subfolder [String] the subfolder.
+    def with_remote_files(subfolder: remote_subfolder, pattern: nil)
+      sftp.files(remote_folder(subfolder), pattern: pattern).each do |remote_file|
         yield(remote_file) if block_given?
       end
+    rescue ArgumentError
+      raise
+    rescue ::Net::SFTP::StatusException => err
+      log(:error) {
+        msg  = "(#{self.class}) There was an error trying to access "
+        msg << "the remote folder '#{subfolder}': #{err}"
+        msg
+      }
+      []
+    end
+
+    def to_remote_path(file, subfolder: remote_subfolder)
+      [remote_folder(subfolder), file].join('/')
+    end
+
+    def remote_subfolder
+      if (remote_dir = options.dig(:sftp, :remote_subfolder))
+        remote_dir
+      elsif self.class.const_defined?(:REMOTE_FOLDER)
+        self.class::REMOTE_FOLDER
+      end
     end
 
-    def to_remote_path(file, subfolder: nil)
-      remote_folder(subfolder) + "/" + file
+    def remote_folder(subfolder = remote_subfolder)
+      [sftp_env_base_path, subfolder].compact.join('/')
+    end
+
+    def sftp_env_base_path
+      sftp_config.remote_folder
+    end
+
+    def local_folder
+      if (local_dir = options.dig(:sftp, :local_folder))
+        local_dir
+      elsif self.class.const_defined?(:LOCAL_FOLDER)
+        self.class::LOCAL_FOLDER
+      else
+        "."
+      end
     end
 
     def sftp_config

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

@@ -23,8 +23,8 @@ class Eco::API::UseCases::OozeCases::ExportRegisterCase < Eco::API::UseCases::Oo
 
   def filters
     [].tap do |fltrs|
-      [:any, :all].each {|mode| fltrs << build_tags_filter(mode)}
-      [:created_at, :updated_at].each {|key| fltrs << build_range_filter(key)}
+      %i[any all].each {|mode| fltrs << build_tags_filter(mode)}
+      %i[created_at updated_at].each {|key| fltrs << build_range_filter(key)}
     end.compact
   end
 
@@ -45,8 +45,10 @@ class Eco::API::UseCases::OozeCases::ExportRegisterCase < Eco::API::UseCases::Oo
   end
 
   def build_range_filter(key = :update_at)
-    from = from_date(key); to = to_date(key)
+    from = from_date(key)
+    to   = to_date(key)
     return nil unless from || to
+
     date_range_filter(from: from, to: to, key: key)
   end
 
@@ -64,9 +66,9 @@ class Eco::API::UseCases::OozeCases::ExportRegisterCase < Eco::API::UseCases::Oo
 
   def export_options
     @export_options ||= {
-      delimiter: options_delimiter,
-      only_indexed: include_deindexed?,
-      only_labeled: include_unnamed?,
+      delimiter:     options_delimiter,
+      only_indexed:  include_deindexed?,
+      only_labeled:  include_unnamed?,
       only_with_ref: include_unhashed?
     }
   end

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

@@ -13,9 +13,9 @@ module Eco
                 drafting_entry(template_id) do |draft|
                   yield(draft) if block_given?
 
-                  if page_id = create_entry(draft, reference: draft_reference)
+                  if (page_id = create_entry(draft, reference: draft_reference))
                     log(:info) { "Page '#{page_id}' created successfully -- #{draft_reference}" }
-                  elsif options.dig(:dry_run)
+                  elsif options[:dry_run]
                     log(:info) { "Simulated launch for #{draft_reference}" }
                   end
                 end
@@ -32,7 +32,7 @@ module Eco
               # Does the actual creation of the entry
               def create_entry(draft, reference: "new entry from #{draft&.template_id}")
                 with_rescue(reference) do
-                  if result = create_ooze(draft, template_id: draft.template_id)
+                  if (result = create_ooze(draft, template_id: draft.template_id))
                     return result.page_id
                   end
                 end
@@ -48,6 +48,7 @@ module Eco
 
               def validate_base_type!(base)
                 return super if defined?(super)
+
                 msg  = "#{self} can only be included in Eco::API::UseCases::OozeSamples::RegisterUpdateCase"
                 msg << "\nCan't be included in #{base}"
                 raise LoadError, msg unless base <= Eco::API::UseCases::OozeSamples::RegisterUpdateCase

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

@@ -5,18 +5,23 @@ module Eco
         module Helpers
           # Class to ease the export process
           class ExportableOoze
-            MERGE_DELIMITER = "#:#"
-
-            META_FIELDS = {
-              "id"   => "Internal ID",
-              "uid"  => "Unique ID",
-              "name" => "Name of Page",
-              "state" => "State of Page",
-              "time_zone" => "Time Zone",
+            MERGE_DELIMITER = "#:#".freeze
+            META_FIELDS     = {
+              "id"         => "Internal ID",
+              "uid"        => "Unique ID",
+              "name"       => "Name of Page",
+              "state"      => "State of Page",
+              "time_zone"  => "Time Zone",
               "created_at" => "Page Created",
               "updated_at" => "Last updated",
-              "tags" => "Location Tags"
-            }
+              "tags"       => "Location Tags"
+            }.freeze
+            DEFAULT_OPTIONS = {
+              delimiter:     "\n",
+              only_indexed:  true,
+              only_labeled:  true,
+              only_with_ref: true
+            }.freeze
 
             class << self
               def label?(field)
@@ -24,9 +29,9 @@ module Eco
               end
 
               def label(field, default: nil)
-                value = nil
+                value   = nil
                 value ||= field.label.to_s.strip if field.respond_to?(:label)
-                value = (!value || value.empty?) ? nil : value
+                value   = nil unless value && !value.empty?
                 return value if value || !default
                 default || "Unnamed field:"
               end
@@ -42,8 +47,10 @@ module Eco
 
               def key_to_ref(str)
                 return str unless str.include?(MERGE_DELIMITER)
+
                 ref = str.split(MERGE_DELIMITER).first
-                ref.to_s.strip.empty?? nil : ref
+                return ref unless ref.to_s.strip.empty?
+                nil
               end
 
               def indexed?(field)
@@ -65,14 +72,11 @@ module Eco
             attr_reader :options
 
             def initialize(ooze, **options)
-              raise "Expecting Ecoportal::API::V2::Page. Given: #{ooze.class}" unless ooze.is_a?(Ecoportal::API::V2::Page)
-              @ooze = ooze
-              @options = options.merge({
-                delimiter: "\n",
-                only_indexed: true,
-                only_labeled: true,
-                only_with_ref: true
-              })
+              msg = "Expecting Ecoportal::API::V2::Page. Given: #{ooze.class}"
+              raise msg unless ooze.is_a?(Ecoportal::API::V2::Page)
+
+              @ooze    = ooze
+              @options = DEFAULT_OPTIONS.merge(options)
             end
 
             def delimiter
@@ -92,8 +96,17 @@ module Eco
               meta_fields.tap do |data|
                 with_field_section_pairs do |field, section|
                   next unless export?(field)
-                  key = self.class.key_ref_label(field, default: alternative_label(field, section))
-                  data[key] = merge_values(data[key], to_value(field), klass: field.class, delimiter: delimiter)
+
+                  key = self.class.key_ref_label(
+                    field,
+                    default: alternative_label(field, section)
+                  )
+                  data[key] = merge_values(
+                    data[key],
+                    to_value(field),
+                    klass:     field.class,
+                    delimiter: delimiter
+                  )
                 end
               end
             end
@@ -109,6 +122,7 @@ module Eco
               sections = []
               ordered_sections.each_with_object([]) do |section, out|
                 next if sections.include?(section)
+
                 sections << section
                 section.components.each do |field|
                   out << [field, section]
@@ -140,8 +154,8 @@ module Eco
             def export?(field, **opts)
               opts = options.merge(opts)
               return false unless field.respond_to?(:to_s)
-              return false if opts[:only_indexed] && !self.class.indexed?(field)
-              return false if opts[:only_labeled] && !self.class.label?(field)
+              return false if opts[:only_indexed]  && !self.class.indexed?(field)
+              return false if opts[:only_labeled]  && !self.class.label?(field)
               return false if opts[:only_with_ref] && !self.class.with_ref?(field)
               true
             end

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

@@ -5,7 +5,6 @@ module Eco
         module Helpers
           # Class to ease the export process
           class ExportableRegister
-
             attr_reader :options
 
             include Eco::API::UseCases::OozeSamples::Helpers::OozeHandlers
@@ -13,17 +12,17 @@ module Eco
 
             def initialize(**options)
               @options = options.merge({
-                delimiter: "\n",
-                only_indexed: true,
-                only_labeled: true,
+                delimiter:     "\n",
+                only_indexed:  true,
+                only_labeled:  true,
                 only_with_ref: true
               })
             end
 
             def add_ooze(ooze)
-              ooz = ExportableOoze.new(ooze, **options)
-              data = ooz.key_typed_data
-              @typed_header = merge_arrays(data.keys, typed_header)
+              ooz             = ExportableOoze.new(ooze, **options)
+              data            = ooz.key_typed_data
+              @typed_header   = merge_arrays(data.keys, typed_header)
               key_typed_data << data
             end
 
@@ -32,19 +31,18 @@ module Eco
             end
 
             def each(as_values: true, as_row: false, &block)
-              return to_enum(:each, as_row: as_row) unless block
+              return to_enum(:each, as_values: as_values, as_row: as_row) unless block
+
               key_typed_data.each do |ooze_data|
                 values = ooze_data.values_at(*typed_header)
-                case
-                when as_values
+
+                if as_values
                   values
-                when as_row
+                elsif as_row
                   ::CSV::Row.new(values, header)
                 else
                   header.zip(values)
-                end.tap do |out|
-                  yield(out)
-                end
+                end.tap(&block)
               end
             end
 
@@ -62,7 +60,7 @@ module Eco
             end
 
             def key_typed_data
-              @typed_keyed_data ||= []
+              @typed_keyed_data ||= [] # rubocop:disable Naming/MemoizedInstanceVariableName
             end
           end
         end