eco-helpers 2.0.25 → 2.0.30

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/to_csv_case.rb

@@ -125,43 +125,7 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
       "id"                 => "ecoPortal ID",
       "external_id"        => "Reference ID (ext_id)",
       "login_provider_ids" => "Login Methods",
-      "landing_page_id"    => "Landing Page ID",
-      "show_sidebar"       => "(pref) Sidebar Open?",
-      "show_shortcuts"     => "(pref) Link to Registers?",
-      "show_coming_soon"   => "(pref) Coming Soon List?",
-      "show_recently_visited_forms" => "(pref) Recently Visited Forms List?",
-      "show_tasks"         => "(pref) Tasks List?",
-      "show_task_bubbles"  => "(pref) Task Count Bubbles",
-      "kiosk_enabled"      => "Kiosk User?",
-      "freemium"           => "Freemium User?",
-      "files"              => "(able) on Files",
-      "reports"            => "(able) on Report Structures",
-      "data"               => "(able) on Data (hours, datasets)",
-      "organization"       => "(able) on Organization Config",
-      "pages"              => "(able) on Page/Entries",
-      "page_editor"        => "(able) page Editor Level",
-      "registers"          => "(able) on Registers",
-      "tasks"              => "(able) on Tasks",
-      "person_core"        => "(able) on People",
-      "person_core_create" => "(able) Create People?",
-      "person_core_edit"   => "(able) Edit People?",
-      "person_details"     => "(able) on People Schema Details",
-      "person_account"     => "(able) on Users",
-      "person_abilities"   => "(able) on Users' Abilities",
-      "custom_files"              => "(min) on Files",
-      "custom_reports"            => "(min) on Report Structures",
-      "custom_data"               => "(min) on Data (hours, datasets)",
-      "custom_organization"       => "(min) on Organization Config",
-      "custom_pages"              => "(min) on Page/Entries",
-      "custom_page_editor"        => "(min) page Editor Level",
-      "custom_registers"          => "(min) on Registers",
-      "custom_tasks"              => "(min) on Tasks",
-      "custom_person_core"        => "(min) on People",
-      "custom_person_core_create" => "(min) Create People?",
-      "custom_person_core_edit"   => "(min) Edit People?",
-      "custom_person_details"     => "(min) on People Schema Details",
-      "custom_person_account"     => "(min) on Users",
-      "custom_person_abilities"   => "(min) on Users' Abilities"
+      "landing_page_id"    => "Landing Page ID"
     }
   end
 

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

@@ -75,4 +75,46 @@ class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::UseCases::
     ]
   end
 
+  def nice_header_maps
+    @nice_header_maps ||= super.merge({
+      "landing_page_id"    => "Landing Page ID",
+      "show_sidebar"       => "(pref) Sidebar Open?",
+      "show_shortcuts"     => "(pref) Link to Registers?",
+      "show_coming_soon"   => "(pref) Coming Soon List?",
+      "show_recently_visited_forms" => "(pref) Recently Visited Forms List?",
+      "show_tasks"         => "(pref) Tasks List?",
+      "show_task_bubbles"  => "(pref) Task Count Bubbles",
+      "kiosk_enabled"      => "Kiosk User?",
+      "freemium"           => "Freemium User?",
+      "files"              => "(able) on Files",
+      "reports"            => "(able) on Report Structures",
+      "data"               => "(able) on Data (hours, datasets)",
+      "organization"       => "(able) on Organization Config",
+      "pages"              => "(able) on Page/Entries",
+      "page_editor"        => "(able) page Editor Level",
+      "registers"          => "(able) on Registers",
+      "tasks"              => "(able) on Tasks",
+      "person_core"        => "(able) on People",
+      "person_core_create" => "(able) Create People?",
+      "person_core_edit"   => "(able) Edit People?",
+      "person_details"     => "(able) on People Schema Details",
+      "person_account"     => "(able) on Users",
+      "person_abilities"   => "(able) on Users' Abilities",
+      "custom_files"              => "(min) on Files",
+      "custom_reports"            => "(min) on Report Structures",
+      "custom_data"               => "(min) on Data (hours, datasets)",
+      "custom_organization"       => "(min) on Organization Config",
+      "custom_pages"              => "(min) on Page/Entries",
+      "custom_page_editor"        => "(min) page Editor Level",
+      "custom_registers"          => "(min) on Registers",
+      "custom_tasks"              => "(min) on Tasks",
+      "custom_person_core"        => "(min) on People",
+      "custom_person_core_create" => "(min) Create People?",
+      "custom_person_core_edit"   => "(min) Edit People?",
+      "custom_person_details"     => "(min) on People Schema Details",
+      "custom_person_account"     => "(min) on Users",
+      "custom_person_abilities"   => "(min) on Users' Abilities"
+    })
+  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

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

@@ -65,8 +65,8 @@ ASSETS.cli.config do |cnf|
         input = [file].flatten.reduce(Eco::API::Organization::People.new([])) do |people, file|
           people.merge(JSON.parse(File.read(file)))
         end
-      else
-        input = session.csv_entries(file)
+      else # :csv
+        input = session.csv_entries(file, check_headers: true)
       end
     end
     input

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

@@ -1,19 +1,35 @@
 ASSETS.cli.config do |cnf|
   cnf.options_set do |options_set, options|
     options_set.add("--help", "Offers a HELP") do |options, sesssion|
-      conf = ASSETS.cli.config
-      puts conf.people_filters.help if hpf = SCR.get_arg("-filters")
-      puts conf.input_filters.help  if hif = SCR.get_arg("-input-filters")
-      puts conf.options_set.help    if ho  = SCR.get_arg("-options")
-      puts conf.usecases.help       if huc = SCR.get_arg("-usecases")
+      conf   = ASSETS.cli.config
+      active = Proc.new do |opt|
+        if there = SCR.get_arg(opt)
+          refine = SCR.get_arg(opt, with_param: true)
+        end
+        refine || there
+      end
+
+      if hpf = active.call("-filters")
+        puts conf.people_filters.help(refine: hpf)
+      end
+      if hif = active.call("-input-filters")
+        puts conf.input_filters.help(refine: hif)
+      end
+      if ho  = active.call("-options")
+        puts conf.options_set.help(refine: ho)
+      end
+      if huc = active.call("-usecases")
+        puts conf.usecases.help(refine: huc)
+      end
       puts [
         "Please specify one of the below:",
         "  -filters       to display available filters on people",
         "  -input-filters to display available filters on input data",
         "  -options       to dislpay available options",
         "  -usecases      to display available usecases",
-        "",
-        "You may specify the usecase to know its specific options by: -usecase_name --help -options"
+        "TIPS:",
+        "  * You may specify the usecase to know its specific options by:    -usecase_name --help -options",
+        "  * You may specify a refinement to show specific information only: --help -usecases tags"
       ].join("\n") unless hpf || hif || ho || huc
       exit
     end
@@ -87,6 +103,11 @@ ASSETS.cli.config do |cnf|
       session.config.dry_run!
     end
 
+    desc  = "Runs runs post_launch cases even if in dry-run"
+    options_set.add("-run-postlaunch", desc) do |options, session|
+      options.deep_merge!(post_launch: {run: true})
+    end
+
     desc  = "(careful with this option)  This will include everybody as part of the update (including those that are api excluded). "
     desc += "Only launch with this option when only api excluded people are included in your update."
     options_set.add("-include-excluded", desc) do |options|