eco-helpers 1.5.1 → 1.5.2

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

@@ -0,0 +1,114 @@
+module Eco
+  module API
+    class UseCases
+      class DefaultCases
+        class UpsertCase < DefaultCase
+
+          def process
+            @cases.define("upsert", type: :sync) do |entries, people, session, options, usecase|
+              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)
+
+              strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
+              pgs           = session.policy_groups
+
+              if session.config.people.default_usergroup?
+                def_id  = pgs.to_id(session.config.people.default_usergroup)
+              end
+
+              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 || []
+
+                  core_excluded    = ["supervisor_id"]
+
+                  unless create
+                    core_attrs     = ["name", "external_id", "email", "filter_tags"]
+                    core_excluded += core_attrs.map.select {|attr| options.dig(:exclude, attr.to_sym)}
+                  end
+
+                  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)
+                  add_account = !person.account
+                  ini_pg_ids  = person.account&.policy_group_ids || []
+
+                  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)
+
+                  unless options.dig(:exclude, :policy_groups) && !create
+                    end_pg_ids = person.account.policy_group_ids || []
+
+                    if add_account && def_id && !entry.policy_group_ids?
+                      # on account creation, if missing policy_group_ids column in the input
+                      # use default_usergroup, if it's defined
+                      end_pg_ids = [def_id]
+                    end
+
+                    # avoid false updates by preserving the original order
+                    person.account.policy_group_ids   = pgs.user_pg_ids(
+                      initial:         ini_pg_ids,
+                      final:           end_pg_ids
+                    )
+                  end
+
+                  person.account.permissions_custom = session.new_preset(person) unless !create && options.dig(:exclude, :abilities)
+
+                  unless options.dig(:exclude, :filter_tags) || 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
+
+                creation.add(person) if create
+                update.add(person) unless create
+
+                # 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
+
+        end
+      end
+    end
+  end
+end

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

@@ -12,6 +12,8 @@ module Eco
           end
         end
 
+        extend Eco::API::Common::ClassHelpers
+        
         @types = [:import, :filter, :transform, :sync, :error_handler, :export, :other]
 
         class << self

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

@@ -67,10 +67,10 @@ module Eco
         end
 
         # Helper to build a `Hash` of symbol keys or `Array` with params to do callbacks.
-        def params(keyed: false)
+        def params(keyed: false, all: false)
           kargs = {}
-          kargs.merge!(input:    input)  if input_required?
-          kargs.merge!(people:  people)  if people_required?
+          kargs.merge!(input:    input)  if input_required?  || all
+          kargs.merge!(people:  people)  if people_required? || all
           kargs.merge!(session: session, options: options)
           keyed ? kargs : kargs.values
         end

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

@@ -2,70 +2,40 @@ module Eco
   module API
     class UseCases
       class DefaultCases < Eco::API::UseCases
-
-        def initialize(*args)
-          super(*args)
-          define_defaults
-        end
-
-        private
-
-        def define_defaults
-          ResetLandingPageCase.new(self).process
-          ToCsvCase.new(self).process
-          ToCsvDetailedCase.new(self).process
-          CodesToTagsCase.new(self).process
-          EmailAsIdCase.new(self).process
-          NewIdCase.new(self).process
-          NewEmailCase.new(self).process
-          SwitchSupervisorCase.new(self).process
-          SetSupervisorCase.new(self).process
-          UpdateDetailsCase.new(self).process
-          CreateDetailsCase.new(self).process
-          CreateDetailsWithSupervisorCase.new(self).process
-          ReinviteCase.new(self).process
-          DeleteCase.new(self).process
-          RemoveAccountCase.new(self).process
-          TransferAccountCase.new(self).process
-          RecoverDBCase.new(self).process
-          RefreshPresets.new(self).process
-          Refresh.new(self).process
-          ChangeEMailCase.new(self).process
-          SetDefaultTagCase.new(self).process
-          CreateCase.new(self).process
-          AppendUsergroupsCase.new(self).process
-          UpdateCase.new(self).process
-          UpsertCase.new(self).process
-          HrisCase.new(self).process
-        end
+        autoloads_children_of "Eco::API::Common::Loaders::UseCase"
+        autoload_namespace    "Eco::API::UseCases::DefaultCases"
       end
     end
   end
 end
 
-require_relative 'default_cases/reset_landing_page_case'
-require_relative 'default_cases/to_csv_case'
-require_relative 'default_cases/to_csv_detailed_case'
+require_relative 'default_cases/append_usergroups_case'
+require_relative 'default_cases/change_email_case'
 require_relative 'default_cases/codes_to_tags_case'
+require_relative 'default_cases/create_case'
+require_relative 'default_cases/create_details_case'
+require_relative 'default_cases/create_details_with_supervisor_case'
+require_relative 'default_cases/delete_trans_case'
+require_relative 'default_cases/delete_sync_case'
 require_relative 'default_cases/email_as_id_case'
+require_relative 'default_cases/hris_case'
 require_relative 'default_cases/new_id_case'
 require_relative 'default_cases/new_email_case'
+require_relative 'default_cases/org_data_convert_case'
+require_relative 'default_cases/refresh_abilities_case'
+require_relative 'default_cases/refresh_case'
+require_relative 'default_cases/reinvite_trans_case'
+require_relative 'default_cases/reinvite_sync_case'
+require_relative 'default_cases/remove_account_trans_case'
+require_relative 'default_cases/remove_account_sync_case'
+require_relative 'default_cases/reset_landing_page_case'
+require_relative 'default_cases/restore_db_case'
+require_relative 'default_cases/set_default_tag_case'
 require_relative 'default_cases/set_supervisor_case'
 require_relative 'default_cases/switch_supervisor_case'
-require_relative 'default_cases/update_details_case'
-require_relative 'default_cases/create_details_case'
-require_relative 'default_cases/create_details_with_supervisor_case'
-require_relative 'default_cases/reinvite_case'
-require_relative 'default_cases/delete_case'
-require_relative 'default_cases/remove_account_case'
+require_relative 'default_cases/to_csv_case'
+require_relative 'default_cases/to_csv_detailed_case'
 require_relative 'default_cases/transfer_account_case'
-require_relative 'default_cases/refresh_case'
-require_relative 'default_cases/refresh_presets_case'
-require_relative 'default_cases/recover_db_case'
-require_relative 'default_cases/change_email_case'
-require_relative 'default_cases/set_default_tag_case'
-require_relative 'default_cases/create_case'
-require_relative 'default_cases/append_usergroups_case'
 require_relative 'default_cases/update_case'
+require_relative 'default_cases/update_details_case'
 require_relative 'default_cases/upsert_case'
-require_relative 'default_cases/hris_case'

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

@@ -1,36 +1,15 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class AppendUsergroupsCase < DefaultCase
+class Eco::API::UseCases::DefaultCases::AppendUsergroupsCase < Eco::API::Common::Loaders::UseCase
+  name "append-usergroups"
+  type :sync
 
-          def process
-            @cases.define("append-usergroups", type: :sync) do |entries, people, session, options, usecase|
-              update   = session.job_group("main").new("update", usecase: usecase, type: :update, sets: [:core, :details, :account])
+  def main(entries, people, session, options, usecase)
+    micro    = session.micro
+    update   = session.new_job("main", "update", :update, usecase)
 
-              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|
-                if person = people.find(entry, strict: strict_search)
-                  if person.account
-                    ini_pg_ids = person.account&.policy_group_ids || []
-                    add        = entry.internal_entry["policy_group_ids"].to_s.split("|").compact
-                    person.account.policy_group_ids = (ini_pg_ids | add).uniq
-
-                    person.account.permissions_custom = session.new_preset(person) unless options.dig(:exclude, :abilities)
-                    update.add(person)
-                  end
-                else
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
-                end
-              end
-            end
-
-          end
-
-        end
-      end
+    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
+      update.add(person)
+      micro.append_usergroups(entry, person, options)
     end
   end
+
 end

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

@@ -1,52 +1,28 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class ChangeEMailCase < DefaultCase
-
-          def process
-            @cases.define("change-email", type: :sync) do |entries, people, session, options, usecase|
-              remove      = session.job_group("main").new("remove account", usecase: usecase, type: :update, sets: :account)
-              change      = session.job_group("main").new("change email", usecase: usecase, type: :update, sets: :core)
-              add_account = session.job_group("post").new("add account", usecase: usecase, type: :update, sets: :account)
-
-              strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
-
-              entries.each.with_index do |entry, i|
-                person = people.find(entry, strict: strict_search)
-
-                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.to_s.strip.downcase
-
-                    super_id      = person.supervisor_id
-                    s_account_doc = person.account&.doc
-                    account_doc   = s_account_doc ? JSON.parse(s_account_doc.to_json) : nil
-
-                    person.account = nil
-                    remove.add(person)
-
-                    new_email = entry.email
-                    change.add(person) do |person|
-                      person.email = new_email
-                    end
-
-                    add_account.add(person) do |person|
-                      if account_doc
-                        person.account = account_doc
-                      end
-                      person.supervisor_id = super_id
-                    end
-                  end
-
-                end
-              end
-            end
-          end
-
+class Eco::API::UseCases::DefaultCases::ChangeEMailCase < Eco::API::Common::Loaders::UseCase
+  name "change-email"
+  type :sync
+  
+  # Target people with non-up-to-date emails will be updated to the new email
+  def main(entries, people, session, options, usecase)
+    micro    = session.micro
+    remove   = session.new_job("main", "remove account", :update, usecase, :account)
+    change   = session.new_job("main", "change email",   :update, usecase, :core)
+    invite   = session.new_job("post", "add account",    :update, usecase, [:core, :account])
+
+    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
+      if entry.email != person.email
+        super_id      = person.supervisor_id
+        s_account_doc = person.account&.doc
+        account_doc   = s_account_doc ? JSON.parse(s_account_doc.to_json) : nil
+
+        remove.add(person) {|person| person.account = nil        }
+        change.add(person) {|person| person.email   = entry.email}
+        invite.add(person) do |person|
+          person.account       = account_doc if account_doc
+          person.supervisor_id = super_id
         end
       end
     end
   end
+
 end

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

@@ -1,47 +1,60 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class CodesToTagsCase < DefaultCase
-
-          def process
-            @cases.define("codes-to-tags-from", type: :other) do |session, options, usecase|
-              raise "You have not defined a tagtree for the organisation" unless session.tagtree
-
-              unless mapper  = session.config.location_codes && session.config.locations_mapper
-                raise "No filter_tags parser, nor location mappings are present"
-              end
-
-              to_tag = Proc.new do |code|
-                if mapper.external?(code)
-                  mapper.to_internal(code)
-                elsif session.tagtree.tag?(code)
-                  code.upcase
-                else
-                  session.logger.warn("Unknown Location Code: '#{code}'")
-                  nil
-                end
-              end
-
-              codes_column = options.dig(:other, :file, :codes_column)
-              input_file   = options.dig(:other, :file, :name)
-              output_file  = "mapped_#{File.basename(input_file).gsub(/\s/, "")}"
-
-              csv_table = Eco::CSV.read(input_file)
-
-              csv_table.add_column("ecoPortalTag").tap do |csv_table|
-                csv_table.each do |row|
-                  row["ecoPortalTag"] = to_tag.call(row[codes_column])
-                end
-
-                File.open(output_file, "w") {|fd| fd << csv_table.to_csv}
-              end
-              exit
-            end
-          end
-
-        end
+class Eco::API::UseCases::DefaultCases::CodesToTagsCase < Eco::API::Common::Loaders::UseCase
+  name "codes-to-tags-from"
+  type :other
+
+  def codes_to_tags
+    raise "You have not defined a tagtree for the organisation" unless session.tagtree
+    csv_table = Eco::CSV.read(input_file)
+
+    csv_table.add_column("ecoPortalTag").tap do |csv_table|
+      csv_table.each do |row|
+        row["ecoPortalTag"] = to_tag(row[codes_column])
       end
+
+      File.open(output_file, "w") {|fd| fd << csv_table.to_csv}
     end
   end
+
+  def main(session, options, usecase)
+    @session = session
+    @options = options
+    codes_to_tags
+    exit
+  end
+
+  private
+
+  def to_tag(code)
+    if mapper.external?(code)
+      mapper.to_internal(code)
+    elsif @session.tagtree.tag?(code)
+      code.upcase
+    else
+      @session.logger.warn("Unknown Location Code: '#{code}'")
+      nil
+    end
+  end
+
+  def mapper
+    unless mapper ||= @session.config.location_codes && @session.config.locations_mapper
+      raise "No filter_tags parser, nor location mappings are present"
+    end
+  end
+
+  def codes_column
+    @codes_column ||= @options.dig(:other, :file, :codes_column)
+  end
+
+  def input_file
+    @input_file   ||= @options.dig(:other, :file, :name)
+  end
+
+  def output_file
+    "mapped_#{clean_file_name(input_file)}"
+  end
+
+  def clean_file_name(filename)
+    File.basename(filename).gsub(/\s/, "")
+  end
+
 end