eco-helpers 2.6.0 → 2.6.2

data/lib/eco/api/usecases/ooze_samples/register_migration_case.rb

@@ -66,8 +66,8 @@ class Eco::API::UseCases::OozeSamples::RegisterMigrationCase < Eco::API::UseCase
 
   def process_ooze
     with_target_stage(self.class::SOURCE_STAGE) do |source|
-      drafting_entry(self.class::TEMPLATE_ID) do |draft|
-        draft_reference = object_reference(source)
+      draft_reference = object_reference(source)
+      creating_new_page(draft_reference, template_id: elf.class::TEMPLATE_ID) do |draft|
         draft.base_tags << ["IMPORTED", "MIGRATED"]
 
         pairing_tracking = copy_pairings(source, draft)
@@ -89,13 +89,6 @@ class Eco::API::UseCases::OozeSamples::RegisterMigrationCase < Eco::API::UseCase
         if msg = pairing_tracking.report_dst_unpaired(only_required: false, exclude_ximport: !self.class::REPORT_DST_XIMPORT)
           logger.warn(msg)
         end
-
-        if page_id = create_entry(draft, reference: draft_reference)
-          csv << [source.id, page_id]
-          logger.info("Page '#{page_id}' created successfully.")
-        elsif options.dig(:dry_run)
-          logger.info("Simulated launch for #{draft_reference}")
-        end
       end
     end
   end
@@ -153,23 +146,6 @@ class Eco::API::UseCases::OozeSamples::RegisterMigrationCase < Eco::API::UseCase
     "#{sym}_callback".to_sym
   end
 
-  def create_entry(draft, reference:, from: self.class::TEMPLATE_ID)
-    with_rescue(reference) do
-      if !options[:dry_run]
-        create_ooze(draft, template_id: from).page_id
-      else
-        logger.info("Creation sample follows...")
-        dry_run_feedback(draft)
-        false
-      end
-    end
-  end
-
-  def drafting_entry(template_id = selfTEMPLATE_ID)
-    draft = apiv2.pages.get_new(template_id)
-    yield(draft)
-  end
-
   def with_target_stage(name)
     if stg = target_stage(name)
       yield(stg)

data/lib/eco/api/usecases/ooze_samples/register_update_case.rb

@@ -4,6 +4,8 @@
 #   - You need to define the `process_ooze` method
 # This case expects `options[:source][:register_id]`
 class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::OozeSamples::OozeBaseCase
+  include Eco::API::UseCases::OozeSamples::Helpers::Creatable
+
   class << self
     # @return [Integer] the number of pages to be processed in each batch
     def batch_size(size = nil)
@@ -18,31 +20,25 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
 
   attr_reader :retrieved_oozes, :non_retrieved_oozes
   attr_reader :total_search_oozes, :dupped_search_oozes
-  attr_reader :ooze_result_ids, :updated_oozes, :failed_update_oozes, :created_oozes
+  attr_reader :ooze_result_ids
+  attr_reader :updated_oozes, :failed_update_oozes, :attempted_ooze_updates
+  attr_reader :created_oozes, :ooze_create_attempts
 
-  def main(session, options, usecase, &block)
-    @retrieved_oozes = 0
-    @non_retrieved_oozes = 0
-    @dupped_search_oozes = 0
-    @ooze_result_ids     = {}
-    @updated_oozes       = 0
-    @failed_update_oozes = 0
-    @created_oozes       = 0
+  def main(session, options, usecase, mode: :legacy, &block)
+    init_kpis
 
     super(session, options, usecase) do
-      with_each_entry do |ooze|
-        process_ooze(&block)
+      if mode == :legacy
+        with_each_entry do |ooze|
+          process_ooze(&block)
+        end
+      elsif mode == :delegate
+        raise "You need to pass a block when running main in `:delegate` mode" unless block_given?
+        yield
       end
     end
-    msg  = "Run end:\n"
-    msg += "  • Search results: #{total_search_oozes}\n"
-    msg += "  • Duplicated search results #{dupped_search_oozes}\n"
-    msg += "  • Retrieved a total of #{retrieved_oozes}\n"
-    msg += "  • Could not get #{non_retrieved_oozes} oozes.\n"
-    msg += "  • Updated #{updated_oozes} oozes.\n"
-    msg += "    - Failed update on #{failed_update_oozes} oozes.\n"
-    msg += "  • Created #{created_oozes} oozes.\n"
-    logger.info(msg)
+
+    log_kpis
   end
 
   def process_ooze(ooze = target)
@@ -51,29 +47,6 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
 
   private
 
-  def with_rescue(reference)
-    begin
-      yield
-    rescue StandardError => e
-      logger.error([reference, e.message].join(' => \n'))
-      lines = []
-      lines << '\nThere was an error. Choose one option:\n'
-      lines << '  (C)      - Continue/resume. Just ignore this one.'
-      lines << '  (A)      - Abort. Just break this run.'
-
-      session.prompt_user('Type one option (C/a):', explanation: lines.join('\n'), default: 'C') do |res|
-        res = res.upcase
-        case
-        when res.start_with?("A")
-          raise
-        else res.start_with?("C")
-          logger.warn "Script resumed after error..."
-          nil
-        end
-      end
-    end
-  end
-
   def before_loading_new_target(ooze_id)
     if pending = queue_shift(ooze_id)
       update_ooze(pending).tap do |result|
@@ -95,6 +68,7 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
     end
   end
 
+  # Main looper (invoked from `main`)
   def with_each_entry
     batched_search_results do |page_results|
       page_results.each do |page_result|
@@ -172,12 +146,26 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
     yield(results) unless results.empty?
   end
 
+  # Launches the actual request to create the entry
   def create_ooze(draft, template_id:)
-    apiv2.pages.create(draft, from: template_id).tap do |result|
-      @created_oozes += 1
+    @ooze_create_attempts += 1
+
+    if dry_run?
+      dry_run_feedback(ooze)
+      false
+    else
+      apiv2.pages.create(draft, from: template_id).tap do |result|
+        @created_oozes += 1
+      end
     end
   end
 
+  # Capture the attempts count
+  def update_ooze(*args, **kargs, &block)
+    @attempted_ooze_updates += 1 if dirty?(ooze)
+    super
+  end
+
   def update_oozes(batched_oozes = batch_queue)
     batched_oozes.each do |ooze|
       update_ooze(ooze).tap do |result|
@@ -215,10 +203,39 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
     end
   end
 
+  def init_kpis
+    @retrieved_oozes        = 0
+    @non_retrieved_oozes    = 0
+    @dupped_search_oozes    = 0
+    @ooze_result_ids        = {}
+    @updated_oozes          = 0
+    @failed_update_oozes    = 0
+    @attempted_ooze_updates = 0
+    @created_oozes          = 0
+    @ooze_create_attempts   = 0
+  end
+
+  def log_kpis
+    log(:info) { kpis_message }
+  end
+
+  def kpis_message
+    msg  = []
+    msg << "Run end:"
+    msg << "  • Search results: #{total_search_oozes}"
+    msg << "  • Duplicated search results #{dupped_search_oozes}"
+    msg << "  • Retrieved a total of #{retrieved_oozes}"
+    msg << "  • Could not get #{non_retrieved_oozes} oozes."
+    msg << "  • Updated #{updated_oozes} oozes (attempted: #{attempted_ooze_updates})."
+    msg << "    - Failed update on #{failed_update_oozes} oozes."
+    msg << "  • Created #{created_oozes} oozes (out of: #{ooze_create_attempts})."
+    msg.join("\n")
+  end
+
   def search_options
     @search_options ||= {}.tap do |opts|
-      opts.merge!(sort: "created_at")
-      opts.merge!(dir:  "asc")
+      opts.merge!(sort:   'created_at')
+      opts.merge!(dir:    'asc')
       opts.merge!(query:   conf_search) if conf_search
       opts.merge!(filters: conf_filters)
     end

data/lib/eco/api/usecases/ooze_samples/target_oozes_update_case.rb

@@ -19,7 +19,11 @@ class Eco::API::UseCases::OozeSamples::TargetOozesUpdateCase < Eco::API::UseCase
           end
         end
         if ooz = ooze(id)
+          @retrieved_oozes += 1
           yield(ooz)
+        else
+          @non_retrieved_oozes += 1
+          logger.warn "Could not get page #{id}"
         end
       end
       update_oozes
@@ -42,8 +46,12 @@ class Eco::API::UseCases::OozeSamples::TargetOozesUpdateCase < Eco::API::UseCase
 
   def target_ids_preview
     dups = target_ids.select {|id| target_ids.count(id) > 1}
+    @total_search_oozes  = target_ids.count
+    @dupped_search_oozes = dups.count
+
     dups_str = dups.count > 0 ? "There are #{dups.count} duplicated ids" : "No duplicates detected"
     msg = "Total target entries: #{target_ids.count} (#{dups_str})"
+
     session.prompt_user("Do you want to proceed (y/N):", explanation: msg, default: "N", timeout: 10) do |res|
       unless res.upcase.start_with?("Y")
         puts "..."

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

@@ -40,6 +40,7 @@ module Eco
         # @option kargs [Eco::API::Organization::People] :people object.
         # @option kargs [Eco::API:Session] :session
         # @option kargs [Hash] :options hash with symbol keys (i.e. behaviour modifiers, cli trackers, filters, etc.)
+        # @return [Eco::API::UseCases::UseCaseIO] an io with the result in output
         def launch(io: nil, **kargs)
           params = io&.params(keyed: true, all: true) || {}
           kargs  = params.merge(kargs).merge(usecase: self)
@@ -88,12 +89,21 @@ module Eco
           callback_self.instance_eval do
             @session = sess
             @options = opts
-            @people  = peo if peo
-            @input   = ent if ent
+            if peo
+              @people = peo
+              self.singleton_class.attr_reader(:people) unless respond_to?(:people)
+            end
+
+            if ent # entries/input
+              @input = ent
+              self.singleton_class.attr_reader(:input) unless respond_to?(:input)
+            end
 
             # `self` is the use case itself (when used the Loader)
             next unless self.is_a?(Eco::API::Common::Loaders::CaseBase)
+
             @usecase = use_case_self
+            self.singleton_class.attr_reader(:usecase) unless respond_to?(:usecase)
           end
           true
         end

data/lib/eco/assets.rb

@@ -31,12 +31,12 @@ module Eco
       @configs ||= {}
     end
 
-    def cli
+    def cli(&block)
       unless @cli_init
         @cli_init = true
         require_relative('cli_default')
       end
-      @cli
+      @cli.tap { yield(@cli) if block_given? }
     end
   end
 end

data/lib/eco/cli_default/workflow.rb

@@ -1,189 +1,171 @@
-ASSETS.cli.config do |config|
+ASSETS.cli do |cli|
   ASSETS.config.workflow do |wf|
-    io                = nil
-    rescued           = false
-    cases_with_input  = nil
-    cases_with_output = nil
 
+    rescued = false
     # default rescue
-    wf.rescue do |exception, io|
-      begin
-        next io if rescued
-        rescued = true
-
-        io.session.logger.debug(exception.patch_full_message)
-        wf.run(:close, io: io)
-      rescue Exception => e
-        puts "Some problem in workflow.rescue: #{e}"
-      end
-      io
+    wf.rescue do |err, io|
+      next io if rescued
+      rescued = true
+      log(:debug) { err.patch_full_message }
+      wf.run(:close, io: io)
+    rescue StandardError => e
+      puts "Some problem in workflow.rescue: #{e}"
     end
 
-    wf.on(:options) do |wf_options, io|
-      config.usecases.cli_apply(io: io)
-      io = io.new(options: config.options_set.process(io: io))
+    wf.on(:options) do |_wf_opt, io|
+      cli.config.usecases.cli_apply(io: io)
+      io.new(options: cli.config.options_set.process(io: io))
     end
 
     wf.for(:load) do |wf_load|
-      wf_load.for(:input) do |wf_input|
-        wf_input.on(:get) do |wf_input_get, io|
-          cases_with_input =  config.usecases.active(io: io).select do |usecase, data|
+      wf_load.for(:input) do |wf_in|
+        wf_in.on(:get) do |_wf_ig, io|
+          cases_with_input = cli.config.usecases.active(io: io).select do |usecase, data|
             io.class.input_required?(usecase.type)
           end
 
-          input_is_required = !cases_with_input.empty? || io.options.dig(:input, :entries_from)
-          missing_input     = !io.input || io.input.empty?
-          next io unless missing_input && input_is_required
+          input_is_required = !cases_with_input.empty? || options.dig(:input, :entries_from)
+          missing_input     = !input || input.empty?
+          next unless missing_input && input_is_required
 
-          if io.options.dig(:input, :entries_from)
-            io = io.new(input: config.input.get(io: io))
+          if options.dig(:input, :entries_from)
+            io.new(input: cli.config.input.get(io: io))
           else
             opt_case = cases_with_input.values.first.option
-            io = io.new(input: config.input.get(io: io, option: opt_case))
+            io.new(input: cli.config.input.get(io: io, option: opt_case))
           end
-          io
         end
 
-        wf_input.on(:filter) do |wf_input_filter, io|
-          next io unless io.input && !io.input.empty?
-          io = io.new(input:  config.input_filters.process(io: io))
+        wf_in.on(:filter) do |_wf_if, io|
+          next unless input && !input.empty?
+          io.new(input:  cli.config.input_filters.process(io: io))
         end
       end
 
-      wf_load.for(:people) do |wf_people|
-        wf_people.on(:get) do |wf_people_get, io|
-          cases_with_people = config.usecases.active(io: io).select do |usecase, data|
+      wf_load.for(:people) do |wf_peo|
+        wf_peo.on(:get) do |_wf_pg, io|
+          cases_with_people = cli.config.usecases.active(io: io).select do |usecase, data|
             io.class.people_required?(usecase.type)
           end
-          next io if cases_with_people.empty? && !io.options.dig(:people, :get)
-          io = io.new(people:  config.people(io: io))
+          next if cases_with_people.empty? && !options.dig(:people, :get)
+          io.new(people: cli.config.people(io: io))
         end
 
-        wf_people.on(:filter) do |wf_people_filter, io|
-          next io unless io.people && !io.people.empty?
-          io = io.new(people:  config.people_filters.process(io: io))
+        wf_peo.on(:filter) do |_wf_pf, io|
+          next unless people && !people.empty?
+          io.new(people: cli.config.people_filters.process(io: io))
         end
       end
     end
 
-    wf.before(:usecases) do |wf_cases, io|
+    wf.before(:usecases) do |_wf_ca, io|
       # save partial entries -> should be native to session.workflow
-      get_people     = io.options.dig(:people, :get)
+      get_people     = options.dig(:people, :get)
       partial_update = get_people && get_people.dig(:type) == :partial
-      if !io.options[:dry_run] && partial_update
-        partial_file = io.session.config.people.partial_cache
-        io.session.file_manager.save_json(io.people, partial_file, :timestamp)
+      if !options[:dry_run] && partial_update
+        partial_file = session.config.people.partial_cache
+        session.file_manager.save_json(io.people, partial_file, :timestamp)
       end
-      io
     end
 
-    wf.on(:usecases) do |wf_cases, io|
-      unless config.usecases.process(io: io)
-        msg = "No update operation specified... quitting"
-        io.session.logger.info(msg)
-        exit(0)
+    wf.on(:usecases) do |_wf_ca, io|
+      unless cli.config.usecases.process(io: io)
+        log(:info) { "No update operation specified... quitting" }
+        exit 0
       end
-      io
     end
 
-    wf.before(:launch_jobs) do |wf_jobs, io|
+    wf.before(:launch_jobs) do
       SCR.stop_on_unknown!
-      io
     end
 
-    wf.on(:launch_jobs) do |wf_jobs, io|
-      io.session.jobs_launch(simulate: io.options[:dry_run])
-      io
+    wf.on(:launch_jobs) do
+      session.jobs_launch(simulate: options[:dry_run])
     end
 
     wf.before(:post_launch) do |wf_post, io|
-      if io.session.post_launch.empty?
+      next wf_post.skip! if session.post_launch.empty?
+
+      run_it  = !options[:dry_run] || options.dig(:post_launch, :run)
+      unless run_it
         wf_post.skip!
-      else
-        get_people     = io.options.dig(:people, :get)
-        partial_update = get_people && get_people.dig(:type) == :partial
-        run_it         = !io.options[:dry_run] || io.options.dig(:post_launch, :run)
-        refresh_data   = !io.options[:dry_run] && partial_update
-        if run_it
-          if refresh_data
-            # get target people afresh
-            people = io.session.micro.people_refresh(people: io.people, include_created: true)
-            io     = io.base.new(people: people)
-          else
-            msg = "Although there are post_launch cases, data will not be refreshed before their run"
-            if io.options[:dry_run]
-              msg += ", because we are in dry-run (simulate)."
-            elsif !partial_update
-              msg += ", because it is not a partial update (-get-partial option not present)."
-            end
-            io.session.logger.info(msg)
-          end
-        else
-          wf_post.skip!
-          msg = "Although there are post_launch cases, they will NOT be RUN"
+        log(:info) {
+          msg  = "Although there are post_launch cases, they will NOT be RUN"
+          msg += ", because we are in dry-run (simulate)." if options[:dry_run]
+          msg
+        }
+        next
+      end
+
+      get_people     = options.dig(:people, :get)
+      partial_update = get_people && get_people.dig(:type) == :partial
+      refresh_data   = !options[:dry_run] && partial_update
+
+      unless refresh_data
+        log(:info) {
+          msg = "Although there are post_launch cases, data will not be refreshed before their run"
           if io.options[:dry_run]
-            msg+= ", because we are in dry-run (simulate)."
+            msg += ", because we are in dry-run (simulate)."
+          elsif !partial_update
+            msg += ", because it is not a partial update (-get-partial option not present)."
           end
-          io.session.logger.info(msg)
-        end
+          msg
+        }
+        next
       end
-      io
+
+      # get target people afresh
+      peo_aux = session.micro.people_refresh(people: people, include_created: true)
+      io.base.new(people: peo_aux)
     end
 
     wf.for(:post_launch) do |wf_post|
-
-      wf_post.on(:usecases) do |wf_postcases, io|
-        io.session.post_launch.each do |use|
-          begin
-            io = use.launch(io: io).base
-          rescue Eco::API::UseCases::BaseIO::MissingParameter => e
-            if e.required == :people
-              io.session.logger.debug("Skipping use case '#{use.name}' -- no base people detected for the current run")
-            else
-              raise
-            end
-          end
+      wf_post.on(:usecases) do |_wf_pu, io|
+        session.post_launch.each do |use|
+          use.launch(io: io).base
+        rescue Eco::API::UseCases::BaseIO::MissingParameter => e
+          raise unless e.required == :people
+          log(:debug) {
+            "Skipping use case '#{use.name}' -- no base people detected for the current run"
+          }
         end
-        io
       end
 
-      wf_post.on(:launch_jobs) do |wf_postlaunch, io|
-        io.session.jobs_launch(simulate: io.options[:dry_run])
-        io
+      wf_post.on(:launch_jobs) do |_wf_pl, io|
+        session.jobs_launch(simulate: options[:dry_run])
       end
     end
 
-    wf.on(:report) do |wf_report, io|
-      io.tap do |_io|
-        if file = io.options.dig(:report, :people, :csv)
-          io.options.deep_merge!(export: {
-            options: {internal_names: true, nice_header: true, split_schemas: true},
-            file: {name: file, format: :csv}
-          })
-          aux_io = io.new(people: io.people.updated_or_created)
-          io.session.process_case("to-csv", io: aux_io, type: :export)
-        end
+    wf.on(:report) do |_wf_rep, io|
+      if file = options.dig(:report, :people, :csv)
+        options.deep_merge!(export: {
+          options: {internal_names: true, nice_header: true, split_schemas: true},
+          file:    {name: file, format: :csv}
+        })
+        aux_io = io.new(people: people.updated_or_created)
+        session.process_case("to-csv", io: aux_io, type: :export)
       end
     end
 
-    wf.on(:end) do |wf_end, io|
-      get_people     = io.options.dig(:people, :get)
+    wf.on(:end) do |_wf_end, io|
+      get_people     = options.dig(:people, :get)
       partial_update = get_people && get_people.dig(:type) == :partial
 
-      unless !io.options[:end_get] || io.options[:dry_run] || partial_update
-        people_update_cases = config.usecases.active(io: io).any? do |usecase, data|
-          [:transform, :sync].any? {|type| usecase.type == type}
+      unless !options[:end_get] || options[:dry_run] || partial_update
+        people_update_cases = cli.config.usecases.active(io: io).any? do |usecase, data|
+          [:transform, :sync].any? { |type| usecase.type == type }
         end
 
         if !people_update_cases
           # Prevent getting people when there were no use cases that used them
-          io.session.logger.info("Won't be recaching people, as there haven't been any targetted updates")
-        elsif !io.people
-          people = io.session.micro.people_cache
-          io     = io.new(people: people)
+          log(:info) {
+            "Won't be recaching people, as there haven't been any targetted updates"
+          }
+        elsif !people
+          people = session.micro.people_cache
+          io.new(people: people)
         end
       end
-      io
     end
   end
 end

data/lib/eco/data/locations/node_base/tag_validations.rb

@@ -1,33 +1,43 @@
 module Eco::Data::Locations::NodeBase
   module TagValidations
+    include Eco::Language::AuxiliarLogger
+
     ALLOWED_CHARACTERS = "A-Za-z0-9 &_'\/.-"
     VALID_TAG_REGEX    = /^[#{ALLOWED_CHARACTERS}]+$/
     INVALID_TAG_REGEX  = /[^#{ALLOWED_CHARACTERS}]+/
     VALID_TAG_CHARS    = /[#{ALLOWED_CHARACTERS}]+/
     DOUBLE_BLANKS      = /\s\s+/
 
-    def clean_id(str, notify: true)
+    def clean_id(str, notify: true, ref: '')
       blanks_x2 = has_double_blanks?(str)
       partial   = replace_not_allowed(str)
       remove_double_blanks(partial).tap do |result|
         next unless notify
-        next if invalid_warned?
+        next if invalid_warned?(str)
         if partial != str
           invalid_chars = identify_invalid_characters(str)
-          puts "• (Row: #{self.row_num}) Invalid characters _#{invalid_chars}_ (removed): '#{str}' (converted to '#{result}')"
+          log(:warn) {
+            "• #{ref}Invalid characters _#{invalid_chars}_ <<_removed_: '#{str}' :_converted_>> '#{result}'"
+          }
         elsif blanks_x2
-          puts "• (Row: #{self.row_num}) Double blanks (removed): '#{str}' (converted to '#{result}')"
+          log(:warn) {
+            "• #{ref}Double blanks removed: '#{str}' :_converted_>> '#{result}'"
+          }
         end
-        invalid_warned!
+        invalid_warned!(str)
       end
     end
 
-    def invalid_warned?
-      @invalid_warned ||= false
+    def invalid_warned?(str)
+      invalid_warned[str] ||= false
+    end
+
+    def invalid_warned!(str)
+      invalid_warned[str] = true
     end
 
-    def invalid_warned!
-      @invalid_warned = true
+    def invalid_warned
+      @invalid_warned ||= {}
     end
 
     def has_double_blanks?(str)