eco-helpers 2.0.21 → 2.0.26

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

@@ -7,16 +7,20 @@ module Eco
       # @param entries [Eco::API::Common::People::Entries] the input entries with the data.
       # @param people [Eco::API::Organization::People] target existing _People_ of the current update.
       # @param options [Hash] the options.
+      # @param append_created [Boolean] whether or not a new person will be added to the `people` object.
       # @yield [entry, person] gives each entry, and the paired person thereof (new or existing).
       # @yieldparam entry [PersonEntry] the input entry with the data we should set on person.
       # @yieldparam person [Ecoportal::API::V1::Person] the found person that matches `entry`, or a new person otherwise.
       # @return [Eco::API::Organization::People] all the people, including new and existing ones.
-      def with_each(entries, people, options)
+      def with_each(entries, people, options, append_created: true)
         @_skip_all_multiple_results = false
+        people_copy = people.newFrom(people.to_a)
         entries.each_with_object([]) do |entry, scoped|
           begin
-            unless person = people.find(entry, strict: micro.strict_search?(options))
-              person = session.new_person
+            unless person = people_copy.find(entry, strict: micro.strict_search?(options))
+              person = session.new_person.tap do |person|
+                people << person if append_created
+              end
             end
           rescue Eco::API::Organization::People::MultipleSearchResults => e
             unless @_skip_all_multiple_results

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

@@ -8,13 +8,14 @@ module Eco
       # @param people [Eco::API::Organization::People] target existing _People_ of the current update.
       # @param options [Hash] the options.
       # @param log_present [Boolean] log error message if an `entry` has match in `people`.
+      # @param append_created [Boolean] whether or not a new person will be added to the `people` object.
       # @yield [entry, person] gives each **new** `person` of `entries` that is not present in `people`.
       # @yieldparam entry [PersonEntry] the input entry with the data we should set on person.
       # @yieldparam person [Ecoportal::API::V1::Person] the **new** person.
       # @return [Eco::API::Organization::People] the starters.
-      def with_each_starter(entries, people, options, log_present: false)
+      def with_each_starter(entries, people, options, log_present: false, append_created: true)
         starters = []
-        micro.with_each(entries, people, options) do |entry, person|
+        micro.with_each(entries, people, options, append_created: append_created) do |entry, person|
           if !person.new?
             if log_present
               session.logger.error("This person (id: '#{person.id}') already exists: #{entry.to_s(:identify)}")

data/lib/eco/api/organization/people.rb

@@ -210,6 +210,12 @@ module Eco
           to_h(:supervisor_id)
         end
 
+        def group_by_schema
+          to_h do |person|
+            person.details && person.details.schema_id
+          end
+        end
+
         def to_h(attr = "id")
           super(attr || "id")
         end
@@ -252,7 +258,7 @@ module Eco
 
         def init_caches
           return if @caches_init
-          @by_id              = to_h
+          @by_id              = no_nil_key(to_h)
           @by_external_id     = no_nil_key(to_h('external_id'))
           @by_users_email     = no_nil_key(existing_users.to_h('email'))
           @by_non_users_email = no_nil_key(non_users.to_h('email'))

data/lib/eco/api/session.rb

@@ -66,6 +66,16 @@ module Eco
         @presets_factory ||= Eco::API::Organization::PresetsFactory.new(enviro: enviro)
       end
 
+      # @return [Eco::Data::Mapper] the mappings between the internal and external attribute/property names.
+      def fields_mapper
+        return @fields_mapper if instance_variable_defined?(:@fields_mapper)
+        mappings = []
+        if map_file = config.people.fields_mapper
+          mappings = map_file ? file_manager.load_json(map_file) : []
+        end
+        @fields_mapper = Eco::Data::Mapper.new(mappings)
+      end
+
       # Helper to obtain a EntryFactory
       # @param schema [String, Ecoportal::API::V1::PersonSchema] `schema` to which associate the EntryFactory,
       #  where `String` can be the _name_ or the _id_ of the schema.
@@ -79,15 +89,11 @@ module Eco
           return @entry_factories[schema&.id]
         end
 
-        mappings = []
-        if map_file = config.people.fields_mapper
-          mappings = map_file ? file_manager.load_json(map_file) : []
-        end
         @entry_factories[schema&.id] = Eco::API::Common::People::EntryFactory.new(
           enviro,
           schema:        schema,
           person_parser: config.people.parser,
-          attr_map:      Eco::Data::Mapper.new(mappings)
+          attr_map:      fields_mapper
         )
       end
 
@@ -147,9 +153,14 @@ module Eco
       # Generates an entries collection from a csv input file.
       # @see Eco::API::Common::People::EntryFactory#entries
       # @param file [String] file to generate the entries from.
+      # @param (see Eco::API::Session#entries)
       # @return [Eco::API::Common::People::Entries] collection of entries.
-      def csv_entries(file)
-        return entries(file: file, format: :csv)
+      def csv_entries(file, **kargs)
+        kargs.merge!({
+          file: file,
+          format: :csv
+        })
+        return entries(**kargs)
       end
 
       # Generates the collection of entries that should be discarded from an update.

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

@@ -137,7 +137,7 @@ module Eco
           rescue error_type => e
             raise unless retries_left > 0
             explanation = "Batch TimeOut. You have #{retries_left} retries left."
-            prompt_user("Do you want to retry (y/N)?", explanation, default: "Y", timeout: 10) do |response|
+            prompt_user(" Do you want to retry (y/N)?", default: "Y", explanation: explanation, timeout: 10) do |response|
               if response.upcase.start_with?("Y")
                 offer_retry_on(error_type, retries_left - 1, &block)
               else

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

@@ -164,12 +164,17 @@ module Eco
           # @return [Eco::API::Session::Batch::Status]
           def launch(simulate: false)
             pqueue    = processed_queue
-            @requests = pqueue.map {|e| as_update(e)}
+            @requests = as_update(pqueue)
             pre_checks(requests, simulate: simulate)
 
-            unless simulate
+            if simulate
+              if options.dig(:requests, :backup)
+                req_backup = as_update(pqueue, add_feedback: false)
+                backup_update(req_backup, simulate: simulate)
+              end
+            else
               if pqueue.length > 0
-                req_backup = pqueue.map {|e| as_update(e, add_feedback: false)}
+                req_backup = as_update(pqueue, add_feedback: false)
                 backup_update(req_backup)
                 session.batch.launch(pqueue, method: type).tap do |job_status|
                   @status     = job_status
@@ -220,13 +225,26 @@ module Eco
             end.join("\n")
           end
 
-          def as_update(*args)
-            feedback.as_update(*args)
+          def as_update(data, *args)
+            if data.is_a?(Array)
+              data.map do |e|
+                feedback.as_update(e, *args)
+              end.compact.select {|e| e && !e.empty?}
+            else
+              feedback.as_update(data, *args)
+            end
           end
 
           def processed_queue
             @queue.each {|e| @callbacks[e].call(e) if @callbacks.key?(e) }
-            apply_policies(api_included(@queue)).select {|e| !as_update(e).empty?}
+            apply_policies(api_included(@queue)).select do |e|
+              !as_update(e).empty?
+            end.select do |e|
+              next true unless e.is_a?(Ecoportal::API::V1::Person)
+              next true unless e.new?
+              # new people should either have account or details
+              e.account || e.details
+            end
           end
 
           # if there is a config definition to exclude entries
@@ -235,7 +253,13 @@ module Eco
           def api_included(full_queue)
             return full_queue if type == :create
             return full_queue unless excluded = session.config.people.api_excluded
-            full_queue.select {|entry| !excluded.call(entry, session, options, self)}
+            if options.dig(:include, :excluded, :only)
+              full_queue.select {|entry| excluded.call(entry, session, options, self)}
+            elsif options.dig(:include, :excluded)
+              full_queue
+            else
+              full_queue.select {|entry| !excluded.call(entry, session, options, self)}
+            end
           end
 
           # Applies the changes introduced by api policies
@@ -280,6 +304,9 @@ module Eco
             if !simulate && status
               status.queue.map do |entry|
                 if status.success?(entry)
+                  if type == :create && entry.respond_to?(:id=)
+                    entry.id = status[entry].body["id"]
+                  end
                   entry.consolidate! if entry.respond_to?(:consolidate!)
                 #else # do not entry.reset! (keep track on changes still)
                 end
@@ -300,16 +327,22 @@ module Eco
                 end
               end
             elsif simulate
+              fake_id = 111111111111111111111111
               queue.map do |entry|
+                if type == :create && entry.respond_to?(:id=)
+                  entry.id  = fake_id.to_s
+                  fake_id  += 1
+                end
                 entry.consolidate! if entry.respond_to?(:consolidate!)
               end
             end
           end
 
           # Keep a copy of the requests for future reference
-          def backup_update(requests)
+          def backup_update(requests, simulate: false)
+            dry_run   = simulate ? "_dry_run" : ""
             dir       = config.people.requests_folder
-            file      = File.join(dir, "#{type}_data.json")
+            file      = File.join(dir, "#{type}_data#{dry_run}.json")
             file_manager.save_json(requests, file, :timestamp)
           end
 

data/lib/eco/api/usecases.rb

@@ -2,7 +2,7 @@ module Eco
   module API
     class UseCases
 
-      class UnkownCase < Exception
+      class UnkownCase < StandardError
         def initialize(msg = nil, case_name: nil, type: nil)
           msg ||= "Unkown case"
           msg += ". Case name '#{case_name}'" if case_name
@@ -11,7 +11,7 @@ module Eco
         end
       end
 
-      class AmbiguousCaseReference < Exception
+      class AmbiguousCaseReference < StandardError
         def initialize(msg = nil, case_name: nil)
           msg ||= "You must specify type when there are multiple cases with same name"
           msg += ". Case name '#{case_name}'" if case_name

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

@@ -4,7 +4,7 @@ module Eco
       # Core class of UseCases. It basically defines and manages allowed `types`
       class BaseCase
 
-        class InvalidType < Exception
+        class InvalidType < StandardError
           def initialize(msg = nil, type:, types:)
             msg ||= "Invalid type."
             msg = "Given type '#{type}'. Valid types: #{types}"
@@ -13,7 +13,7 @@ module Eco
         end
 
         extend Eco::API::Common::ClassHelpers
-        
+
         @types = [:import, :filter, :transform, :sync, :error_handler, :export, :other]
 
         class << self

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

@@ -5,6 +5,19 @@ module Eco
       class BaseIO < BaseCase
         @types  = BaseCase.types
 
+        class MissingParameter < StandardError
+          attr_reader :type, :required, :given
+
+          def initialize(msg = nil, type: nil, required:, given:)
+            @type     = type
+            @required = required
+            @given    = given
+            msg += " of type '#{type}'" if type
+            msg += " requires an object '#{required}'. Given: #{given}."
+            super(msg)
+          end
+        end
+
         class << self
           def input_required?(type)
             !valid_type?(type) || [:import, :sync].include?(type)
@@ -80,13 +93,13 @@ module Eco
         def validate_args(input:, people:, session:, options:)
           case
           when !session.is_a?(Eco::API::Session)
-            raise "A UseCase needs a Session object. Given: #{session}"
+            raise MissingParameter.new("UseCase", required: :session, given: session.class)
           when input_required? && !input
-            raise "UseCase of type '#{type}' requires a valid input. None given"
+            raise MissingParameter.new("UseCase", type: type, required: :input, given: input.class)
           when people_required? && !people.is_a?(Eco::API::Organization::People)
-            raise "UseCase of type '#{type}' requires a People object. Given: #{people}"
+            raise MissingParameter.new("UseCase", type: type, required: :people, given: people.class)
           when !options || (options && !options.is_a?(Hash))
-            raise "To inject dependencies via ':options' it should be a Hash object. Given: #{options}"
+            raise MissingParameter.new("Use Case options", required: :Hash, given: options.class)
           end
           true
         end

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

@@ -2,12 +2,15 @@ class Eco::API::UseCases::DefaultCases::CreateCase < Eco::API::Common::Loaders::
   name "create"
   type :sync
 
+  attr_reader :options
+
   def main(entries, people, session, options, usecase)
+    options  = @options
     micro    = session.micro
     creation = session.new_job("main", "create",  :create, usecase)
     supers   = session.new_job("post", "supers",  :update, usecase, :core)
 
-    micro.with_each_starter(entries, people, options, log_present: true) do |entry, person|
+    micro.with_each_starter(entries, people, options, log_present: true, append_created: append_created) do |entry, person|
       creation.add(person)
       micro.set_core_with_supervisor(entry, person, people, supers, options)
       entry.set_details(person) unless options.dig(:exclude, :details)
@@ -15,4 +18,10 @@ class Eco::API::UseCases::DefaultCases::CreateCase < Eco::API::Common::Loaders::
     end
   end
 
+  private
+
+  def append_created
+    options.dig(:people, :append_created)
+  end
+
 end

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

@@ -2,15 +2,24 @@ class Eco::API::UseCases::DefaultCases::CreateDetailsCase < Eco::API::Common::Lo
   name "create-details"
   type :sync
 
+  attr_reader :options
+
   def main(entries, people, session, options, usecase)
+    @options = options
     micro    = session.micro
     creation = session.new_job("main", "create",  :create, usecase)
 
-    micro.with_each_starter(entries, people, options, log_present: true) do |entry, person|
+    micro.with_each_starter(entries, people, options, log_present: true, append_created: append_created) do |entry, person|
       creation.add(person)
       micro.set_core(entry, person, options)
       entry.set_details(person) unless options.dig(:exclude, :details)
     end
   end
 
+  private
+
+  def append_created
+    options.dig(:people, :append_created)
+  end
+
 end

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

@@ -2,16 +2,25 @@ class Eco::API::UseCases::DefaultCases::CreateDetailsWithSupervisorCase < Eco::A
   name "create-details-with-supervisor"
   type :sync
 
+  attr_reader :options
+
   def main(entries, people, session, options, usecase)
+    @options = options
     micro    = session.micro
     creation = session.new_job("main", "create", :create, usecase)
     supers   = session.new_job("post", "supers", :update, usecase, :core)
 
-    micro.with_each_starter(entries, people, options, log_present: true) do |entry, person|
+    micro.with_each_starter(entries, people, options, log_present: true, append_created: append_created) do |entry, person|
       creation.add(person)
       micro.set_core_with_supervisor(entry, person, people, supers, options)
       entry.set_details(person) unless options.dig(:exclude, :details)
     end
   end
 
+  private
+
+  def append_created
+    options.dig(:people, :append_created)
+  end
+
 end

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

@@ -3,8 +3,11 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
   type :sync
 
   attr_reader :creation, :update, :supers, :leavers
+  attr_reader :people, :session, :options
 
   def main(entries, people, session, options, usecase)
+    @session = session; @options = options; @people = people
+    require_only_one_schema!
     micro    = session.micro
     @creation = session.new_job("main", "create",  :create, usecase)
     @update   = session.new_job("main", "update",  :update, usecase)
@@ -15,7 +18,7 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
       leavers.add(person, &method(:leavers_callback))
     end
 
-    micro.with_each(entries, people, options) do |entry, person|
+    micro.with_each(entries, people, options, append_created: append_created) do |entry, person|
       person.new? ? creation.add(person) : update.add(person)
       micro.set_core_with_supervisor(entry, person, people, supers, options)
       entry.set_details(person) unless options.dig(:exclude, :details)
@@ -25,9 +28,30 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
 
   private
 
+  def append_created
+    options.dig(:people, :append_created)
+  end
+
   def leavers_callback(person)
     person.supervisor_id = nil
     person.account       = nil if person.account
   end
 
+  def require_only_one_schema!
+    unless schema_id = options.dig(:people, :filter, :details, :schema_id)
+      active_schema = session.schema
+      other_schemas = session.schemas.map(&:id) - [active_schema.id]
+      other_people  = people.group_by_schema.values_at(*other_schemas).map(&:to_a).flatten
+      if other_people.length > 3
+        msg  = "There are #{other_people.length} people in schemas other than #{active_schema.name}."
+        msg << " Please, use the filter option '-schema_id SchemaName' for the 'hris' case to only include those of that schema"
+        msg << " in the current update. The HRIS case identifies people that are not in the file as leavers"
+        msg << " (as it will remove the account of all the people of other schemas if they are not in the input file)."
+        msg << "\n For example: -schema-id '#{active_schema.name.downcase}'"
+        logger.error(msg)
+        raise msg
+      end
+    end
+  end
+
 end

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

@@ -2,13 +2,16 @@ class Eco::API::UseCases::DefaultCases::UpsertCase < Eco::API::Common::Loaders::
   name "upsert"
   type :sync
 
+  attr_reader :options
+  
   def main(entries, people, session, options, usecase)
+    @options = options
     micro    = session.micro
     creation = session.new_job("main", "create", :create, usecase)
     update   = session.new_job("main", "update", :update, usecase)
     supers   = session.new_job("post", "supers", :update, usecase, :core)
 
-    micro.with_each(entries, people, options) do |entry, person|
+    micro.with_each(entries, people, options, append_created: append_created) do |entry, person|
       person.new? ? creation.add(person) : update.add(person)
       micro.set_core_with_supervisor(entry, person, people, supers, options)
       entry.set_details(person) unless options.dig(:exclude, :details)
@@ -16,4 +19,10 @@ class Eco::API::UseCases::DefaultCases::UpsertCase < Eco::API::Common::Loaders::
     end
   end
 
+  private
+
+  def append_created
+    options.dig(:people, :append_created)
+  end
+
 end