eco-helpers 2.0.25 → 2.0.26

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

@@ -80,21 +80,21 @@ module Eco
           # @param data [Array<Hash>] data to be parsed. It cannot be used alongside with `file:`
           # @param file [String] absolute or relative path to the input file. It cannot be used alongside with `data:`.
           # @param format [Symbol] it must be used when you use the option `file:` (i.e. `:xml`, `:csv`), as it specifies the format of the input `file:`.
-          # @param encoding [String] optional parameter to read `file:` by expecting certain encoding.
+          # @param options [Hash] further options.
+          # @option options [String] :encoding optional parameter to read `file:` by expecting certain encoding.
+          # @option options [Boolean] :check_headers signals if the `csv` file headers should be expected.
           # @return [Eco::API::Common::People::Entries] collection of `Eco::API::Common::People::PersonEntry`.
-          def entries(data: (no_data = true; nil), file: (no_file = true; nil), format: (no_format = true; nil), encoding: nil)
+          def entries(data: (no_data = true; nil), file: (no_file = true; nil), format: (no_format = true; nil), **options)
             fatal("You should at least use data: or file:, but not both") if no_data == no_file
             fatal("You must specify a valid format: (symbol) when you use file.") if file && no_format
             fatal("Format should be a Symbol. Given '#{format}'") if format && !format.is_a?(Symbol)
             fatal("There is no parser/serializer for format ':#{format.to_s}'") unless no_format || @person_parser.defined?(format)
 
-            kargs = {}
-            kargs.merge!(content:  data)     unless no_data
-            kargs.merge!(file:     file)     unless no_file
-            kargs.merge!(format:   format)   unless no_format
-            kargs.merge!(encoding: encoding) if encoding
+            options.merge!(content:  data)     unless no_data
+            options.merge!(file:     file)     unless no_file
+            options.merge!(format:   format)   unless no_format
 
-            Entries.new(to_array_of_hashes(**kargs), klass: PersonEntry, factory: self)
+            Entries.new(to_array_of_hashes(**options), klass: PersonEntry, factory: self)
           end
 
           def to_array_of_hashes(**kargs)
@@ -118,7 +118,8 @@ module Eco
               logger.error("Input data as 'Hash' not supported. Expecting 'Enumerable' or 'String'")
               exit(1)
             when String
-              to_array_of_hashes(content: person_parser.parse(format, content))
+              deps = {check_headers: true} if kargs[:check_headers]
+              to_array_of_hashes(content: person_parser.parse(format, content, deps: deps || {}))
             when Enumerable
               sample = content.to_a.first
               case sample

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

@@ -6,6 +6,14 @@ module Eco
         # Class to define a parser/serializer.
         class PersonAttributeParser < Eco::Language::Models::ParserSerializer
 
+          # @note
+          #   - This was introduced at a later stage and might not be available for certain org-parsers configs
+          # @return [RequiredAttrs]
+          def required_attrs
+            @required_attrs ||= @dependencies[:required_attrs]
+            #@required_attrs ||= RequiredAttrs.new(attr, :unkown, [attr])
+          end
+
           # @see Eco::Language::Models::ParserSerializer#def_parser
           # @note
           #  - additionally, you can declare a callback `active:` to determine if when the

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

@@ -10,7 +10,7 @@ module Eco
 
           attr_reader :schema, :schema_attrs
 
-          def initialize(person: {}, schema: {}, account: {}, modifier: Common::People::PersonModifier.new)
+          def initialize(person: nil, schema: {}, account: {}, modifier: Common::People::PersonModifier.new)
             @modifier = Common::People::PersonModifier.new(modifier)
             @person  = person
             @account = account
@@ -77,7 +77,9 @@ module Eco
             when Hash
               JSON.parse(person.to_json)
             else
-              {}
+              {
+                "subordinates" => 0
+              }
             end
           end
 

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

@@ -59,9 +59,15 @@ module Eco
 
           # @!group Scopping attributes (identifying, presence & active)
 
+          # @return [Array<Eco::API::Common::Loaders::Parser::RequiredAttrs>]
+          def required_attrs
+            @parsers.values_at(*all_attrs(include_defined_parsers: true)).compact.map(&:required_attrs).compact
+          end
+
           # All the internal name attributes, including _core_, _account_ and _details_.
           def all_attrs(include_defined_parsers: false)
-            all_model_attrs | defined_model_attrs
+            return all_model_attrs | defined_model_attrs if include_defined_parsers
+            all_model_attrs
           end
 
           # Scopes `source_attrs` using the _**core** attributes_.

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

@@ -15,7 +15,7 @@ module Eco
             # Reorders as follows:
             #   1. supervisors, people with no supervisor or where their supervisor not present
             #   2. subordinates
-            # @return [Array<Entry>] `values` sorted by supervisors/subordinates
+            # @return [Array<PersonEntry>] `values` sorted by supervisors/subordinates
             def sort_by_supervisors(values, supervisors_first: true)
               raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
               return [] unless values && values.is_a?(Enumerable)

data/lib/eco/api/common/version_patches/ecoportal_api/external_person.rb

@@ -5,14 +5,6 @@ module Ecoportal
       class Person
         attr_accessor :entry
 
-        def reset_details!
-          doc["details"] = JSON.parse(original_doc["details"])
-        end
-
-        def consolidate_details!
-          original_doc["details"] = JSON.parse(doc["details"])
-        end
-
         def identify(section = :person)
           if entry && section == :entry
             entry.to_s(:identify)

data/lib/eco/api/common/version_patches/ecoportal_api/internal_person.rb

@@ -3,14 +3,6 @@ module Ecoportal
     class Internal
       class Person
 
-        def reset_account!
-          doc["account"] = JSON.parse(original_doc["account"])
-        end
-
-        def consolidate_account!
-          original_doc["account"] = JSON.parse(doc["account"])
-        end
-
         def new?(doc = :initial)
           ref_doc = (doc == :original) ? original_doc : initial_doc
           !ref_doc["details"] && !ref_doc["account"]

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

@@ -12,9 +12,11 @@ module Eco
         unless options.dig(:exclude, :core) && !person.new?
           micro.set_core(entry, person, options)
           if entry.supervisor_id?
-            micro.set_supervisor(entry.supervisor_id, person, people, options) do |unkown_id|
+            micro.set_supervisor(person, entry.supervisor_id, people, options) do |unknown_id|
               # delay setting supervisor if does not exit
-              supers_job.add(person) {|person| person.supervisor_id = unkown_id}
+              supers_job.add(person) do |person|
+                micro.set_supervisor(person, unknown_id, people, options)
+              end
             end
           end
         end

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

@@ -1,22 +1,27 @@
 module Eco
   module API
     class MicroCases
-      # Special snippet to decide if the `supervisor_id` is set now or in a later batch job `supers_job`.
-      # @note delaying the setting of a `supervisor_id` can save errors when the supervisor still does not exit.
-      # @param sup_id [nil, String] the **supervisor id** we should set on the `person`.
+      # Unique access point to set the `supervisor_id` value on a person.
       # @param person [Ecoportal::API::V1::Person] the person we want to update, carrying the changes to be done.
-      # @param people [Eco::API::Organization::People] target existing _People_ of the current update.
+      # @param sup_id [nil, String] the **supervisor id** we should set on the `person`.
+      # @param people [Eco::API::Organization::People] _People_ involved in the current update.
       # @param options [Hash] the options.
       # @yield [supervisor_id] callback when the supervisor_id is **unknown** (not `nil` nor any one's in `people`).
       # @yieldparam supervisor_id [String] the **unknown** `supervisor_id`.
-      def set_supervisor(sup_id, person, people, options)
+      def set_supervisor(person, sup_id, people, options)
         unless options.dig(:exclude, :core) || options.dig(:exclude, :supervisor)
-          micro.with_supervisor(sup_id, people) do |supervisor|
+          cur_id    = person.supervisor_id
+          cur_super = cur_id && with_supervisor(cur_id, people)
+          micro.with_supervisor(sup_id, people) do |new_super|
             if !sup_id
               person.supervisor_id = nil
-            elsif supervisor
-              person.supervisor_id = supervisor.id
+              descrease_subordinates(cur_super)
+            elsif new_super && id = new_super.id
+              person.supervisor_id = id
+              descrease_subordinates(cur_super)
+              increase_subordinates(new_super)
             elsif !block_given?
+              descrease_subordinates(cur_super)
               person.supervisor_id = sup_id
             else
               yield(sup_id) if block_given?
@@ -25,6 +30,22 @@ module Eco
         end
       end
 
+      private
+
+      def descrease_subordinates(person, by = 1)
+        if person.is_a?(Ecoportal::API::V1::Person)
+          person.subordinates -= by
+          #person.subordinates  = 0 if person.subordinates < 0
+        end
+      end
+
+      def increase_subordinates(person, by = 1)
+        if person.is_a?(Ecoportal::API::V1::Person)
+          #person.subordinates  = 0 if person.subordinates < 0
+          person.subordinates += by
+        end
+      end
+
     end
   end
 end

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

@@ -258,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

@@ -153,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/job.rb

@@ -304,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
@@ -324,7 +327,12 @@ 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

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

@@ -18,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)
@@ -28,6 +28,10 @@ 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
@@ -41,7 +45,7 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
       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 << " 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)

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