class Eco::API::UseCases::DefaultCases::RestoreDBCase

Attributes

options[R]
session[R]

Public Instance Methods

main(entries, people, session, options, usecase) click to toggle source
# File lib/eco/api/usecases/default_cases/restore_db_case.rb, line 7
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 Instance Methods

account_copy(src, dst) click to toggle source
# File lib/eco/api/usecases/default_cases/restore_db_case.rb, line 56
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_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
core_copy(entry, person) click to toggle source
# File lib/eco/api/usecases/default_cases/restore_db_case.rb, line 47
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
logger() click to toggle source
# File lib/eco/api/usecases/default_cases/restore_db_case.rb, line 99
def logger
  session.logger
end
report_re_starters(re_starters) click to toggle source
# File lib/eco/api/usecases/default_cases/restore_db_case.rb, line 89
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
require_people_as_entries!(entries) click to toggle source
# File lib/eco/api/usecases/default_cases/restore_db_case.rb, line 82
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