eco-helpers 3.0.20 → 3.0.22

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

@@ -1,28 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Helper to preserve the original filter tags.
-      # @note
-      #   1. It only works if the original value of `filter_tags` was **not** empty
-      # @param person [Ecoportal::API::V1::Person] the person we want to update, carrying the changes to be done.
-      # @param options [Hash] the options.
-      # @param keep_new [Boolean] tells if it should keep the new tags or get rid of them.
-      # @return [Array<String>] the final value of `filter_tags`.
-      def preserve_filter_tags(person, _options, keep_new: false)
-        person.filter_tags.tap do
-          next unless person.as_update.key?('filter_tags')
-          next unless (original = person.original_doc['filter_tags'])
-          next if original.empty?
-
-          if keep_new
-            person.filter_tags += original
-          else
-            person.filter_tags  = original
-          end
-
-          return person.filter_tags
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Helper to preserve the original `policy_group_ids`.
-      # @note
-      #   1. It only works if the original value of `policy_group_ids` was **not** empty
-      # @param person [Ecoportal::API::V1::Person] the person we want to update, carrying the changes to be done.
-      # @param options [Hash] the options.
-      # @param keep_new [Boolean] tells if it should keep the new policy groups or get rid of them.
-      # @return [String] the final value of `policy_group_ids`.
-      def preserve_policy_groups(person, _options, keep_new: false)
-        return unless (account = person.account)
-
-        account.policy_group_ids.tap do
-          next unless account.as_update.key?("policy_group_ids")
-          next unless (original = person.original_doc.dig("account", "policy_group_ids"))
-          next if original.empty?
-
-          if keep_new
-            person.account.policy_group_ids += original
-          else
-            person.account.policy_group_ids  = original
-          end
-
-          return account.policy_group_ids
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # When the input data, or `entry`, does not provide the `default_tag`,
-      # it sets the `default_tag` of the user following some criteria
-      # @note it assumes `default_tag` has been already set to `person.account`
-      # @param entry [PersonEntry] the input entry with the data we should set on person.
-      # @param person [Ecoportal::API::V1::Person] the person we want to update, carrying the changes to be done.
-      # @param options [Hash] the options
-      def refresh_default_tag(entry, person, options)
-        return unless person.account
-        return if options.dig(:exclude, :account)
-        return if options.dig(:exclude, :filter_tags)
-        return if options.dig(:exclude, :default_tag)
-        return if entry&.default_tag?
-
-        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
-  end
-end

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

@@ -1,18 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # @param entry [PersonEntry] the input entry with the data we should set on person.
-      # @param person [Ecoportal::API::V1::Person] the person we want to update, carrying the changes to be done.
-      # @param options [Hash] the options.
-      def set_account(entry, person, options)
-        return if options.dig(:exclude, :account)
-
-        entry.set_account(person, exclude: micro.account_excluded(person, options))
-
-        person.account.send_invites = options[:send_invites] if options.key?(:send_invites)
-        micro.refresh_default_tag(entry, person, options)
-        micro.fix_default_group(entry, person, options)
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Sets all the core details, but the supervisor.
-      # @note `supervisor_id` requires a special treatment, and therefore is always excluded.
-      # @param entry [PersonEntry] the input entry with the data we should set on person.
-      # @param person [Ecoportal::API::V1::Person] the person we want to update, carrying the changes to be done.
-      # @param options [Hash] the options
-      def set_core(entry, person, options)
-        return if options.dig(:exclude, :core) && !person.new?
-
-        entry.set_core(person, exclude: micro.core_excluded(person, options))
-        micro.fix_filter_tags(person, options)
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Sets all the core details, but the supervisor.
-      # @note `supervisor_id` requires a special treatment, and therefore is always excluded.
-      # @param entry [PersonEntry] the input entry with the data we should set on 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 supers_job [Eco::API::Session::Batch::Job] the job that will run the supers .
-      # @param options [Hash] the options.
-      def set_core_with_supervisor(entry, person, people, supers_job, options)
-        return if options.dig(:exclude, :core) && !person.new?
-
-        micro.set_core(entry, person, options)
-
-        return unless entry.supervisor_id?
-
-        micro.set_supervisor(
-          person,
-          entry.supervisor_id,
-          people,
-          options
-        ) do |unknown_id|
-          # delay setting supervisor if does not exit
-          supers_job.add(person) do |pers|
-            micro.set_supervisor(pers, unknown_id, people, options)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Unique access point to set the `supervisor_id` value on a person.
-      # @note
-      #   - It prevents the basic cyclic supervisor case (supervisor to be supervisor of themselves)
-      # @param person [Ecoportal::API::V1::Person] the person we want to update, carrying the changes to be done.
-      # @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(person, sup_id, people, options)
-        return false if options.dig(:exclude, :core) || options.dig(:exclude, :supervisor)
-        return false if sup_id && ((person.id == sup_id) || (person.external_id == sup_id))
-
-        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
-            descrease_subordinates(cur_super)
-          elsif new_super && (id = new_super.id)
-            set_supervisor(new_super, nil, people, options) if new_super_direct_cyclic?(person, new_super)
-            person.supervisor_id = id
-            descrease_subordinates(cur_super)
-            increase_subordinates(new_super)
-          elsif !block_given?
-            descrease_subordinates(cur_super)
-            person.supervisor_id = sup_id
-          elsif block_given?
-            yield(sup_id)
-          end
-        end
-      end
-
-      private
-
-      def new_super_direct_cyclic?(person, new_super)
-        return false unless new_super.is_a?(Ecoportal::API::V1::Person)
-        return false if new_super.supervisor_id.nil?
-        return true  if person.id == new_super.id
-        return true  if new_super.supervisor_id == person.id
-        return true  if new_super.supervisor_id == person.external_id
-
-        false
-      end
-
-      def descrease_subordinates(person, by = 1)
-        return unless person.is_a?(Ecoportal::API::V1::Person)
-
-        person.subordinates -= by
-      end
-
-      def increase_subordinates(person, by = 1)
-        return unless person.is_a?(Ecoportal::API::V1::Person)
-
-        person.subordinates += by
-      end
-    end
-  end
-end

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

@@ -1,129 +0,0 @@
-# rubocop:disable Metrics/BlockNesting, Layout/LineLength
-module Eco
-  module API
-    class MicroCases
-      # Frees up `target_email` from an account not present in this org.
-      #   Allows to force `target_email` on the current user's account.
-      #   - If the person does not have account, this case will not do anything.
-      #   - If `original_doc["account"]` is `nil` (no account on server side), this case will not do anything.
-      #   - If the `target_email` and the `current_email` are the same or empty, this case will not do anything.
-      # @note
-      #   - **It does not do the final update to the server to the `target_email`**.
-      #     You will need to do this part yourself.
-      #   - You would call this function only when you got an error of `email already taken`.
-      #   - If the `target_email` is associated to a user in the same org, this will fail.
-      # @param person [Ecoportal::API::V1::Person] the person we want to update,
-      #   carrying the changes to be done.
-      # @param dest_email [String, Proc] the email that we will move the other account to,
-      #   when we free up `target_email`.
-      # @param target_email [String] the email that we want to free up from another account and bring to ours.
-      #   If it's empty, the `person.email` will be used instead.
-      # @param options [Hash] the options.
-      # @param current_email [String] the email that the person's account is currently linked.
-      #   As the current email should be associated with this person's account on server side,
-      #   we use `original_doc["email"]`.
-      # @param context [String] main core part of logs. Provides context to the logs.
-      def take_email_from_account(person, dest_email:, target_email: nil, options: {}, context: "Session")
-        return false if options.dig(:exclude, :account)
-        return false unless (account     = person.account)
-        return false unless (had_account = person.original_doc["account"]) # rubocop:disable Lint/UselessAssignment
-
-        target_email  ||= person.email
-        account_email   = person.original_doc["email"]
-
-        return false unless target_email != account_email
-        return false if account_email.to_s.strip.empty?
-        return false if target_email.to_s.strip.empty?
-
-        if dest_email.is_a?(String)
-          return false unless target_email != dest_email
-          return false unless dest_email   != account_email
-          return false if dest_email.to_s.strip.empty?
-        end
-
-        account_json = _take_email_account_json(account)
-        person.email = account_email
-
-        if (success = _take_email_remove_account!(person, context: context))
-          if (success = _take_email_acquire_account!(person, target_email, account: {}, context: context))
-            if (success = _take_email_email_free_up!(person, dest_email: dest_email, context: context))
-              if (success = _take_email_remove_account!(person, context: context))
-                # Bring back the original account
-                if (success = _take_email_acquire_account!(person, account_email, account: account_json, context: context)) # rubocop:disable Style/SoleNestedConditional
-                  success      = true
-                  person.email = target_email
-                end
-              end
-            else # free up target email
-              # restore
-              reverted = false
-              if reverted ||= _take_email_remove_account!(person, context: context)
-                reverted ||= _take_email_acquire_account!(person, account_email, account: account_json, context: context)
-              end
-
-              unless reverted
-                msg = "Could not revert back to the original account #{person.identify}"
-                log(:debug) { msg }
-                puts msg
-              end
-
-              success = false
-            end
-          else # aquire other account
-            # restore
-            unless _take_email_acquire_account!(person, account_email, account: account_json, context: context)
-              msg = "Could not bring back the original account that "
-              msg << "we want to update the email to '#{target_email}' #{person.identify}"
-              log(:debug) { msg }
-              puts msg
-            end
-
-            success = false
-          end
-        end
-
-        success
-      end
-
-      private
-
-      def _take_email_account_json(account)
-        JSON.parse(account.to_json).tap do |hash|
-          hash.delete("user_id")
-          hash.delete("permissions_merged")
-          hash.delete("permissions_preset")
-          hash.delete("prefilter")
-
-          if (pref = hash["preferences"])
-            hash["preferences"] = pref.reject do |attr, _value|
-              attr.start_with?("kiosk")
-            end
-          end
-        end
-      end
-
-      # Bring the account of the `target_email` taken, so we can change the email of this account
-      def _take_email_acquire_account!(person, target_email, account: {}, context: "Session")
-        person.account = account
-        person.account.send_invites = false
-        person.email = target_email
-        micro.person_update!(person, reason: "bring account with email '#{target_email}'", context: context)
-      end
-
-      # Free up the email (`target_email`) of the account that has it taken to `dest_email`
-      def _take_email_email_free_up!(person, dest_email:, target_email: nil, context: "Session")
-        target_email ||= person.email
-        person.email   = dest_email.is_a?(Proc)? dest_email.call(target_email) : dest_email
-        reason = "free up email '#{target_email}', by moving account to '#{person.email}'"
-        micro.person_update!(person, reason: reason, context: context)
-      end
-
-      def _take_email_remove_account!(person, context: "Session")
-        person.account = nil
-        micro.person_update!(person, reason: "remove account", context: context)
-      end
-    end
-  end
-end
-
-# rubocop:enable Metrics/BlockNesting, Layout/LineLength

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

@@ -1,103 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Finds each **entry** of `entries` in `people` and runs a block.
-      # @note
-      #  - it also links to `person.entry` the input data entry.
-      # @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, append_created: true)
-        @_skip_all_multiple_results = false
-        people_copy = people.newFrom(people.to_a)
-
-        entries.each_with_object([]) do |entry, scoped|
-          begin
-            person   = people_copy.find(entry, strict: micro.strict_search?(options))
-            person ||= session.new_person.tap do |pers|
-              people << pers if append_created
-            end
-          rescue Eco::API::Organization::People::MultipleSearchResults => e
-            unless @_skip_all_multiple_results
-              msg    = "\n * When searching this Entry: #{entry.to_s(:identify)}"
-              person = _with_each_prompt_to_select_user(e.append_message(msg), entry: entry)
-            end
-          end
-
-          next unless person
-
-          person.entry = entry
-          yield(entry, person) if block_given?
-
-          scoped << person
-        end.then do |all_people|
-          people.newFrom all_people.uniq
-        end
-      end
-
-      private
-
-      def _with_each_prompt_to_select_user(error, entry: nil, increase_count: true) # rubocop:disable Metrics/AbcSize
-        unless error.is_a?(Eco::API::Organization::People::MultipleSearchResults)
-          raise "Expecting Eco::API::Organization::People::MultipleSearchResults. Given: #{error.class}"
-        end
-
-        @_with_each_prompts  = 0 unless instance_variable_defined?(:@_with_each_prompts)
-        @_with_each_prompts += 1 if increase_count
-
-        lines  = []
-        lines << "\n(#{@_with_each_prompts}) #{error}\n"
-        lines << "  #index   - Select the correct person by its number index among the list above."
-        lines << "  (I)      - Just Skip/Ignore this one. I will deal with that input entry in another launch."
-        lines << "  (A)      - Ignore all the rest of input entries with this problem."
-        lines << "  (C)      - Create a new person."
-        lines << "  (B)      - Just break this script. I need to change the input file :/"
-
-        prompt_user("Type one option (#number/I/A/C/B):", explanation: lines.join("\n"), default: "I") do |res|
-          res = res.upcase
-
-          if res.start_with?("I")
-            log(:info) { "Ignoring entry... #{entry&.to_s(:identify)}" }
-
-            nil
-          elsif res.start_with?("A")
-            log(:info) {
-              "All input entries with this same issue will be ignored for this launch"
-            }
-
-            @_skip_all_multiple_results = true
-            nil
-          elsif res.start_with?("C")
-            log(:info) {
-              "Creating new person...#{"for entry #{entry.to_s(:identify)}" if entry}"
-            }
-
-            session.new_person
-          elsif res.start_with?("B")
-            raise error
-          elsif res && !res.empty? && (pos = res.to_i rescue nil) && (pos < error.candidates.length) # rubocop:disable Style/RescueModifier
-            error.candidate(pos).tap do |person|
-              log(:info) { "Thanks!! You selected #{person.identify}" }
-              sleep(1.5)
-            end
-          else
-            if pos.is_a?(Numeric) && (pos >= error.candidates.length)
-              print "#{pos} is not a number in the range. "
-            else
-              print "#{res} is not an option. "
-            end
-
-            puts "Please select one of the offered options..."
-            sleep(1)
-            _with_each_prompt_to_select_user(error, increase_count: false, entry: entry)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Detects who has left the organization and `yield` s them one by one to the given block
-      # @note
-      #   - To be used only when the input file is the full DB
-      #   - The `Entries#find` method. If the people manager entry does not have `external_id`,
-      #     but has a matching `email` wiht some input entry (row), it won't be identified as a leaver.
-      # @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.
-      # @yield [person] gives each person of `people` that is not present in `entries`.
-      # @yieldparam person [Ecoportal::API::V1::Person] the person that leaves the org.
-      # @return [Eco::API::Organization::People] the leavers.
-      def with_each_leaver(entries, people, options)
-        leavers = people.map do |person|
-          unless entries.find(person, strict: micro.strict_search?(options))
-            yield(person) if block_given?
-            person
-          end
-        end.compact
-
-        people.newFrom leavers
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Finds those in `entries` that already exist in the organization (`people`) and `yield` s them one by one to the given block.
-      # @note
-      #   - it also links to `person.entry` the input data `entry`.
-      # @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 log_starter [Boolean] log error message if an `entry` does not have match in `people`.
-      # @yield [entry, person] gives each **found** `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 **found** person.
-      # @return [Eco::API::Organization::People] the found people.
-      def with_each_present(entries, people, options, log_starter: false)
-        found = []
-        micro.with_each(entries, people, options) do |entry, person|
-          if person.new?
-            if log_starter
-              log(:error) {
-                "This person does not exist: #{entry.to_s(:identify)}"
-              }
-            end
-
-            next
-          end
-
-          found << person
-          yield(entry, person) if block_given?
-        end
-
-        people.newFrom found
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Detects who in the `entries` is new in the organization and `yield` s them one by one to the given block.
-      # @note
-      #   - it also links to `person.entry` the input data `entry`.
-      # @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 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, append_created: true)
-        starters = []
-        micro.with_each(entries, people, options, append_created: append_created) do |entry, person|
-          unless person.new?
-            if log_present
-              log(:error) {
-                "This person (id: '#{person.id}') already exists: #{entry.to_s(:identify)}"
-              }
-            end
-
-            next
-          end
-
-          starters << person
-          yield(entry, person) if block_given?
-        end
-
-        people.newFrom starters
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Finds all the subordinates of `supervisor`.
-      # @note if `supervisor` is `nil`, it will return all people with no supervisor.
-      # @param supervisor [String, Ecoportal::API::V1::Person, Hash] the `supervisor` or the `id` / `external_id` thereof.
-      # @param people [Eco::API::Organization::People] target existing _People_ of the current update.
-      # @yield [subordinate] block that does some stuff with `subordinate`.
-      # @yieldparam subordinate [Ecoportal::API::V1::Person] each one of the suborinates of `supervisor`.
-      # @return [Eco::API::Organization::People] the **subordinates** of `supervisor`.
-      def with_each_subordinate(supervisor, people)
-        people.supervisor_id(_person_id(supervisor, people)).tap do |subordinates|
-          subordinates.each do |subordinate|
-            yield(subordinate) if block_given?
-          end
-        end
-      end
-
-      private
-
-      def _person_id(value, people)
-        case value
-        when Hash
-          _person_id(value["id"] || value["external_id"], people)
-        when Ecoportal::API::V1::Person
-          _person_id(value.id    || value.external_id, people)
-        when String
-          micro.with_supervisor(value, people)&.id
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-module Eco
-  module API
-    class MicroCases
-      # Finds the supervisor among `people` by using the `supervisor_id` of `value`.
-      # @param value [String, Ecoportal::API::V1::Person, Hash] the subordinate person,
-      #   or the unique identifier of the supervisor to be found (preferably the `external_id`).
-      # @param people [Eco::API::Organization::People] target existing _People_ of the current update.
-      # @param strict [Boolean] specifies if the search should be `strict` (see {Eco::API::Organization::People#person}).
-      # @yield [supervisor] block that does some stuff with supevisor.
-      # @yieldparam supervisor [Ecoportal::API::V1::Person] the person object of the supervisor, or `nil` if not found.
-      # @return [nil, Ecoportal::API::V1::Person] found `supervisor` of `value`.
-      def with_supervisor(value, people, strict: false)
-        if sup_id = with_supervisor_supervisor_id(value)
-          people.person(id: sup_id, external_id: sup_id, email: sup_id, strict: strict)
-        end.tap do |supervisor|
-          yield(supervisor) if block_given?
-        end
-      end
-
-      private
-
-      def with_supervisor_supervisor_id(value)
-        return nil if value.to_s.strip.empty?
-        case
-        when value.respond_to?(:supervisor_id)
-          value.supervisor_id
-        when value.is_a?(Hash)
-          value["supervisor_id"]
-        else
-          value
-        end
-      end
-    end
-  end
-end