eco-helpers 1.0.5 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db7768619b97c307a3bed9edede57a9cc0fc32defce50ddbe43972544cc5b915
-  data.tar.gz: f4c69c66654881629ce0d070f1b912982d73df87d3b608e428cd12182c5f3729
+  metadata.gz: a87a05e0b6be791a7cb630afb3fce8405447aca9f130a4940d3a042b8ccf0720
+  data.tar.gz: fc315306e49cfe9be73c67b61b9a2bd1f59fbc6b74850e82400399ebd6255377
 SHA512:
-  metadata.gz: e2d69f4364ad41db88ceb7d7876251d0fc560dbd027cc79e5e6f7640c7f830a3680722c482eaed2c8647938bb7e6d8961b336c195ec0d53192ec856ec332440e
-  data.tar.gz: de56af0c58ef50d7caadc1162cf30a04137c8fd35af6453c0a970473be9e9c98ff3192c29460fbc2085805d4a914706dfe0e34c37f9b2defe790765a11188690
+  metadata.gz: 18f83a3a064dd30033519d3df486e1d9839a87abc1161bf9f2d42b1378dcfe4ae20b40d018968c5fed6b8e3e6310202f2545dd4a2c2de85281de93a8d7b662f5
+  data.tar.gz: 2ac3597409e546f5d931264b5cfa8a4f39b3ad4665c4d37f5349da12bbf3af9d42fe3f261b379f0c0e74cbcc8399a1d832578e83b26eeca4f0c419024a59cacd

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

@@ -63,7 +63,10 @@ module Eco
                 encoding   ||= Eco::API::Common::Session::FileManager.encoding(file)
                 file_content = File.read(file, encoding: encoding)
                 arr_hash     = @person_parser.parse(format, file_content)
+              else
+                @logger.warn("File does not exist: #{file}")
               end
+
               entries(data: arr_hash)
             else
               Entries.new(data, klass: PersonEntry, factory: self)

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

@@ -2,7 +2,7 @@ module Ecoportal
   module API
     class Internal
       class Person
-
+        
         def reset_account!
           doc["account"] = JSON.parse(original_doc["account"])
         end
@@ -11,22 +11,6 @@ module Ecoportal
           original_doc["account"] = JSON.parse(doc["account"])
         end
 
-        def account=(value)
-          case value
-          when NilClass
-            doc["account"] = nil
-          when Internal::Account
-            doc["account"] = JSON.parse(value.to_json)
-          when Hash
-            doc["account"] = value.slice(*%w[policy_group_ids landing_page_id permissions_preset permissions_custom preferences prefilter filter_tags default_tag login_provider_ids starred_ids])
-          else
-            # TODO
-            raise "Invalid set on account: Need nil, Account or Hash; got #{value.class}"
-          end
-          remove_instance_variable("@account") if defined?(@account)
-          return account
-        end
-
       end
     end
   end

data/lib/eco/api/error.rb

@@ -30,8 +30,9 @@ module Eco
         @match   = /#{@str_err}/
       end
       class EmailTaken < Eco::API::Error
-        @str_err = "user email already taken"
-        @match   = /#{@str_err}/
+        @str_err  = "user email already taken"
+        @str_err2 = "Email is already taken"
+        @match    = /(?:#{@str_err}|#{@str_err2})/
       end
       class SupervisorNotFound < Eco::API::Error
         @str_err = "Supervisor not found"

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

@@ -51,13 +51,13 @@ module Eco
         def person(id: nil, external_id: nil, email: nil, strict: false)
           init_caches
           pers = @by_id[id]&.first if id
-          pers = @by_external_id[external_id&.strip]&.first        if !pers && !external_id.to_s.strip.empty?
+          pers = @by_external_id[external_id&.strip]&.first       if !pers && !external_id.to_s.strip.empty?
 
           # strict prevents taking existing user for searched person with same email
           # specially useful if the organisation ensures all have external id (no need for email search)
           if !pers && (!strict || external_id.to_s.strip.empty?)
             # person still not found and either not strict or no external_id provided
-            pers = @by_users_email[email&.downcase.strip]&.first   if !email.to_s.strip.empty?
+            pers = @by_users_email[email&.downcase.strip]&.first  if !email.to_s.strip.empty?
 
             if !pers && !strict && !email.to_s.strip.empty?
               candidates = @by_non_users_email[email&.downcase.strip] || []
@@ -66,7 +66,7 @@ module Eco
             end
 
           end
-          pers = @by_external_id[email&.downcase.strip]&.first   if !pers && !email.to_s.strip.empty?
+          pers = @by_external_id[email&.downcase.strip]&.first    if !pers && !email.to_s.strip.empty?
 
           pers
         end
@@ -102,6 +102,10 @@ module Eco
           exclude_people(into_a(object), strict: strict)
         end
 
+        def exclude!(object, strict: false)
+          self < exclude(object, strict: strict).to_a
+        end
+
         def exclude_people(list, strict: false)
           discarded = list.map do |person|
             find(person, strict: strict)

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

@@ -46,10 +46,16 @@ module Eco
           @has_tags.empty?
         end
 
-        # List of tag nodes of the entire subtree.
+        # @param depth [Integer] if empty, returns the list of tag nodes of that level. Otherwise the list of tag nodes of the entire subtree.
         # @return [Array<String>]
-        def tags
-          @hash_tags.keys
+        def tags(depth: nil)
+          if !depth || depth < 0
+            @hash_tags.keys
+          else
+            @hash_tags.select do |t, n|
+              n.depth == depth
+            end.keys
+          end
         end
 
         # Verifies if a tag exists in the tree.

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

@@ -91,18 +91,18 @@ module Eco
           end
 
           def launch(simulate: false)
-            queue = processed_queue
-            launch_feedback(queue, simulate ? 2500 : 800)
+            pqueue = processed_queue
+            launch_feedback(pqueue, simulate ? 2500 : 800)
 
             if !simulate
-              if queue.length > 0
-                backup_update(queue)
-                @status = session.batch.launch(queue, method: type)
+              if pqueue.length > 0
+                backup_update(pqueue)
+                @status = session.batch.launch(pqueue, method: type)
                 @status.root = self
               end
             end
 
-            post_launch(queue: queue, simulate: simulate)
+            post_launch(queue: pqueue, simulate: simulate)
 
             logger.info("Simulate: this would have launched: '#{type}'") if simulate
             @pending = false
@@ -113,7 +113,7 @@ module Eco
 
           def processed_queue
             @queue.each {|e| @callbacks[e].call(e) if @callbacks.key?(e) }
-            apply_policies(@queue).select {|e| !as_update(e).empty?}
+            apply_policies(api_included(@queue)).select {|e| !as_update(e).empty?}
           end
 
           def post_launch(queue: [], simulate: false)
@@ -128,9 +128,9 @@ module Eco
               handlers = session.config.error_handlers
               if @status.errors.any? && !handlers.empty?
                 err_types = @status.errors.by_type
-                handlers.each do |hd|
-                  if entries = err_types[hd.name]
-                    hd.launch(people: people(entries), session: session, options: options)
+                handlers.each do |handler|
+                  if entries = err_types[handler.name]
+                    handler.launch(people: people(entries), session: session, options: options)
                   end
                 end
               end
@@ -141,11 +141,21 @@ module Eco
             end
           end
 
+          # if there is a config definition to exclude entries
+          # and the current batch is not a creation batch
+          # - filter out excluded entries from the api update
+          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)}
+          end
+
           def apply_policies(pre_queue)
-            pre_queue.tap do |entries|
+            #pre_queue.tap do |entries|
+            people(pre_queue).tap do |entries|
               policies = session.config.policies
               unless policies.empty?
-                policies.launch(people: people(entries), session: session, options: options)
+                policies.launch(people: entries, session: session, options: options)
               end
             end
           end

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

@@ -39,6 +39,12 @@ module Eco
             self["discarded_file"]
           end
 
+          # with given a person what is the criteria of exclusion
+          def api_excluded
+            return self["api_excluded"] unless block_given?
+            self["api_excluded"] = Proc.new
+          end
+
           # internal-external fields map
           def fields_mapper=(file)
             self["fields_mapper"] = file
@@ -56,7 +62,7 @@ module Eco
           def default_usergroup
             self["default_usergroup"]
           end
-          
+
           def default_schema=(name)
             self["default_schema"] = name
           end

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

@@ -18,7 +18,7 @@ module Eco
                 if !person
                   session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
                 else
-                  unless entry.email.to_s.strip.downcase == person.email
+                  unless entry.email.to_s.strip.downcase == person.email.to_s.strip.downcase
 
                     super_id      = person.supervisor_id
                     s_account_doc = person.account&.doc

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

@@ -7,6 +7,7 @@ module Eco
           def process
             @cases.define("create", type: :sync) do |entries, people, session, options, usecase|
               creation = session.job_group("main").new("create", usecase: usecase, type: :create, sets: [:core, :details, :account])
+              supers   = session.job_group("post").new("supers", usecase: usecase, type: :update, sets: :core)
 
               strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
               pgs = session.policy_groups
@@ -55,6 +56,23 @@ module Eco
                   end
 
                   creation.add(person)
+
+                  # set supervisor
+                  unless options.dig(:exclude, :core) || options.dig(:exclude, :supervisor)
+                    if !(sup_id = entry.supervisor_id)
+                      person.supervisor_id = nil
+                    else
+                      if supervisor = people.person(id: sup_id, external_id: sup_id, email: sup_id)
+                        person.supervisor_id = supervisor.id
+                      else
+                        # delay setting supervisor if does not exit
+                        supers.add(person) do |person|
+                          person.supervisor_id = sup_id
+                        end
+                      end
+                    end
+                  end
+                  
                 end
               end
             end

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

@@ -31,10 +31,7 @@ module Eco
                     else
                       # delay setting supervisor if does not exit
                       supers.add(person) do |person|
-                        #person = session.new_person(person: person.doc)
-                        person.sync
                         person.supervisor_id = sup_id
-                        person
                       end
                     end
                   end

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

@@ -6,44 +6,78 @@ module Eco
 
           def process
             @cases.define("hris", type: :sync) do |entries, people, session, options, usecase|
-              # IMPORTANT: this two lines ensure that key users are preserved (only manually maintained)
-              #people  = people.exclude(session.discarded_entries)
-              #entries = entries.exclude(session.discarded_entries)
-
               creation = session.job_group("main").new("create", usecase: usecase, type: :create, sets: [:core, :details, :account])
               update   = session.job_group("main").new("update", usecase: usecase, type: :update, sets: [:core, :details, :account])
               supers   = session.job_group("post").new("supers", usecase: usecase, type: :update, sets: :core)
-              #remove   = session.job_group("post").new("remove_account", type: :update, sets: :account)
+              remove   = session.job_group("post").new("remove_account", usecase: usecase, type: :update, sets: :account)
 
-              #people.users.each_with_index  do |person, i|
-              #  if !entries.find(person)
-              #    remove.add(person) do |person|
-              #      person.account = nil
-              #      person
-              #    end
-              #  end
-              #end
+              people.users.each_with_index  do |person, i|
+                if !entries.find(person)
+                  remove.add(person) do |person|
+                    person.supervisor_id = nil
+                    person.account       = nil
+                  end
+                end
+              end
 
               strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
+              pgs           = session.policy_groups
 
-              entries.each.with_index do |entry, i|
+              entries.each_with_index do |entry, i|
                 person = people.find(entry, strict: strict_search)
                 person = session.new_person if create = !person
 
-                entry.set_core(person, exclude: "supervisor_id")
-                entry.set_details(person)
-                entry.set_account(person) #if !remove.people.find(entry)
-                person.account.send_invites = options[:send_invites] if options.key?(:send_invites)
+                unless options.dig(:exclude, :core) && !create
+                  ini_tags   = person.filter_tags || []
+
+                  core_attrs = ["name", "external_id", "email", "filter_tags"]
+                  core_excluded = core_attrs.map(&:to_sym).select {|attr| options.dig(:exclude, attr)}
+                  core_excluded.push("supervisor_id")
+
+                  entry.set_core(person, exclude: core_excluded)
+                  if session.tagtree && !options.dig(:exclude, :filter_tags)
+                    person.filter_tags = session.tagtree.user_tags(
+                      initial:          ini_tags,
+                      final:            person.filter_tags,
+                      preserve_custom:  true,
+                      add_custom:       true
+                    )
+                  end
+                end
+
+                entry.set_details(person) unless options.dig(:exclude, :details)
+
+                unless options.dig(:exclude, :account)
+                  ini_pg_ids = person.account&.policy_group_ids || []
 
-                person.account.permissions_custom = session.new_preset(person) unless !create && options.dig(:exclude, :abilities)
+                  account_excluded = []
+                  account_excluded.push("policy_group_ids") if options.dig(:exclude, :policy_groups) && !create
 
-                person.account.default_tag = person.filter_tags.first if person.filter_tags.length == 1
+                  entry.set_account(person, exclude: account_excluded)
 
+                  person.account.send_invites = options[:send_invites] if options.key?(:send_invites)
+
+                  unless options.dig(:exclude, :policy_groups) && !create
+                    person.account.policy_group_ids   = pgs.user_pg_ids(
+                      initial:         ini_pg_ids,
+                      final:           person.account.policy_group_ids
+                    )
+                  end
+
+                  person.account.permissions_custom = session.new_preset(person) unless !create && options.dig(:exclude, :abilities)
+
+                  if session.tagtree
+                    person.account.default_tag = session.tagtree.default_tag(*person.filter_tags)
+                  else
+                    tags = person.filter_tags
+                    person.account.default_tag = tags.first unless tags.length > 1
+                  end
+
+                end
 
                 creation.add(person) if create
                 update.add(person) unless create
 
-                # set supervisor
                 # set supervisor
                 unless options.dig(:exclude, :core) || options.dig(:exclude, :supervisor)
                   if !(sup_id = entry.supervisor_id)
@@ -54,9 +88,7 @@ module Eco
                     else
                       # delay setting supervisor if does not exit
                       supers.add(person) do |person|
-                        person.consolidate!
                         person.supervisor_id = sup_id
-                        person
                       end
                     end
                   end
@@ -65,6 +97,8 @@ module Eco
               end
 
             end
+
+
           end
 
         end

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

@@ -24,25 +24,50 @@ module Eco
               strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
               pgs = session.policy_groups
 
+              not_exist = []
+
               entries.each.with_index do |entry, i|
                 create = ! (person = people.find(entry, strict: strict_search))
 
                 if create && !options.dig(:include, :create)
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.name} (#{entry.email})")
+                  not_exist.push(entry);
                 else
                   person = session.new_person if create
 
                   unless options.dig(:exclude, :core)
-                    person.external_id   = entry.external_id
-                    person.name          = entry.name
-                    person.email         = entry.email unless options.dig(:exclude, :email)
+                    person.external_id   = entry.external_id   unless options.dig(:exclude, :external_id)
+                    person.name          = entry.name          unless options.dig(:exclude, :name)
+                    person.email         = entry.email         unless options.dig(:exclude, :email)
                     person.supervisor_id = entry.supervisor_id unless options.dig(:exclude, :supervisor)
-                    person.filter_tags   = entry.filter_tags || []
+                    person.filter_tags   = entry.filter_tags || [] unless options.dig(:exclude, :filter_tags)
                   end
 
                   unless options.dig(:exclude, :account)
-                    person.account = entry.account
-                    person.account&.send_invites = options[:send_invites] if options.key?(:send_invites)
+                    #person.account = entry.account
+                    if eaccount = entry.account
+                      person.account ||= {}
+                      person.account.default_tag          = eaccount.default_tag  unless options.dig(:exclude, :filter_tags)
+
+                      unless options.dig(:exclude, :policy_groups) && person.account.policy_group_ids
+                        person.account.policy_group_ids   = eaccount.policy_group_ids
+                      end
+
+                      unless options.dig(:exclude, :abilities) && (person.account.permissions_preset || person.account.permissions_custom)
+                        person.account.permissions_preset = eaccount.permissions_preset if eaccount.permissions_preset
+                        person.account.permissions_custom = eaccount.permissions_custom
+                      end
+                      person.account.login_provider_ids = eaccount.login_provider_ids if eaccount.login_provider_ids
+                      person.account.accept_eula        = eaccount.accept_eula if eaccount.accept_eula
+
+                      if eaccount.preferences
+                        person.account.doc["preferences"] = JSON.parse((eaccount.doc["preferences"] || {}).to_json)
+                      end
+
+                      person.account.starred_ids        = eaccount.starred_ids     if eaccount.landing_page_id
+                      person.account.landing_page_id    = eaccount.landing_page_id if eaccount.landing_page_id
+
+                      person.account&.send_invites = options[:send_invites] if options.key?(:send_invites)
+                    end
                   end
 
                   unless options.dig(:exclude, :details)
@@ -53,6 +78,15 @@ module Eco
                   update.add(person) unless create
                 end
               end
+
+              unless not_exist.empty?
+                session.logger.error("There were #{not_exist.length} entries of the back up that do not exist in the (filtered?) people manager")
+                session.logger.error("Some examples:")
+                not_exist.slice(0, 4).each_with_index do |entry, i|
+                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.name} (#{entry.email})")
+                end
+              end
+
             end
           end
 

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

@@ -13,6 +13,23 @@ module Eco
               end
               invite
             end
+
+            @cases.define("reinvite", type: :sync) do |entries, people, session, options, usecase|
+              invite = session.job_group("main").new("invite", usecase: usecase, type: :update, sets: :account)
+
+              users         = people.users
+              strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
+
+              entries.each_with_index do |entry, i|
+                if person = people.find(entry, strict: strict_search)
+                  person.account.send_invites = true
+                  invite.add(person)
+                else
+                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
+                end
+              end
+              
+            end
           end
 
         end

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

@@ -5,18 +5,9 @@ module Eco
         class UpdateCase < DefaultCase
 
           def process
-            #opts = CLI::Options.new do |p|
-            #  p.option :exclude, "Allows to exclude certain options"
-            #  p.suboption :exclude, :core, "Excludes core details from the update.", optional: true
-            #  p.suboption :exclude, :details, "Excludes schema details from the update.", optional: true
-            #  p.suboption :exclude, :account, "Excludes account details from the update.", optional: true
-            #  p.suboption :exclude, :email, "Excludes core email from the update.", optional: true
-            #  p.suboption :exclude, :supervisor, "Excludes supervisor_id from the update.", optional: true
-            #  p.suboption :exclude, :abilities, "Excludes the abilities from the update.", optional: true
-            #end
-
             @cases.define("update", type: :sync) do |entries, people, session, options, usecase|
               update   = session.job_group("main").new("update", usecase: usecase, type: :update, sets: [:core, :details, :account])
+              supers   = session.job_group("post").new("supers", usecase: usecase, type: :update, sets: :core)
 
               strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
               pgs = session.policy_groups
@@ -24,14 +15,16 @@ module Eco
               entries.each.with_index do |entry, i|
                 if person = people.find(entry, strict: strict_search)
 
-                  core_excluded = ["supervisor_id"]
-                  core_excluded.push("email") if options.dig(:exclude, :email)
-
                   unless options.dig(:exclude, :core)
                     ini_tags   = person.filter_tags || []
+
+                    core_attrs = ["name", "external_id", "email", "filter_tags"]
+                    core_excluded = core_attrs.map(&:to_sym).select {|attr| options.dig(:exclude, attr)}
+                    core_excluded.push("supervisor_id")
+
                     entry.set_core(person, exclude: core_excluded)
 
-                    if session.tagtree
+                    if session.tagtree && !options.dig(:exclude, :filter_tags)
                       person.filter_tags = session.tagtree.user_tags(
                         initial:          ini_tags,
                         final:            person.filter_tags,
@@ -40,31 +33,56 @@ module Eco
                       )
                     end
                   end
-                  
+
                   entry.set_details(person) unless options.dig(:exclude, :details)
 
                   unless options.dig(:exclude, :account)
                     ini_pg_ids = person.account&.policy_group_ids || []
-                    entry.set_account(person)
 
-                    person.account.policy_group_ids   = pgs.user_pg_ids(
-                      initial:         ini_pg_ids,
-                      final:           person.account.policy_group_ids
-                    )
+                    account_excluded = []
+                    account_excluded.push("policy_group_ids") if options.dig(:exclude, :policy_groups)
 
-                    person.account.permissions_custom = session.new_preset(person) unless options.dig(:exclude, :abilities)
+                    entry.set_account(person, exclude: account_excluded)
 
-                    if session.tagtree
-                      person.account.default_tag = session.tagtree.default_tag(*person.filter_tags)
-                    else
-                      tags = person.filter_tags
-                      person.account.default_tag = tags.first unless tags.length > 1
+                    person.account.send_invites = options[:send_invites] if options.key?(:send_invites)
+
+                    unless options.dig(:exclude, :policy_groups)
+                      person.account.policy_group_ids   = pgs.user_pg_ids(
+                        initial:         ini_pg_ids,
+                        final:           person.account.policy_group_ids
+                      )
                     end
 
-                    person.account&.send_invites = options[:send_invites] if options.key?(:send_invites)
+                    person.account.permissions_custom = session.new_preset(person) unless options.dig(:exclude, :abilities)
+
+                    unless options.dig(:exclude, :filter_tags)
+                      if session.tagtree
+                        person.account.default_tag = session.tagtree.default_tag(*person.filter_tags)
+                      else
+                        tags = person.filter_tags
+                        person.account.default_tag = tags.first unless tags.length > 1
+                      end
+                    end
 
                   end
                   update.add(person)
+
+                  # set supervisor
+                  unless options.dig(:exclude, :core) || options.dig(:exclude, :supervisor)
+                    if !(sup_id = entry.supervisor_id)
+                      person.supervisor_id = nil
+                    else
+                      if supervisor = people.person(id: sup_id, external_id: sup_id, email: sup_id)
+                        person.supervisor_id = supervisor.id
+                      else
+                        # delay setting supervisor if does not exit
+                        supers.add(person) do |person|
+                          person.supervisor_id = sup_id
+                        end
+                      end
+                    end
+                  end
+
                 else
                   session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
                 end

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

@@ -6,18 +6,50 @@ module Eco
 
           def process
             @cases.define("update-details", type: :sync) do |entries, people, session, options, usecase|
-              job = session.job_group("main").new("update", usecase: usecase, type: :update, sets: [:core, :details])
+              job    = session.job_group("main").new("update", usecase: usecase, type: :update, sets: [:core, :details])
+              supers = session.job_group("post").new("supers", usecase: usecase, type: :update, sets: :core)
 
               strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
 
               entries.each.with_index do |entry, i|
                 if person = people.find(entry, strict: strict_search)
-                  core_excluded = ["supervisor_id"]
-                  core_excluded.push("email") if options.dig(:exclude, :email)
-                  entry.set_core(person, exclude: core_excluded) unless options.dig(:exclude, :core)
+                  unless options.dig(:exclude, :core)
+                    core_attrs = ["name", "external_id", "email", "filter_tags"]
+                    core_excluded = core_attrs.map(&:to_sym).select {|attr| options.dig(:exclude, attr)}
+                    core_excluded.push("supervisor_id")
+
+                    entry.set_core(person, exclude: core_excluded) unless options.dig(:exclude, :core)
+
+                    if session.tagtree && !options.dig(:exclude, :filter_tags)
+                      person.filter_tags = session.tagtree.user_tags(
+                        initial:          ini_tags,
+                        final:            person.filter_tags,
+                        preserve_custom:  true,
+                        add_custom:       true
+                      )
+                    end
+                  end
+
                   entry.set_details(person)
 
                   job.add(person)
+
+                  # set supervisor
+                  unless options.dig(:exclude, :core) || options.dig(:exclude, :supervisor)
+                    if !(sup_id = entry.supervisor_id)
+                      person.supervisor_id = nil
+                    else
+                      if supervisor = people.person(id: sup_id, external_id: sup_id, email: sup_id)
+                        person.supervisor_id = supervisor.id
+                      else
+                        # delay setting supervisor if does not exit
+                        supers.add(person) do |person|
+                          person.supervisor_id = sup_id
+                        end
+                      end
+                    end
+                  end
+
                 else
                   session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
                 end

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

@@ -11,19 +11,21 @@ module Eco
               supers   = session.job_group("post").new("supers", usecase: usecase, type: :update, sets: :core)
 
               strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
-              pgs = session.policy_groups
+              pgs           = session.policy_groups
 
-              entries.each.with_index do |entry, i|
-                create = ! (person = people.find(entry, strict: strict_search))
-                person = session.new_person if create
-
-                core_excluded = ["supervisor_id"]
-                core_excluded.push("email") if options.dig(:exclude, :email) && !create
+              entries.each_with_index do |entry, i|
+                person = people.find(entry, strict: strict_search)
+                person = session.new_person if create = !person
 
                 unless options.dig(:exclude, :core) && !create
                   ini_tags   = person.filter_tags || []
-                  entry.set_core(person, exclude: core_excluded) 
-                  if session.tagtree
+
+                  core_attrs = ["name", "external_id", "email", "filter_tags"]
+                  core_excluded = core_attrs.map(&:to_sym).select {|attr| options.dig(:exclude, attr)}
+                  core_excluded.push("supervisor_id")
+
+                  entry.set_core(person, exclude: core_excluded)
+                  if session.tagtree && !options.dig(:exclude, :filter_tags)
                     person.filter_tags = session.tagtree.user_tags(
                       initial:          ini_tags,
                       final:            person.filter_tags,
@@ -37,14 +39,20 @@ module Eco
 
                 unless options.dig(:exclude, :account)
                   ini_pg_ids = person.account&.policy_group_ids || []
-                  entry.set_account(person)
+
+                  account_excluded = []
+                  account_excluded.push("policy_group_ids") if options.dig(:exclude, :policy_groups) && !create
+
+                  entry.set_account(person, exclude: account_excluded)
 
                   person.account.send_invites = options[:send_invites] if options.key?(:send_invites)
 
-                  person.account.policy_group_ids   = pgs.user_pg_ids(
-                    initial:         ini_pg_ids,
-                    final:           person.account.policy_group_ids
-                  )
+                  unless options.dig(:exclude, :policy_groups) && !create
+                    person.account.policy_group_ids   = pgs.user_pg_ids(
+                      initial:         ini_pg_ids,
+                      final:           person.account.policy_group_ids
+                    )
+                  end
 
                   person.account.permissions_custom = session.new_preset(person) unless !create && options.dig(:exclude, :abilities)
 
@@ -70,9 +78,7 @@ module Eco
                     else
                       # delay setting supervisor if does not exit
                       supers.add(person) do |person|
-                        person.consolidate!
                         person.supervisor_id = sup_id
-                        person
                       end
                     end
                   end

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

@@ -28,18 +28,32 @@ ASSETS.cli.config do |cnf|
     options_set.add("-exclude-core") do |options|
       options.deep_merge!(exclude: {core: true})
     end
+    options_set.add("-exclude-filter-tags") do |options|
+      options.deep_merge!(exclude: {filter_tags: true})
+    end
+    options_set.add("-exclude-external-id") do |options|
+      options.deep_merge!(exclude: {external_id: true})
+    end
     options_set.add("-exclude-supervisor") do |options|
       options.deep_merge!(exclude: {supervisor: true})
     end
     options_set.add("-exclude-email") do |options|
       options.deep_merge!(exclude: {email: true})
     end
+    options_set.add("-exclude-name") do |options|
+      options.deep_merge!(exclude: {name: true})
+    end
+
     options_set.add("-exclude-details") do |options|
       options.deep_merge!(exclude: {details: true})
     end
+
     options_set.add("-exclude-account") do |options|
       options.deep_merge!(exclude: {account: true})
     end
+    options_set.add("-exclude-policy-groups") do |options|
+      options.deep_merge!(exclude: {policy_groups: true})
+    end
     options_set.add("-exclude-abilities") do |options|
       options.deep_merge!(exclude: {abilities: true})
     end

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

@@ -37,6 +37,7 @@ ASSETS.cli.config do |cnf|
     cases.add("-create-details-from", :sync, case_name: "create-details")
     cases.add("-update-details-from", :sync, case_name: "update-details")
     cases.add("-reinvite", :transform, case_name: "reinvite")
+    cases.add("-reinvite-from", :sync, case_name: "reinvite")
     cases.add("-set-default-tag", :transform, case_name: "set-default-tag")
 
     cases.add("-recover-db-from", :sync, case_name: "recover-db") do |input, people, session, options|

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "1.0.5"
+  VERSION = "1.0.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
 platform: ruby
 authors:
 - Oscar Segura