eco-helpers 2.0.41 → 2.0.45

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f9f409fadb3cd263964b4254d35ea3b32cd97ff21eaaef4cd96bb0bafb61b83
-  data.tar.gz: 411187eb287a25f73e75d08fd7ccc6984e3ece935786fd161f3998cfb53a0670
+  metadata.gz: f85bd156250d1f44ca911d98007005cbbb2281ff4a40a2fc07a80680fd42a408
+  data.tar.gz: 4ccda90fbf7d1bbfc814d18cd033110b7af2ae366687af1fa2db10370788c52d
 SHA512:
-  metadata.gz: 7ef199c58c422283f767f90319e6768265a2d38b33e4b5be73ad6b3c77923949056e5263e2130b650307d08deb78d4e0e1da078fcfed70936cb294aa8bb1326f
-  data.tar.gz: aee328dc5617c180ca6efc8e7399a205755b4abb6ff0b8546f19462e2d3a2f095bcc7be6d3b43eb2303b99710fd3bcc881c4421560a37d91b4b0a743bc6e3db6
+  metadata.gz: f4b7add6e04fb8b4dfa0c56371bc3f85e791659754e937f60586b88dec06186723f9286c87482144bd9b012298dbc03251388c49f1245008026a186cd6d16a88
+  data.tar.gz: 7a0bfda7154a8c0e7bb7e18100a96cd2a45f26a6d45309725e7d796dd9d0ad48cefb35be551c031706757d1241fab7505d74f401cf6a04764547bbe8c582e076

data/CHANGELOG.md

@@ -1,10 +1,74 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [2.0.41] - 2021-09-xx
+## [2.0.45] - 2021-11-xx
 
 ### Added
+  - `Eco::API::UseCases::OozeSamples::RegisterExportCase`
+  
 ### Changed
+  - Upgrade `ecoportal-api` dependency
+  - Upgrade `ecoportal-api-v2` dependency
+
+### Fixed
+
+## [2.0.44] - 2021-11-25
+
+### Changed
+  - Upgrade `ecoportal-api` dependency
+
+## [2.0.43] - 2021-11-25
+
+### Added
+  - `Eco::API::Session::Batch::Job` added better **logging**
+
+### Changed
+  - `Eco::API::Session::Batch` added **resilience** and **recovery** to connection errors
+  - `Eco::API::Policies::DefaultPolicies::UserAccess` changed logging from `warn` to `info`.
+
+## [2.0.42] - 2021-10-30
+
+### Added
+  - `eco/api/organization/presets_values.json` added abilities:
+    - `visitor_management`
+    - `broadcast_notifications`
+    - `cross_register_reporting`
+    - Due to dev pipeline, the `ecoportal-api` version `0.8.4` hasn't been released
+      - This part of the current `eco-helpers` version depends on that gem version (to be upgraded later)
+  - Changed the `workflow` in
+    - `before(:post_launch, :usecases)` => post launch cases are not prevented for **partial** updates
+      - rectified message
+    - `run(:post_launch, :usecases)` => missing **people** error will log in `debug` level
+      - it won't break the script anymore (just prevent a post use case to be run)
+  - New use case `Eco::API::UseCases::DefaultCases::EntriesToCsv`: to export input entries as `csv`
+    - invokable via `-entries-to-csv`
+  - More errors:
+    - `Eco::API::Error::ExternalIdTaken`
+    - `Eco::API::Error::InternalServerError`
+  - **Added** option `processed-people-to-csv file.csv` to export a `csv` with the results of processing people
+    - This option allows to preview the final data when launching a `dry-run` (`-simulate`)
+  - **Added** ooze case sample `Eco::API::UseCases::OozeSamples::TargetOozesUpdateCase`
+    - Allows to retrieve the target entries based on a `csv`
+
+### Changed
+  - Moved methods of `#person_ref`, `#get_attr` and `#get_row` as **class methods** of `Eco::API::Session::Batch::Feedback`
+    - `Eco::API::Session::Errors` methods above to use them via `Feedback` class
+  - `Eco::API::Session::Errors::ErrorCache`: **added** new property `response`
+    - `#by_type` added parameter `only_entries` to specify the output type
+    - `#errors`  capture the `response` in the generated `ErrorCache` object
+
+### Fixed
+  - `Eco::API::Session::Config::Workflow#run` to validate **callback** output class
+    - It should be a `Eco::API::UseCases::BaseIO`
+  - Prevent **uncreated people** to be present in queues or people refresh (if the server side worked perfectly, this contingency shouldn't be necessary):
+    - `Eco::API::Session::Batch::Job#processed_queue`
+      - Sanity-check to exclude people that are **new** and do not have `id` when the current `Job` is **not** of type `:create` (meaning that it was supposed to be created but failed and it probably doesn't exist on server-side)
+      - This prevents errors when trying to update/delete a person that most probably does not exist on the server.
+    - `Eco::API::MicroCases#people_refresh`
+      - Remove from people run-time object those that are **new** that are `dirty` (with pending changes)
+
+## [2.0.41] - 2021-10-06
+
 ### Fixed
   - `Eco::API::Session::Batch::Job` `backup_update`
     - Saved `requests` filename was overlapping due to only batch job type being used

data/eco-helpers.gemspec

@@ -30,8 +30,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "yard",      ">= 0.9.26", "< 0.10"
   spec.add_development_dependency "redcarpet", ">= 3.5.1",  "< 3.6"
 
-  spec.add_dependency 'ecoportal-api', '>= 0.8.3', '< 0.9'
-  spec.add_dependency 'ecoportal-api-v2', '>= 0.8.19', '< 0.9'
+  spec.add_dependency 'ecoportal-api', '>= 0.8.4', '< 0.9'
+  spec.add_dependency 'ecoportal-api-v2', '>= 0.8.21', '< 0.9'
   spec.add_dependency 'aws-sdk-s3',    '>= 1.83.0', '< 2'
   spec.add_dependency 'aws-sdk-ses',   '>= 1.36.0', '< 2'
   spec.add_dependency 'dotenv',        '>= 2.7.6', '< 2.8'

data/lib/eco/api/common/people/entry_factory.rb

@@ -166,7 +166,7 @@ module Eco
             run = true
             if Eco::API::Common::Session::FileManager.file_exists?(file)
               prompt_user("Do you want to overwrite it? (Y/n):", explanation: "The file '#{file}' already exists.", default: "Y") do |response|
-                run = (response == "") || reponse.upcase.start_with?("Y")
+                run = (response == "") || response.upcase.start_with?("Y")
               end
             end
 

data/lib/eco/api/common/session/sftp.rb

@@ -1,5 +1,4 @@
 require "net/sftp"
-
 module Eco
   module API
     module Common

data/lib/eco/api/error.rb

@@ -19,10 +19,18 @@ module Eco
         @match     = /.*/
       end
 
+      class InternalServerError < Eco::API::Error
+        @str_err  = "Internal Server Error"
+        @match   = /#{@str_err}/
+      end
       class UnknownPersonId < Eco::API::Error
         @str_err = "Unknown person id"
         @match   = /Cannot find person with id (.*)/
       end
+      class ExternalIdTaken < Eco::API::Error
+        @str_err  = "external ID already taken"
+        @match   = /#{@str_err}/
+      end
       class EmailMissing < Eco::API::Error
         @str_err = "missing email for account creation"
         @match   = /#{@str_err}/

data/lib/eco/api/microcases/people_refresh.rb

@@ -2,15 +2,22 @@ module Eco
   module API
     class MicroCases
       # Helper to obtain all the elements of `people` anew from the _People Manager_.
-      # @note this helper is normally used to run consecutive usecases, where data needs refresh.
+      # @note
+      #   1. This helper is normally used to run consecutive usecases, where data needs refresh.
+      #   2. It only includes new people if they are not dirty (they do not have pending updates)
+      #     - This contingency wouldn't be necessary if the server worked perfectly.
       # @param people [Eco::API::Organization::People] the people that needs refresh.
       # @param include_created [Boolean] include people created during this session? (will check `:create` batch jobs).
       # @return [Eco::API::Organization::People] the `People` object with the data.
       def people_refresh(people:, include_created: true)
+        people = people.newFrom people.select do |person|
+          !person.new? || !person.dirty?
+        end
         ini = people.length
         if include_created
           session.job_groups.find_jobs(type: :create).map do |job|
-            people = people.merge(job.people)
+            to_add = job.people.select {|person| !person.dirty?}
+            people = people.merge(to_add)
           end
         end
 

data/lib/eco/api/organization/presets_values.json

@@ -12,5 +12,8 @@
   "person_core_edit": [null, "edit"],
   "person_details": [null, "view", "edit_public", "view_private", "edit_private"],
   "person_account": [null, "view", "create", "edit"],
-  "person_abilities": [null, "view", "edit"]
+  "person_abilities": [null, "view", "edit"],
+  "visitor_management": [null, "view", "edit", "administrate"],
+  "broadcast_notifications": [null, "view", "administrate"],
+  "cross_register_reporting": [null, "view"]
 }

data/lib/eco/api/policies/default_policies/99_user_access_policy.rb

@@ -22,7 +22,7 @@ class Eco::API::Policies::DefaultPolicies::UserAccess < Eco::API::Common::Loader
   def warn_account_removal!
     if account_removed_count > 0
       msg = "(DefaultPolicy on job '#{job.name}') Removed account to #{account_removed_count} people"
-      session.logger.warn(msg)
+      session.logger.info(msg)
     end
   end
 

data/lib/eco/api/session/batch/errors.rb

@@ -8,7 +8,7 @@ module Eco
           # @attr_reader status [Eco::API::Session::Batch::Status] `batch status` this `Errors` object is associated to.
           attr_reader :status
 
-          ErrorCache = Struct.new(:type, :err, :entry)
+          ErrorCache = Struct.new(:type, :err, :entry, :response)
 
           # @param status [Eco::API::Session::Batch::Status] `batch status` this `Errors` object is associated to.
           def initialize(status:)
@@ -46,31 +46,52 @@ module Eco
 
           # @!group Pure errors helper methods
 
+          # @return [Integer] the number of `entries` that got error.
+          def count
+            entries.length
+          end
+
           # Was there any _Sever_ (reply) **error** as a result of this batch?
           # @return [Boolean] `true` if any of the queried _entries_ got an unsuccessful `Ecoportal::API::Common::BatchResponse`
           def any?
             queue.any? {|query| !status[query].success?}
           end
 
-          # @return [Integer] the number of `entries` that got error.
-          def count
-            entries.length
+          # Groups `entries` with error `type`
+          # @return [Hash] where each `key` is a `type` **error** and each value is  an `Array` of:
+          #   1. `entries` that got that error, if `only_entries` is `true`
+          #   2. `ErrorCache` objects, if `only_entries` is `false`
+          def by_type(only_entries: true)
+            errors.group_by do |e|
+              e.type
+            end.transform_values do |arr|
+              if only_entries
+                arr.map {|e| e.entry}
+              else
+                arr
+              end
+            end
           end
+          # @!endgroup
 
-          # For all the `entries` with errors generates a `Hash` object
-          # @return [Array<Hash>] where each `Hash` has
-          #   1. `:type` -> the error type
-          #   2. `:err` -> the error `class` of that `:type`
-          #   3. `:entry` -> the entry that generated the error
+          # For all the `entries` with errors generates an `Array` of `ErrorCache` objects
+          # @return [Array<Eco::API::Session::Batch::Errors::ErrorCache>] where each `object` has
+          #   1. `type`  -> the error type `Class`
+          #   2. `err`   -> an instance object of that error `class` type
+          #   3. `entry` -> the entry that generated the error
+          #   4. `response` -> the original response from the server that carries the error
           def errors
             entries.each_with_object([]) do |entry, arr|
-              if body = status[entry].body
-                if errs = body["errors"]
+              response = status[entry]
+              if body = response.body
+                if errs = body["errors"] || body["error"]
+                  errs = [errs].flatten(1).compact
                   errs.each do |msg|
                     arr.push(ErrorCache.new(
                       klass = Eco::API::Error.get_type(msg),
                       klass.new(err_msg: msg, entry: entry, session: session),
-                      entry
+                      entry,
+                      response
                     ))
                   end
                 end
@@ -78,18 +99,6 @@ module Eco
             end
           end
 
-          # Groups `entries` with error `type`
-          # @return [Hash] where each `key` is a `type` **error** and each value is
-          #   an `Array` of `entries` that got that error
-          def by_type
-            errors.group_by do |e|
-              e.type
-            end.transform_values do |arr|
-              arr.map {|e| e.entry}
-            end
-          end
-          # @!endgroup
-
           # @!group Messaging methods
 
           def message
@@ -112,8 +121,7 @@ module Eco
           # @!endgroup
 
           def person_ref(entry)
-            row_str = (row = get_row(entry)) ? "(row: #{row}) " : nil
-            "#{row_str}(id: '#{get_attr(entry, :id)}') '#{get_attr(entry, :name)}' ('#{get_attr(entry, :external_id)}': '#{get_attr(entry, :email)}')"
+            Eco::API::Session::Batch::Feedback.person_ref(entry)
           end
 
           private
@@ -142,20 +150,11 @@ module Eco
           end
 
           def get_attr(entry, attr)
-            if entry.respond_to?(attr.to_sym)
-              entry.public_send(attr.to_sym)
-            elsif entry.is_a?(Hash)
-              entry["#{attr}"]
-            end
+            Eco::API::Session::Batch::Feedback.get_attr(entry, attr)
           end
 
           def get_row(value)
-            case value
-            when Eco::API::Common::People::PersonEntry
-              value.idx
-            when Ecoportal::API::V1::Person
-              get_row(value.entry)
-            end
+            Eco::API::Session::Batch::Feedback.get_row(value)
           end
 
           # Sorts the entries that got server error by error `type` and generates the error messages.

data/lib/eco/api/session/batch/feedback.rb

@@ -5,6 +5,30 @@ module Eco
         # @attr_reader job [Eco::API::Session::Batch::Job] `batch job` the feedback is associated with
         class Feedback
 
+          class << self
+            def person_ref(entry)
+              row_str = (row = get_row(entry)) ? "(row: #{row}) " : nil
+              "#{row_str}(id: '#{get_attr(entry, :id)}') '#{get_attr(entry, :name)}' ('#{get_attr(entry, :external_id)}': '#{get_attr(entry, :email)}')"
+            end
+
+            def get_attr(entry, attr)
+              if entry.respond_to?(attr.to_sym)
+                entry.public_send(attr.to_sym)
+              elsif entry.is_a?(Hash)
+                entry["#{attr}"]
+              end
+            end
+
+            def get_row(value)
+              case value
+              when Eco::API::Common::People::PersonEntry
+                value.idx
+              when Ecoportal::API::V1::Person
+                get_row(value.entry)
+              end
+            end            
+          end
+
           attr_reader :job
 
           # @param job [Eco::API::Session::Batch::Job] `batch job` the feedback is associated with

data/lib/eco/api/session/batch/job.rb

@@ -176,6 +176,7 @@ module Eco
               if pqueue.length > 0
                 req_backup = as_update(pqueue, add_feedback: false)
                 backup_update(req_backup)
+                logger.debug("Job ('#{name}':#{type}): going to launch batch against #{pqueue.count} entries")
                 session.batch.launch(pqueue, method: type).tap do |job_status|
                   @status     = job_status
                   status.root = self
@@ -235,9 +236,23 @@ module Eco
             end
           end
 
+          # Method to generate the base of people that will be present in the queue
+          # @note
+          #   - If the entry is a new person, we are not in a creation job and the person doesn't have `id`
+          #     it means that it failed to be created (it doesn't exist on server-side).
+          #     The entry won't be included.
+          #   - The contingency above wouldn't be necessary if the server worked perfectly.
           def processed_queue
-            @queue.each {|e| @callbacks[e].call(e) if @callbacks.key?(e) }
-            apply_policies(api_included(@queue)).select do |e|
+            pre_filtered = @queue.select do |entry|
+              if unexisting = entry.new? && !entry.id && type != :create
+                ref = Eco::API::Session::Batch::Feedback.person_ref(entry)
+                msg = "Job ('#{name}':#{type}): excluded unexisting entry (failed creation): #{ref}"
+                session.logger.warn(msg)
+              end
+              !unexisting
+            end
+            pre_filtered.each {|e| @callbacks[e].call(e) if @callbacks.key?(e) }
+            apply_policies(api_included(pre_filtered)).select do |e|
               !as_update(e).empty?
             end.select do |e|
               next true unless e.is_a?(Ecoportal::API::V1::Person)
@@ -320,7 +335,7 @@ module Eco
                 handlers.each do |handler|
                   if entries = err_types[handler.name]
                     handler_job = subjobs_add("#{self.name} => #{handler.name}", usecase: handler)
-                    logger.debug("Running error handler #{handler.name}")
+                    logger.debug("Running error handler #{handler.name} (against #{entries.count} entries)")
                     handler.launch(people: people(entries), session: session, options: options, job: handler_job)
                     logger.debug("Launching job of error handler: #{handler_job.name}")
                     handler_job.launch(simulate: simulate)

data/lib/eco/api/session/batch.rb

@@ -92,6 +92,7 @@ module Eco
           return people_api.get_all(params: params, silent: silent)
         end
 
+
         def batch_from(data, method:, params: {}, silent: false)
           fatal "Invalid batch method: #{method}." if !self.class.valid_method?(method)
           return nil if !data || !data.is_a?(Enumerable)
@@ -101,12 +102,23 @@ module Eco
           params   = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
           per_page = params[:per_page] || DEFAULT_BATCH_BLOCK
 
+          launch_batch(data,
+            method: method,
+            per_page: per_page,
+            people_api: people_api,
+            silent: silent
+          )
+        end
+
+        def launch_batch(data, method:, status: nil, job_mode: true, per_page: DEFAULT_BATCH_BLOCK, people_api: api&.people, silent: false)
           iteration  = 1; done = 0
           iterations = (data.length.to_f / per_page).ceil
 
-          Eco::API::Session::Batch::Status.new(enviro, queue: data, method: method).tap do |status|
+          status ||= Eco::API::Session::Batch::Status.new(enviro, queue: data, method: method)
+          status.tap do |status|
             start_time  = Time.now
             start_slice = Time.now; slice = []
+            pending_for_server_error = data.to_a[0..-1]
             data.each_slice(per_page) do |slice|
               msg  = "starting batch '#{method}' iteration #{iteration}/#{iterations},"
               msg += " with #{slice.length} entries of #{data.length} -- #{done} done"
@@ -115,11 +127,14 @@ module Eco
 
               start_slice = Time.now
               offer_retry_on(Ecoportal::API::Errors::TimeOut) do
-                people_api.batch do |batch|
+                people_api.batch(job_mode: false) do |batch|
                   slice.each do |person|
                     batch.public_send(method, person) do |response|
                       faltal("Request with no response") unless !!response
-                      status[person] = response
+                      unless server_error?(response)
+                        pending_for_server_error.delete(person)
+                        status[person] = response
+                      end
                     end
                   end
                 end # end batch
@@ -128,9 +143,31 @@ module Eco
               iteration  += 1
               done       += slice.length
             end # next slice
+
+            # temporary working around (due to back-end problems with batch/jobs)
+            unless pending_for_server_error.empty?
+              msg = "Going to re-try #{pending_for_server_error.count} due to server errors"
+              logger.info(msg) unless silent
+              launch_batch(pending_for_server_error,
+                status: status,
+                method: method,
+                job_mode: false,
+                per_page: per_page,
+                people_api: people_api,
+                silent: silent
+              )
+            end
           end
         end
 
+        def server_error?(response)
+          res_status   = response.status
+          server_error = !res_status || res_status.server_error?
+          other_error  = !server_error && (!res_status.code || res_status.code < 100)
+          no_body      = !server_error && !other_error  && !response.body
+          server_error || other_error || no_body
+        end
+
         def offer_retry_on(error_type, retries_left = 3, &block)
           begin
             block.call

data/lib/eco/api/session/config/workflow.rb

@@ -185,6 +185,7 @@ module Eco
           #   - it will **not** run the `callback` for `on` defined during the configuration time
           #   - it will rather `yield` the target stage after all the `before` _callbacks_ have been run
           #   - aside of this, the rest will be the same as when the _block_ is provided (see previous note)
+          # @raise [ArgumentError] if the object returned by `before` and `after` callbacks is not an `Eco::API::UseCases::BaseIO`.
           # @param key [Symbol, nil] cases:
           #   - if `key` is not provided, it targets the _current stage_
           #   - if `key` is provided, it targets the specific _sub-stage_
@@ -200,7 +201,16 @@ module Eco
               if key
                 io = stage(key).run(io: io, &block)
               elsif pending?
-                @before.each {|c| io = c.call(self, io)}
+                @before.each do |c|
+                  io = c.call(self, io).tap do |i_o|
+                    unless i_o.is_a?(Eco::API::UseCases::BaseIO)
+                      msg  = "Workflow callaback before('#{name}') should return Eco::API::UseCases::BaseIO object."
+                      msg += " Given #{i_o.class}"
+                      msg += " • Callback source location: '#{c.source_location}'"
+                      raise ArgumentError.new(msg)
+                    end
+                  end
+                end
 
                 unless skip?
                   io.session.logger.debug("(Workflow: #{path}) running now")
@@ -218,7 +228,16 @@ module Eco
                   @pending = false
                 end
 
-                @after.each  {|c| io = c.call(self, io)}
+                @after.each do |c|
+                  io = c.call(self, io).tap do |i_o|
+                    unless i_o.is_a?(Eco::API::UseCases::BaseIO)
+                      msg  = "Workflow callaback after('#{name}') should return Eco::API::UseCases::BaseIO object."
+                      msg += " Given #{i_o.class}"
+                      msg += " • Callback source location: '#{c.source_location}'"
+                      raise ArgumentError.new(msg)
+                    end
+                  end
+                end
               end
             rescue SystemExit
               exit

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

@@ -0,0 +1,18 @@
+class Eco::API::UseCases::DefaultCases::EntriesToCsv < Eco::API::Common::Loaders::UseCase
+  name "entries-to-csv"
+  type :import
+
+  attr_reader :session, :options
+
+  def main(entries, session, options, usecase)
+    @options = options
+    @session = session
+    entries.export(filename)
+  end
+
+  private
+
+  def filename
+    options.dig(:export, :file) || "entries.csv"
+  end
+end

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

@@ -24,6 +24,7 @@ require_relative 'default_cases/email_as_id_case'
 require_relative 'default_cases/hris_case'
 require_relative 'default_cases/new_id_case'
 require_relative 'default_cases/new_email_case'
+require_relative 'default_cases/entries_to_csv_case'
 require_relative 'default_cases/org_data_convert_case'
 require_relative 'default_cases/refresh_case'
 require_relative 'default_cases/reinvite_trans_case'

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

@@ -0,0 +1,184 @@
+# Use case to update a register
+# @note
+#   - You can define methods `filters` and `search` to change the target entries of the register
+#   - You need to define the `process_ooze` method
+# This case expects `options[:source][:register_id]`
+class Eco::API::UseCases::OozeSamples::RegisterExportCase < Eco::API::Common::Loaders::UseCase
+
+  class << self
+    # @return [Integer] the number of pages to be processed in each batch
+    def batch_size(size = nil)
+      @batch_size ||= 25
+      return @batch_size unless size
+      @batch_size = size
+    end
+  end
+
+  include Eco::API::UseCases::OozeSamples::Helpers
+
+  name "register-export-case"
+  type :other
+
+  attr_reader :session, :options, :usecase
+  attr_reader :target
+
+  def main(session, options, usecase)
+    options[:end_get] = false
+    @session = session; @options = options; @usecase = usecase
+    @target  = nil
+    raise "You need to inherit from this class ('#{self.class}') and call super with a block" unless block_given?
+    with_each_entry do |ooze|
+      process_ooze(ooze)
+    end
+    yield
+  end
+
+  # Write here your script
+  def process_ooze(ooze = target)
+    raise "You need to inherit from this class ('#{self.class}') and call super with a block" unless block_given?
+    yield(ooze)
+  end
+
+  private
+
+  def new_target(object)
+    @target = object
+  end
+
+  def with_each_entry
+    batched_search_results do |page_results|
+      page_results.each do |page_result|
+        if ooz = build_full_ooze(page_result.id)
+          yield(ooz)
+        end
+      end
+    end
+  end
+
+  # It builds a full page model (not updatable)
+  # @note If it's a page instance with stages, there's where it will be handy
+  # @param ooze_id [String]
+  # @return [Ecoportal::API::V2::Page]
+  def build_full_ooze(ooze_id)
+    if page = ooze(ooze_id)
+      return page unless page.is_a?(Ecoportal::API::V2::Pages::PageStage)
+      secs_doc = page.sections.doc
+      flds_doc = page.components.doc
+      pending_stage_ids = page.stages.map(&:id) - [page.current_stage_id]
+      pending_stage_ids.each do |id|
+        if page = stage(id, ooze: page)
+          page.sections.doc.each do |sec_doc|
+            unless secs_doc.find {|sec| sec["id"] == sec_doc["id"]}
+              secs_doc << sec_doc
+            end
+          end
+          page.components.doc.each do |comp_doc|
+            unless flds_doc.find {|fld| fld["id"] == comp_doc["id"]}
+              flds_doc << comp_doc
+            end
+          end
+        end
+      end
+      Ecoportal::API::V2::Page.new(page.doc)
+    end
+  end
+
+  #def update_oozes(batched_oozes = batch_queue)
+  #  batched_oozes.each do |ooze|
+  #    update_ooze(ooze)
+  #  end
+  #  batched_oozes.clear
+  #end
+
+  def batched_search_results
+    raise "Missing block. It yields in slices of #{self.class.batch_size} results" unless block_given?
+    results_preview
+    results = []
+    apiv2.registers.search(register_id, search_options) do |page_result|
+      results << page_result
+      if results.length >= self.class.batch_size
+        yield(results)
+        results = []
+      end
+    end
+    yield(results) unless results.empty?
+  end
+
+  def ooze(ooze_id = nil, stage_id: nil)
+    return target unless ooze_id
+    apiv2.pages.get(ooze_id, stage_id: stage_id).tap do |ooze|
+      if ooze
+        new_target(ooze)
+        logger.info("Got #{object_reference(ooze)}")
+      else
+        exit_error "Could not get ooze '#{ooze_id}'"
+      end
+    end
+  end
+
+  def stage(id_name = nil, ooze: target)
+    if ooze_id = ooze && ooze.id
+      exit_error "#{object_reference(ooze)} does not have stages!" unless ooze.stages?
+    else
+      exit_error "There's no target ooze to get retrieve stages from"
+    end
+
+    if stg = ooze.stages[id_name] || ooze.stages.get_by_name(id_name)
+      return ooze if ooze.respond_to?(:current_stage_id) && (ooze.current_stage_id == stg.id)
+      return apiv2.pages.get(ooze_id, stage_id: stg.id).tap do |stage|
+        if stage
+          new_target(stage)
+          logger.info("Got #{object_reference(stage)} from #{object_reference(ooze)}")
+        else
+          exit_error "Could not get stage '#{id_name}' in ooze '#{ooze_id}'"
+        end
+      end
+    end
+    exit_error "Stage '#{id_name}' doesn't exist in ooze '#{ooze_id}'"
+  end
+
+  def results_preview
+    apiv2.registers.search(register_id, search_options.merge(only_first: true)).tap do |search_results|
+      str_results = "Total target entries: #{search_results.total} (out of #{search_results.total_before_filtering})"
+      session.prompt_user("Do you want to proceed (y/N):", explanation: str_results, default: "N", timeout: 10) do |res|
+        unless res.upcase.start_with?("Y")
+          puts "..."
+          logger.info "Aborting script..."
+          exit(0)
+        end
+      end
+    end
+  end
+
+  def search_options
+    @search_options ||= {}.tap do |opts|
+      opts.merge!(sort: "created_at")
+      opts.merge!(dir:  "asc")
+      opts.merge!(query:   conf_search) if conf_search
+      opts.merge!(filters: conf_filters)
+    end
+  end
+
+  def conf_filters
+    return filters if self.respond_to?(:filters)
+    []
+  end
+
+  def conf_search
+    return search if self.respond_to?(:search)
+  end
+
+  def register_id
+    options.dig(:source, :register_id)
+  end
+
+  def apiv2
+   @apiv2 ||= session.api(version: :oozes)
+  end
+
+  def exit_error(msg)
+    logger.error(msg)
+    exit(1)
+  end
+
+end

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

@@ -0,0 +1,64 @@
+# Use case to update a target oozes
+# @note
+#   - `target_ids` => Expects options[:source][:file] where at least the 1st column should be the target entry `ids`
+class Eco::API::UseCases::OozeSamples::TargetOozesUpdateCase < Eco::API::UseCases::OozeSamples::RegisterUpdateCase
+  name "target-oozes-update-case"
+  type :other
+
+  private
+
+  def with_each_entry
+    batched_target_ids do |ids|
+      ids.each do |id|
+        if pending = queue_shift(id)
+          if dirty?(pending)
+            msg  = "Same entry 'id' appears more than once. "
+            msg << "Launching update on '#{object_reference(pending)}' to be able to queue it back"
+            console.warn msg
+            update_ooze(pending)
+          end
+        end
+        if ooz = ooze(id)
+          yield(ooz)
+        end
+      end
+      update_oozes
+    end
+  end
+
+  def batched_target_ids
+    raise "Missing block. It yields in slices of #{self.class.batch_size} ids" unless block_given?
+    target_ids_preview
+    pool = []
+    target_ids.each do |id|
+      pool << id
+      if pool.length >= self.class.batch_size
+        yield(pool)
+        pool = []
+      end
+    end
+    yield(pool) unless pool.empty?
+  end
+
+  def target_ids_preview
+    dups = target_ids.select {|id| target_ids.count(id) > 1}
+    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 "..."
+        logger.info "Aborting script..."
+        exit(0)
+      end
+    end
+  end
+
+  def target_ids
+    @target_ids ||= input_csv.columns.first[1..-1]
+  end
+
+  def input_csv
+    @input_csv ||= Eco::CSV.read(options.dig(:source, :file))
+  end
+
+end

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

@@ -10,7 +10,9 @@ end
 
 require_relative 'ooze_samples/helpers'
 require_relative 'ooze_samples/ooze_base_case'
+require_relative 'ooze_samples/register_export_case'
 require_relative 'ooze_samples/ooze_run_base_case'
 require_relative 'ooze_samples/ooze_update_case'
 require_relative 'ooze_samples/ooze_from_doc_case'
 require_relative 'ooze_samples/register_update_case'
+require_relative 'ooze_samples/target_oozes_update_case'

data/lib/eco/cli/config/default/options.rb

@@ -96,6 +96,13 @@ ASSETS.cli.config do |cnf|
       })
     end
 
+    desc  = "Used to export to a csv the final people (after processing). "
+    desc += "It is useful analyse the data after a -dry-run (-simulate)."
+    options_set.add("-processed-people-to-csv", desc) do |options, session|
+      file = SCR.get_file("-processed-people-to-csv", required: true, should_exist: false)
+      options.deep_merge!(report: {people: {csv: file}})
+    end
+
     desc  = "Runs in dry-run (no requests sent to server)"
     options_set.add(["-dry-run", "-simulate"], desc) do |options, session|
       options[:dry_run]  = true

data/lib/eco/cli/config/default/usecases.rb

@@ -137,6 +137,13 @@ ASSETS.cli.config do |cnf|
       end
     end
 
+    desc  = "Input file dump into a CSV as is."
+    cases.add("-entries-to-csv", :import, desc, case_name: "entries-to-csv")
+    .add_option("-out") do |options|
+      file  = SCR.get_file("-out")
+      options.deep_merge(export: {file: file})
+    end
+
     desc  = "Usage '-org-data-convert backup.json -restore-db-from'."
     desc += " Transforms an input .json file to the values of the destination environment "
     desc += " (names missmatch won't solve: i.e. usergroups)"
@@ -196,7 +203,7 @@ ASSETS.cli.config do |cnf|
     .add_option("-append-starters", as1) do |options|
       options.deep_merge!(people: {append_created: true})
     end
-    
+
     desc = "Creates people with only details"
     cases.add("-create-details-from", :sync, desc, case_name: "create-details")
     .add_option("-append-starters", as1) do |options|

data/lib/eco/cli/config/default/workflow.rb

@@ -119,9 +119,7 @@ ASSETS.cli.config do |config|
         else
           wf_post.skip!
           msg = "Although there are post_launch cases, they will NOT be RUN"
-          if !partial_update
-            msg+= ", because it is not a partial update (-get-partial)"
-          elsif io.options[:dry_run]
+          if io.options[:dry_run]
             msg+= ", because we are in dry-run (simulate)."
           end
           io.session.logger.info(msg)
@@ -134,7 +132,15 @@ ASSETS.cli.config do |config|
 
       wf_post.on(:usecases) do |wf_postcases, io|
         io.session.post_launch.each do |use|
-          io = use.launch(io: io).base
+          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
         end
         io
       end
@@ -146,8 +152,13 @@ ASSETS.cli.config do |config|
     end
 
     wf.on(:report) do |wf_report, io|
-      #config.reports.active(io: io)
-      #io.session.reports
+      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}
+        })
+        io = io.session.process_case("to-csv", io: io, type: :export)
+      end
       io
     end
 

data/lib/eco/csv/table.rb

@@ -15,6 +15,7 @@ module Eco
         end
       end
 
+      # It allows to rename the header names
       # @return [Eco::CSV::Table]
       def transform_headers
         header = self.headers
@@ -25,6 +26,8 @@ module Eco
         columns_to_table(cols)
       end
 
+      # When there are headers with the same name, it merges those columns
+      # @note it also offers a way to resolve merge conflicts
       # @return [Eco::CSV::Table]
       def merge_same_header_names
         dups = self.duplicated_header_names

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "2.0.41"
+  VERSION = "2.0.45"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.0.41
+  version: 2.0.45
 platform: ruby
 authors:
 - Oscar Segura
@@ -116,7 +116,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.8.4
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.9'
@@ -126,7 +126,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.8.4
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.9'
@@ -136,7 +136,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.19
+        version: 0.8.21
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.9'
@@ -146,7 +146,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.19
+        version: 0.8.21
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.9'
@@ -533,6 +533,7 @@ files:
 - lib/eco/api/usecases/default_cases/delete_sync_case.rb
 - lib/eco/api/usecases/default_cases/delete_trans_case.rb
 - lib/eco/api/usecases/default_cases/email_as_id_case.rb
+- lib/eco/api/usecases/default_cases/entries_to_csv_case.rb
 - lib/eco/api/usecases/default_cases/hris_case.rb
 - lib/eco/api/usecases/default_cases/new_email_case.rb
 - lib/eco/api/usecases/default_cases/new_id_case.rb
@@ -563,7 +564,9 @@ files:
 - lib/eco/api/usecases/ooze_samples/ooze_from_doc_case.rb
 - lib/eco/api/usecases/ooze_samples/ooze_run_base_case.rb
 - lib/eco/api/usecases/ooze_samples/ooze_update_case.rb
+- lib/eco/api/usecases/ooze_samples/register_export_case.rb
 - lib/eco/api/usecases/ooze_samples/register_update_case.rb
+- lib/eco/api/usecases/ooze_samples/target_oozes_update_case.rb
 - lib/eco/api/usecases/use_case.rb
 - lib/eco/api/usecases/use_case_chain.rb
 - lib/eco/api/usecases/use_case_io.rb