eco-helpers 1.5.1 → 1.5.6

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

@@ -1,28 +1,14 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class NewIdCase < DefaultCase
-
-          def process
-            @cases.define("new-id", type: :sync) do |entries, people, session, options, usecase|
-              job = session.job_group("main").new("update", 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)
-                  person.external_id = entry.external_id
-                  job.add(person)
-                else
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
-                end
-              end
-            end
-          end
-
-        end
-      end
+class Eco::API::UseCases::DefaultCases::NewIdCase < Eco::API::Common::Loaders::UseCase
+  name "new-id"
+  type :sync
+
+  def main(entries, people, session, options, usecase)
+    micro    = session.micro
+    update   = session.new_job("main", "update", :update, usecase, :core)
+    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
+      update.add(person)
+      person.external_id = entry.external_id
     end
   end
+
 end

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

@@ -0,0 +1,14 @@
+class Eco::API::UseCases::DefaultCases::NewIdCase < Eco::API::Common::Loaders::UseCase
+  name "new-id"
+  type :sync
+
+  def main(entries, people, session, options, usecase)
+    micro    = session.micro
+    update   = session.new_job("main", "update", :update, usecase, :core)
+    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
+      update.add(person)
+      person.external_id = entry.external_id
+    end
+  end
+
+end

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

@@ -0,0 +1,101 @@
+class Eco::API::UseCases::DefaultCases::OrgDataConvertCase < Eco::API::Common::Loaders::UseCase
+  name "org-data-convert"
+  type :import
+
+  attr_reader :session, :options
+
+  def org_data_convert(people)
+    pp "Going to convert data from '#{source_enviro}' to '#{ASSETS.active_config}'"
+    puts "\n"
+    people.each.with_index do |person, i|
+      if (i % 10 == 0)
+        percent = i * 100 / people.length
+        print "Processing: #{percent.round}% (#{i}/#{people.length} entries)\r"
+        $stdout.flush
+      end
+
+      person.id = nil
+      details_convert!(person)
+      account_convert!(person)
+    end
+    people
+  end
+
+  def main(people, session, options, usecase)
+    @options = options
+    @session = session
+    org_data_convert(people)
+  end
+
+  private
+
+  def account_convert!(person)
+    if account = person.account
+      account.policy_group_ids = policy_groups_convert(account.policy_group_ids)
+      account.doc.tap do |doc|
+        ["login_provider_ids", "starred_ids", "landing_page_id"].map do |attr|
+          doc.delete(attr)
+        end
+      end
+    end
+  end
+
+  def details_convert!(person)
+    if person.details
+      person.details.as_json.tap do |details_doc|
+        details_doc["schema_id"] = @session.schema.id
+        person.add_details(@session.schema)
+        person.details = details_doc
+      end
+    end
+  end
+
+  def policy_groups_convert(ids)
+    ids.map do |id|
+      unless name = source_policy_groups.to_name(id) || ignore_missing_policy_groups?
+        msg  = "Ops, do not know #{id} usergroup for source environment"
+        msg += "\nUse the option -ignore-missing-policy-groups if you do not care"
+        error(msg)
+      end
+      session.policy_groups.to_id(name).tap do |new_id|
+        unless new_id || ignore_missing_policy_groups?
+          msg  = "Ops, do not know #{name} usergroup for destination environment"
+          msg += "\nUse the option -ignore-missing-policy-groups if you do not care"
+          error(msg)
+        end
+      end
+    end.compact
+  end
+
+  def source_policy_groups
+    source_config.policy_groups
+  end
+
+  def source_config
+    @source_config ||= ASSETS.config(key: source_enviro, update_active: false).tap do |config|
+      unless config
+        error("The source environment '#{source_enviro}' does not exit or is not configured")
+      end
+    end
+  end
+
+  def source_enviro
+    @source_enviro ||= options.dig(:source_enviro).tap do |enviro|
+      error("A source environment is required to migrate data from") unless enviro
+    end
+  end
+
+  def ignore_missing_policy_groups?
+    options.dig(:ignore, :missing, :policy_groups)
+  end
+
+  def logger
+    @session.logger
+  end
+
+  def error(msg)
+    logger.error(msg)
+    exit(1)
+  end
+
+end

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

@@ -0,0 +1,30 @@
+class Eco::API::UseCases::DefaultCases::RefreshAbilitiesCase < Eco::API::Common::Loaders::UseCase
+  name "refresh-abilities"
+  type :transform
+
+  # Usecase to refresh the user's account abilities as defined in the org config for their usergroups.
+  # @param people [Eco::API::Organization::People] target existing _People_ of the current update.
+  # @param session [Eco::API::Session] the current session where the usecase kicks in.
+  # @param options [Hash] the options that modify the case behaviour or bring some dependencies.
+  # @return [Void]
+  def main(people, session, options, usecase)
+    users    = require_users!(people, session.logger)
+    update   = session.new_job("main", "update", :update, usecase, :account)
+    users.each do |person|
+      person.account.permissions_custom = session.new_preset(person)
+      update.add(person)
+    end
+  end
+
+  private
+
+  def require_users!(people, logger)
+    people.users.tap do |users|
+      unless users.length > 0
+        logger.warn("There are no people with account amoung your #{people.length} people")
+        exit(1)
+      end
+    end
+  end
+
+end

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

@@ -1,23 +1,10 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class Refresh < DefaultCase
+class Eco::API::UseCases::DefaultCases::RefreshCase < Eco::API::Common::Loaders::UseCase
+  name "refresh"
+  type :transform
 
-          def process
-            @cases.define("refresh", type: :transform) do |people, session, options, usecase|
-              job = session.job_group("main").new("update", usecase: usecase, type: :update, sets: :account)
-
-              people.each_with_index do |person, i|
-                job.add(person)
-              end
-
-            end
-          end
-
-        end
-
-      end
-    end
+  def main(people, session, options, usecase)
+    update   = session.new_job("main", "update", :update, usecase)
+    people.each {|person| job.add(person)}
   end
+
 end

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

@@ -0,0 +1,11 @@
+class Eco::API::UseCases::DefaultCases::ReinviteSyncCase < Eco::API::UseCases::DefaultCases::ReinviteTransCase
+  name "reinvite"
+  type :sync
+
+  def main(entries, people, session, options, usecase)
+    micro    = session.micro
+    found    = micro.with_each_present(entries, people, options, log_starter: true)
+    reinvite(found.users, session, options, usecase)
+  end
+
+end

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

@@ -0,0 +1,17 @@
+class Eco::API::UseCases::DefaultCases::ReinviteTransCase < Eco::API::Common::Loaders::UseCase
+  name "reinvite"
+  type :transform
+
+  def reinvite(users, session, options, usecase)
+    invite   = session.new_job("main", "invite", :update, usecase, :account)
+    users.each do |person|
+      person.account.send_invites = true
+      invite.add(person)
+    end
+  end
+
+  def main(people, session, options, usecase)
+    reinvite(people.users, session, options, usecase)
+  end
+
+end

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

@@ -0,0 +1,11 @@
+class Eco::API::UseCases::DefaultCases::RemoveAccountSyncCase < Eco::API::UseCases::DefaultCases::RemoveAccountTransCase
+  name "remove-account"
+  type :sync
+
+  def main(entries, people, session, options, usecase)
+    micro    = session.micro
+    found    = micro.with_each_present(entries, people, options, log_starter: true)
+    remove_account(found.users, session, options, usecase)
+  end
+
+end

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

@@ -0,0 +1,17 @@
+class Eco::API::UseCases::DefaultCases::RemoveAccountTransCase < Eco::API::Common::Loaders::UseCase
+  name "remove-account"
+  type :transform
+
+  def remove_account(users, session, options, usecase)
+    update   = session.new_job("main", "update", :update, usecase, :account)
+    users.each do |user|
+      user.account = nil
+      update.add(user)
+    end
+  end
+
+  def main(people, session, options, usecase)
+    remove_account(people.users, session, options, usecase)
+  end
+
+end

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

@@ -1,24 +1,14 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class ResetLandingPageCase < DefaultCase
+class Eco::API::UseCases::DefaultCases::ResetLandingPageCase < Eco::API::Common::Loaders::UseCase
+  name "reset-landing-page"
+  type :transform
 
-          def process
-            @cases.define("reset-landing-page", type: :transform) do |people, session, options, usecase|
-              job = session.job_group("main").new("update", usecase: usecase, type: :update, sets: :account)
+  def main(people, session, options, usecase)
+    update   = session.new_job("main", "update", :update, usecase, :core)
 
-              people.users.each do |user|
-                user.account.landing_page_id = nil
-                job.add(user)
-              end
-
-              job
-            end
-          end
-
-        end
-      end
+    people.users.each do |user|
+      user.account.landing_page_id = nil
+      update.add(user)
     end
   end
+
 end

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

@@ -0,0 +1,104 @@
+class Eco::API::UseCases::DefaultCases::RestoreDBCase < Eco::API::Common::Loaders::UseCase
+  name "restore-db"
+  type :sync
+
+  attr_reader :session, :options
+
+  def main(entries, people, session, options, usecase)
+    @session = session; @options = options
+
+    micro    = session.micro
+    require_people_as_entries!(entries)
+
+    restart  = session.new_job("main", "restart", :create, usecase) if options.dig(:include, :create)
+    update   = session.new_job("main", "update",  :update, usecase)
+    delete   = session.new_job("main", "delete",  :update, usecase)
+
+    if options.dig(:include, :delete)
+      micro.with_each_leaver(entries, people, options) do |person|
+        delete.add(person)
+      end
+    end
+
+    re_starters = []
+
+    micro.with_each(entries, people, options) do |entry, person|
+      if person.new? && !options.dig(:include, :create)
+        re_starters.push(entry);
+        next
+      end
+
+      person.new? ? restart.add(person) : update.add(person)
+
+      core_copy(entry, person)        unless options.dig(:exclude, :core)
+      person.details = entry.details  unless options.dig(:exclude, :details)
+
+      unless options.dig(:exclude, :account) || !entry.account
+        person.account ||= {}
+        account_copy(entry.account, person.account)
+      end
+    end
+
+    report_re_starters(re_starters)
+  end
+
+  private
+
+  def core_copy(entry, person)
+    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   unless options.dig(:exclude, :filter_tags)
+    person.freemium      = entry.freemium
+  end
+
+  def account_copy(src, dst)
+    if src
+      dst.default_tag        = src.default_tag      unless options.dig(:exclude, :filter_tags)
+      dst.policy_group_ids   = src.policy_group_ids unless options.dig(:exclude, :policy_groups)
+
+      unless options.dig(:exclude, :abilities)
+        dst.permissions_preset = src.permissions_preset
+        dst.permissions_custom = src.permissions_custom
+      end
+
+      unless options.dig(:exclude, :login_providers) || options.dig(:source_enviro)
+        dst.login_provider_ids = src.login_provider_ids
+      end
+
+      if src.preferences
+        dst.doc["preferences"] = JSON.parse((src.doc["preferences"] || {}).to_json)
+      end
+
+      unless options.dig(:source_enviro)
+        dst.starred_ids        = src.starred_ids
+        dst.landing_page_id    = src.landing_page_id
+      end
+      
+      dst&.send_invites      = options[:send_invites] if options.key?(:send_invites)
+    end
+  end
+
+  def require_people_as_entries!(entries)
+    unless entries.is_a?(Eco::API::Organization::People)
+      logger.error("Your input should be an 'Eco::API::Organization::People' object. Got: #{entries.class}")
+      exit(1)
+    end
+  end
+
+  def report_re_starters(re_starters)
+    unless re_starters.empty?
+      logger.error("There were #{re_starters.length} entries of the backup that do not exist in the (filtered?) people manager")
+      logger.error("Some examples:")
+      re_starters.slice(0, 4).each_with_index do |entry, i|
+        logger.error("This person does not exist: #{entry.name} (#{entry.email})")
+      end
+    end
+  end
+
+  def logger
+    session.logger
+  end
+
+end

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

@@ -1,49 +1,41 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class SetDefaultTagCase < DefaultCase
-          # take the deepest tag (the one that is further down in the tree)
-          # different options (several nodes at the same depth):
-          # => take the common node between them (i.e. you have Hamilton and Auckland -> take New Zealand)
-          # => if there's no common node between them, take the `first` (unless they are at top level of the tree)
+class Eco::API::UseCases::DefaultCases::SetDefaultTagCase < Eco::API::Common::Loaders::UseCase
+  name "set-default-tag"
+  type :transform
 
-          def process
-            @cases.define("set-default-tag", type: :transform) do |people, session, options, usecase|
-              if !session.tagtree
-                msg = "There is no tagtree definition in the configuration files\n" +
-                      "For this usecase to work out you need to define it."
-                session.logger.fatal(msg)
-                raise msg
-              end
+  # take the deepest tag (the one that is further down in the tree)
+  # different options (several nodes at the same depth):
+  # => take the common node between them (i.e. you have Hamilton and Auckland -> take New Zealand)
+  # => if there's no common node between them, take the `first` (unless they are at top level of the tree)
+  def main(people, session, options, usecase)
+    micro    = session.micro
+    tagtree_present!(session)
+    users    = users_present!(people, session)
+    update   = session.new_job("main", "update", :update, usecase, :account)
 
-              # IMPORTANT: this two lines ensure that only people to be updated is selected
-              all_people = people
-              people = people.account_present
-
-              if people.length <= 0
-                msg = "There are no people with account... aborting script"
-                session.logger.info(msg)
-                raise msg
-              end
-
-              update   = session.job_group("main").new("update", usecase: usecase, type: :update, sets: :account)
+    users.each do |person|
+      micro.refresh_default_tag(nil, person, options)
+      update.add(person)
+    end
+  end
 
-              people.each_with_index  do |person, i|
-                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
-                update.add(person)
-              end
+  private
 
-            end
-          end
+  def tagtree_present!(session)
+    if !session.tagtree
+      msg = "There is no tagtree definition in the configuration files\n" +
+            "For this usecase to work out you need to define it."
+      session.logger.fatal(msg)
+      raise msg
+    end
+  end
 
-        end
+  def users_present!(people, session)
+    people.users.tap do |users|
+      unless users.length > 0
+        session.logger.info(msg = "There are no people with account... aborting script")
+        raise msg
       end
     end
   end
+
 end