eco-helpers 2.7.2 → 2.7.4

data/lib/eco/api/usecases/default/people/switch_supervisor_case.rb

@@ -2,22 +2,24 @@ class Eco::API::UseCases::Default::People::SwitchSupervisorCase < Eco::API::Comm
   name "switch-supervisor"
   type :transform
 
-  def main(people, session, options, usecase)
+  def main(people, session, _options, usecase)
     supers   = session.new_job("main", "supers", :update, usecase, :core)
 
-    old_sup, new_sup = get_supers(people).tap do |supers|
-      inform(*supers, session.logger)
+    old_sup, new_sup = get_supers(people).tap do |sups|
+      inform(*sups)
     end
 
     micro.with_each_subordinate(old_sup, people) do |subordinate|
       subordinate.supervisor_id = new_sup&.id
       supers.add(subordinate)
     end.tap do |subordinates|
-      unless subordinates.length > 0
-        sup_str = "#{old_sup.external_id} (#{old_sup.name} - #{old_sup.email})"
-        session.logger.error("There are no subordinates for supervisor #{sup_str}. Aborting...")
-        exit(1)
-      end
+      next unless subordinates.empty?
+
+      sup_str = "#{old_sup.external_id} (#{old_sup.name} - #{old_sup.email})"
+      log(:error) {
+        "There are no subordinates for supervisor #{sup_str}. Aborting..."
+      }
+      exit(1)
     end
   end
 
@@ -26,43 +28,47 @@ class Eco::API::UseCases::Default::People::SwitchSupervisorCase < Eco::API::Comm
   def get_supers(people)
     micro            = session.micro
     old_id,  new_id  = get_super_ids(options)
-    old_sup, new_sup = [nil, nil]
+    old_sup, new_sup = [nil, nil] # rubocop:disable Style/ParallelAssignment
 
     micro.with_supervisor(old_id, people) do |supervisor|
-      unless old_sup = supervisor
-        session.logger.error("Couldn't find any user with that id (old-super): '#{old_id}'. Aborting...")
+      unless (old_sup = supervisor)
+        log(:error) {
+          "Couldn't find any user with that id (old-super): '#{old_id}'. Aborting..."
+        }
         exit(1)
       end
     end
 
     micro.with_supervisor(new_id, people) do |supervisor|
-      unless new_sup = supervisor
-        session.logger.error("Couldn't find any user with that id (new-super): '#{new_id}'. Aborting...")
-        exit(1)
-      end
+      next if (new_sup = supervisor)
+
+      log(:error) {
+        "Couldn't find any user with that id (new-super): '#{new_id}'. Aborting..."
+      }
+      exit(1)
     end
 
     [old_sup, new_sup]
   end
 
   def get_super_ids(options)
-    unless old_id = options.dig(:super, :old)
-      session.logger.error("You haven't specified the original supervisor. Aborting...")
+    unless (old_id = options.dig(:super, :old))
+      log(:error) { "You haven't specified the original supervisor. Aborting..." }
       exit(1)
     end
 
     # we could be setting the supervisor to nil
     unless options[:super].key?(:new)
-      session.logger.error("You haven't specified the new supervisor. Aborting...")
+      log(:error) { "You haven't specified the new supervisor. Aborting..." }
       exit(1)
     end
 
     [old_id, options.dig(:super, :new)]
   end
 
-  def inform(old_sup, new_sup, logger)
+  def inform(old_sup, new_sup)
     msg  = "Switching supervisor '#{old_sup.name}' (#{old_sup.external_id}) "
     msg += "to '#{new_sup&.name}' (#{new_sup&.external_id})"
-    logger.info(msg)
+    log(:info) { msg }
   end
 end

data/lib/eco/api/usecases/default/people/transfer_account_case.rb

@@ -6,7 +6,8 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
   #   * **invocation command**: `-transfer-account-from`
   #
   # These are the steps and jobs it does:
-  #   1. **pair** person entries (note: the `destination-id` entry could not be present, it will add it in such a case).
+  #   1. **pair** person entries (note: the `destination-id` entry could not be present, it will add it
+  #     in such a case).
   #   2. **retrieve** from server persons that were not included in `people`.
   #   3. **validation**
   #     - a person should only receive account from just one user
@@ -24,7 +25,8 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
   #     - **restore** email: sets the receiver email from the dummy address to the final email.
   #       * the final email inbox will receive a **notification** of _email change_
   # @note
-  #   - the `csv` should contain a column `destination-id` containing the person `id` or `external_id` of the person that will be receiving the account.
+  #   - the `csv` should contain a column `destination-id` containing the person `id` or `external_id` of
+  #     the person that will be receiving the account.
   #   - when running this case, it is recommended to use the option `-skip-batch-policies`
   #   - it is highly recommended to either refresh the cache with `-get-people` or use the `-get-partial` option.
   # @param entries [Eco::API::Common::People::Entries] the input entries with the data.
@@ -34,28 +36,29 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
   # @option options [Hash<Symbol, Object>] :include things that should be included.
   #   * `:email` (Boolean) [false] if the `email` should be transferred as well (**command option**: `-include-email`)
   # @option options [Hash<Symbol, Object>] :skip things that should be excluded.
-  #   * `:api_policies` (Boolean) [false] if the `api policies` should be skipped (**command option**: `-skip-api-policies`)
+  #   * `:api_policies` (Boolean) [false] if the `api policies` should be skipped
+  #     (**command option**: `-skip-api-policies`)
   # @return [Void]
-  def main(entries, people, session, options, usecase)
+  def main(entries, _people, session, options, usecase) # rubocop:disable Metrics/AbcSize
     move     = session.new_job("main", "move email accounts", :update, usecase, :account)
     free     = session.new_job("main", "free up accounts",    :update, usecase, :account)
     switch   = session.new_job("main", "switch email",        :update, usecase, :core)
     invite   = session.new_job("post", "invite receivers",    :update, usecase, :account)
     restore  = session.new_job("post", "restore email",       :update, usecase, :core)
 
-    with_each_person_pair(entries, people, session, options) do |src_person, dst_person|
+    with_each_person_pair(entries) do |src_person, dst_person|
       # capture actual initial information
-      src_doc   = src_person.account.doc
-      src_email = src_person.email
-      src_dummy = dummy_email(src_person)
-      dst_email = dst_person.email
-      dst_dummy = dummy_email(dst_person)
-      copy_src_email  = options.dig(:include, :email) || !dst_person.account
-      dst_end_email   = copy_src_email ? src_email : dst_email
+      src_doc        = src_person.account.doc
+      src_email      = src_person.email
+      src_dummy      = dummy_email(src_person)
+      dst_email      = dst_person.email
+      dst_dummy      = dummy_email(dst_person)
+      copy_src_email = options.dig(:include, :email) || !dst_person.account
+      dst_end_email  = copy_src_email ? src_email : dst_email
 
       # account email renamings are necessary to avoid uncertainty and ensure no email taken error
-      move.add(dst_person)    {|dst| dst.email = dst_dummy}
-      move.add(src_person)    {|src| src.email = src_dummy}
+      move.add(dst_person) {|dst| dst.email = dst_dummy}
+      move.add(src_person) {|src| src.email = src_dummy}
       # free accounts up!
       free.add([dst_person, src_person]) {|person| person.account = nil}
       # to effectivelly transfer the user/account, email should be the same during invite
@@ -66,8 +69,10 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
       # recover the original email, if the receiver had account
       restore.add(dst_person) {|dst| dst.email = dst_end_email}
     end.tap do |units|
-      if options[:simulate]
-        units.each {|unit| puts unit.persons.map(&:external_id).join(" --> ")}
+      next unless options[:simulate]
+
+      units.each do |unit|
+        puts unit.persons.map(&:external_id).join(" --> ")
       end
     end
   end
@@ -77,23 +82,24 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
   # if the person has account and an email different to demo+__@ecoportal.co.nz
   # it transforms email to demo+__@ecoportal.co.nz
   def dummy_email(person)
-    return nil   unless email = person.email
+    return nil   unless (email = person.email)
     return email if email.start_with?("demo") && email.end_with?("@ecoportal.co.nz")
     return email unless person.account
     "demo+#{email.split("@").join(".")}@ecoportal.co.nz"
   end
 
-  def with_each_person_pair(entries, people, session, options)
-    units = paired_entries(entries, session) do |unpaired_entries|
-      report_missing_peer!(unpaired_entries, session.logger)
+  def with_each_person_pair(entries)
+    units = paired_entries(entries) do |unpaired_entries|
+      report_missing_peer!(unpaired_entries)
     end.map do |entry_pair|
-      person_pair = to_persons(entry_pair, people, session, options)
+      person_pair = to_persons(entry_pair)
       new_unit(*entry_pair, *person_pair)
     end
-    sort_units(units).tap do |units|
+
+    sort_units(units).tap do |uts|
       # check that there are no repeated sources or destinations, that sources have account
-      validate_pairs!(units, session.logger)
-      units.each do |unit|
+      validate_pairs!(uts)
+      uts.each do |unit|
         yield(*unit.persons) if block_given?
       end
     end
@@ -111,17 +117,20 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
   end
 
   # Entry helpers
-  def to_persons(paired_entry, people, session, options)
-    micro    = session.micro
+  def to_persons(paired_entry)
     [].tap do |persons|
       micro.with_each(paired_entry, people, options) do |entry, person|
         next persons.push(person) unless person.new?
-        if person = session.batch.search([entry], silent: true).people.first
+
+        person = session.batch.search([entry], silent: true).people.first
+        if person
           persons.push(person)
           people << person
           next
         end
-        session.logger.error("This person does not exist: #{entry.to_s(:identify)}")
+        log(:error) {
+          "This person does not exist: #{entry.to_s(:identify)}"
+        }
         exit(1)
       end
     end.tap do |persons|
@@ -129,22 +138,23 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
     end
   end
 
-  def paired_entries(entries, session)
-    expect_destination_id!(entries, session.logger)
+  def paired_entries(entries)
+    expect_destination_id!(entries)
     missing_peer = []
     entries.each_with_object([]) do |source, out|
-      if peer = entry_peer(source, entries)
+      if (peer = entry_peer(source, entries))
         out.push([source, peer])
       else
         missing_peer.push(source)
       end
-    end.tap do |paired_entries|
+    end.tap do
       yield(missing_peer) if block_given?
     end
   end
 
   def entry_peer(entry, entries)
-    return nil unless peer_id = entry_peer_id(entry)
+    return nil unless (peer_id = entry_peer_id(entry))
+
     entries.entry(id: peer_id, external_id: peer_id) || decouple_peer(entry)
   end
 
@@ -159,7 +169,7 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
 
   def entry_peer_id(entry)
     dest_id = entry.final_entry["destination-id"]
-    return dest_id unless dest_id.to_s.strip.empty?
+    dest_id unless dest_id.to_s.strip.empty?
   end
 
   def entry_peer_id?(entry)
@@ -172,9 +182,11 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
       def persons
         [src_person, dst_person]
       end
-      def reversed_unit?(u2)
-        (src_person == u2.dst_person) && (dst_person == u2.src_person)
+
+      def reversed_unit?(u_2)
+        (src_person == u_2.dst_person) && (dst_person == u_2.src_person)
       end
+
       # givers go first
       def <=>(other)
         return -1 if src_person == other.dst_person
@@ -184,15 +196,15 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
     end
   end
 
-  def new_unit(e1, e2, p1, p2)
-    unit_type.new(e1, e2, p1, p2)
+  def new_unit(e_1, e_2, p_1, p_2)
+    unit_type.new(e_1, e_2, p_1, p_2)
   end
 
   # Units helpers
   def find_repeated(units, &block)
-    units.group_by(&block).select do |k,v|
+    units.group_by(&block).select do |_k, v|
       v.count > 1
-    end.map {|k, v| v.first}
+    end.map {|_k, v| v.first}
   end
 
   def uniq_array(ary, &block)
@@ -201,8 +213,9 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
     end
   end
 
-  def validate_pairs!(units, logger)
+  def validate_pairs!(units) # rubocop:disable Metrics/AbcSize
     missing_account = []
+
     src_repeated = find_repeated(units) do |unit|
       unit.src_person.tap do |src_person|
         missing_account << (src_person.account ? nil : str_person_entry(unit.src_person, unit.src_entry))
@@ -210,32 +223,32 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
     end.each_with_object([]) do |unit, lines|
       lines << str_person_entry(unit.src_person, unit.src_entry)
     end
-    dst_repeated = find_repeated(units) do
-      |unit| unit.dst_person
-    end.each_with_object([]) do |unit, lines|
+
+    dst_repeated = find_repeated(units, &:dst_person).each_with_object([]) do |unit, lines|
       lines << str_person_entry(unit.dst_person, unit.dst_entry, unit.src_entry.idx)
     end
     missing_account.compact!
-    unless [missing_account, src_repeated, dst_repeated].all?(&:empty?)
-      report_missing_account(missing_account.join("\n"), logger) unless missing_account.empty?
 
-      msg = Proc.new do |spot|
-        "Transfers should be a 1.to.1 relation. The following #{spot} entries are repeated in the csv:"
-      end
-      report_repeated(src_repeated.join("\n"), logger, msg["SOURCE"])       unless src_repeated.empty?
-      report_repeated(dst_repeated.join("\n"), logger, msg["DESTINATION"])  unless dst_repeated.empty?
-      exit(1)
+    return if [missing_account, src_repeated, dst_repeated].all?(&:empty?)
+
+    report_missing_account(missing_account.join("\n")) unless missing_account.empty?
+
+    msg = proc do |spot|
+      "Transfers should be a 1.to.1 relation. The following #{spot} entries are repeated in the csv:"
     end
+    report_repeated(src_repeated.join("\n"), msg["SOURCE"])       unless src_repeated.empty?
+    report_repeated(dst_repeated.join("\n"), msg["DESTINATION"])  unless dst_repeated.empty?
+    exit(1)
   end
 
   # Messaging & Validation
-  def report_missing_peer!(unpaired_entries, logger)
-    unless unpaired_entries.empty?
-      msg  = "The following rows are missing 'destination-id':\n\n"
-      msg += unpaired_entries.map {|entry| str_missing_peer(entry)}.join("\n")
-      logger.error(msg)
-      exit(1)
-    end
+  def report_missing_peer!(unpaired_entries)
+    return if unpaired_entries.empty?
+
+    msg  = "The following rows are missing 'destination-id':\n\n"
+    msg += unpaired_entries.map {|entry| str_missing_peer(entry)}.join("\n")
+    log(:error) { msg }
+    exit(1)
   end
 
   def str_missing_peer(entry)
@@ -247,22 +260,25 @@ class Eco::API::UseCases::Default::People::TransferAccountCase < Eco::API::Commo
     "#{str_row}id: '#{person.id || person.external_id}' email:#{person.email} -> Entry #{entry.to_s(:identify)}"
   end
 
-  def expect_destination_id!(entries, logger)
-    unless entries.length > 0
-      logger.error("Your csv is empty")
-      exit(1)
-    end
-    unless entry_peer_id?(entries.first)
-      logger.error("You haven't defined a column 'destination-id' to whom the account should be transferred")
+  def expect_destination_id!(entries)
+    unless entries.any?
+      log(:error) { "Your csv is empty" }
       exit(1)
     end
+
+    return if entry_peer_id?(entries.first)
+
+    log(:error) {
+      "You haven't defined a column 'destination-id' to whom the account should be transferred"
+    }
+    exit(1)
   end
 
-  def report_missing_account(str, logger)
-    logger.error("The following source people do not have account:\n#{str}")
+  def report_missing_account(str)
+    log(:error) { "The following source people do not have account:\n#{str}" }
   end
 
-  def report_repeated(str, logger, msg = "The following entries are repeated")
-    logger.error("#{msg}\n#{str}")
+  def report_repeated(str, msg = "The following entries are repeated")
+    log(:error) { "#{msg}\n#{str}" }
   end
 end

data/lib/eco/api/usecases/default_cases/hris_case.rb

@@ -52,7 +52,7 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
     msg << " (as it will remove the account of all the people of other schemas"
     msg << " if they are not in the input file)."
     msg << "\n For example: -schema-id '#{active_schema.name.downcase}'"
-    logger.error(msg)
+    log(:error) { msg }
     raise msg
   end
 end

data/lib/eco/api/usecases/default_cases/to_csv_case.rb

@@ -4,12 +4,12 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
 
   attr_reader :people
 
-  def main(people, session, options, usecase)
+  def main(people, _session, options, _usecase)
     options[:end_get] = false
     @people = people
 
     unless people && !people.empty?
-      logger.warn("No source people to create the file... aborting!")
+      log(:warn) { "No source people to create the file... aborting!" }
       return false
     end
 
@@ -40,7 +40,7 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
   def to_row(person)
     entry = to_entry_type(person)
     entry.values_at(*keys(entry)).tap do |row|
-      row << schemas.to_name(person.details&.schema_id) || "No Schema"
+      row << (schemas.to_name(person.details&.schema_id) || "No Schema")
     end
   end
 
@@ -53,11 +53,11 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
   end
 
   def keys(entry)
-    entry.keys - ["freemium", "send_invites"]
+    entry.keys - %w[freemium send_invites]
   end
 
   def nice_header_names?
-     options.dig(:nice_header) || options.dig(:export, :options, :nice_header)
+    options[:nice_header] || options.dig(:export, :options, :nice_header)
   end
 
   def nice_header_names(header, schema: nil)
@@ -65,7 +65,7 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
     name_maps = schema.fields_by_alt_id.each_with_object({}) do |(alt_id, fld), mappings|
       mappings[alt_id] = fld.name
     end.merge(nice_header_maps)
-    header.map {|name| name_maps[name] ? name_maps[name] : name}
+    header.map {|name| name_maps[name] || name}
   end
 
   def to_entry_type(person)
@@ -89,7 +89,7 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
 
   def by_schema
     people.group_by do |person|
-      if details = person.details
+      if (details = person.details)
         details.schema_id
       end
     end.transform_values do |persons|

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

@@ -43,7 +43,7 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
       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 }
+        log(:info) { msg }
 
         response = nil
         unless simulate? && !options.dig(:requests, :backup)

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

@@ -2,87 +2,95 @@ 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') }
+      class << self
+        def included(base)
+          super(base)
+          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
+        end
       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
+      module InstanceMethods
+        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)
+          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
-      end
 
-      private
+        private
 
-      # Work with adapted diff builders.
-      def nodes_diff_class
-        Eco::API::UseCases::GraphQL::Helpers::Location::Command::Diffs
-      end
+        # 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?
+        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
-      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
+        # 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 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
+        def print_diff_details?
+          false
+        end
       end
     end
   end

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

@@ -43,7 +43,13 @@ module Eco::API::UseCases::GraphQL::Samples
       include Eco::API::UseCases::GraphQL::Samples::Location::Service::TreeToList
 
       require_relative 'tree_diff/convertible'
-      include Convertible
+
+      class << self
+        def included(base)
+          super(base)
+          base.send :include, Convertible
+        end
+      end
 
       def process
         compare

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

@@ -19,6 +19,7 @@ module Eco::API::UseCases::GraphQL::Samples::Location::Service
 
       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|