Holding model migration scripts

README.md

Instructions 12/06/2017

this code is supposed to be run in the rails console.

TODO:

• run fix_varner_organizations.rb
• for each organization identifier: (cubus, dressmann, urban... except carlings) do:
  • set env variable MYCHAIN_SYNCED_ORGANIZATIONS to the organization_identifier in production.
  • run a clean mychain import: make sure there is no MyChainSync record with organization_identifier = 'varner', also modify the MYCHAIN_SYNCED_ORGANIZATIONS to have one organization at a time, for not having problems with memory on production.
  • repeat for the other organization identifiers
• enable organization groups
• run transfer_courses_script.rb for the desired organizations (you must call the functions directly)
• add logos and settings for external auth for the organization aliases
• run fix_varner_retail.rb
• set env variable MYCHAIN_SYNCED_ORGANIZATIONS to all synced organizations for having the delta import organization_identifier in production.

TODO: for carlings

• set env variable MYCHAIN_SYNCED_ORGANIZATIONS to the organization_identifier in production.
  • run a clean mychain import: make sure there is no MyChainSync record with organization_identifier = 'varner', also modify the MYCHAIN_SYNCED_ORGANIZATIONS to have one organization at a time, for not having problems with memory on production.
  • repeat for the other organization identifiers
• set env variable MYCHAIN_SYNCED_ORGANIZATIONS to all synced organizations for having the delta import organization_identifier in production.

fix_varner_organizations.rb

orgs = ["bikbok", "cubus", "dlt", "dressmann", "urban", "volt", "wow"]

Organization.where(identifier_name: orgs).each do |organization|
  organization.update(identifier_name: "old-#{organization.identifier_name}")
end

aliases = {
  cubus: {
    name: 'Cubus',
    identifier_name: 'cubus',
    :main_color => "#3e464f",
    :secondary_color => "#61e2ec",
    :main_feature_color => "#3e464f",
    :secondary_feature_color => "#61e2ec",
    :background_color => "#000000",
  },
  dressmann: {
    name: 'Dressmann',
    identifier_name: 'dressmann',
    :main_color => "#1b1e24",
    :secondary_color => "#ec4637",
    :main_feature_color => "#fcd234",
    :secondary_feature_color => "#1b1e24",
    :background_color => "#000000",
  },
  bikbok: {
    name: 'Bik Bok',
    identifier_name: 'bikbok',
    :main_color => "#000000",
    :secondary_color => "#000000",
    :main_feature_color => "#000000",
    :secondary_feature_color => "#000000",
    :background_color => "#000000",
  },
  urban: {
    name: 'Urban',
    identifier_name: 'urban',
    :main_color => "#141516",
    :secondary_color => "#30eecf",
    :main_feature_color => "#141516",
    :secondary_feature_color => "#30eecf",
    :background_color => "#000000",
  }
}

varner = find_organization('varner')

aliases.values.each do |alias_data|
  varner.aliases.create!(alias_data)
end

fix_varner_retail.rb

varner = find_organization('varner')

varner.update!(name: 'Varner')
varner.default_group.update!(name: 'Varner')

varner_retail_group = varner.groups.create!(level: :level_1, name: 'Varner Retail', enabled: true, identifier_name: 'varner-retail')

organization_alias = UsersSystem::OrganizationAlias.create!(
  name: 'Varner Retail',
  identifier_name: 'varner-retail',
  organization: varner
)

varner.users.where(imported: false).find_each do |user|
  UsersSystem::GroupMembership.create!(user: user, group: varner_retail_group, role: :member)
end

transfer_courses_script.rb

class CourseTransfer
  attr_reader :course, :from_organization, :to_organization, :options, :logger

  # options
  #   - transfer_delegations: Boolean
  #   - transfer_assignments: Boolean
  #   - transfer_completions: Boolean
  #   - owner_group_id: Integer
  def initialize(course, options = {})
    @course = course
    @from_organization = options.fetch(:from_organization)
    @to_organization = options.fetch(:to_organization)
    @options = options
    @logger = options.fetch(:logger) { Logger.new(STDOUT) }
  end

  def call
    ActiveRecord::Base.transaction do
      store_course_previous_state

      update_categories
      transfer_course!
      transfer_badge!
      transfer_delegations!
      transfer_assignments!
      transfer_chapter_completions!

      check_course_integrity
    end
  end

  def store_course_previous_state
    pp @original_state = {
      categories: course.categories.count,
      approver: course.approver&.full_name,
      editors: course.editors.count,
      assignments: course.assignments.count,
      badge: course.badge.title,
      scope: course.organization.name
    }
  end

  def check_course_integrity
    course.reload

    pp new_state = {
      categories: course.categories.count,
      approver: course.approver&.full_name,
      editors: course.editors.count,
      assignments: course.assignments.count,
      badge: course.badge.title,
      scope: course.organization.name
    }

    success =(
    @original_state[:categories] == new_state[:categories] &&
    @original_state[:badge] == new_state[:badge] &&
    true
    )

    raise 'Error!' unless success
  end

  private

  def update_categories
    new_categories = course.categories.map { |category| to_organization.training_categories.find_or_create_by(title: category.title) }
    course.update!(categories: new_categories)
    logger.info ">>> set new categories #{new_categories.map(&:title)}"
  end

  def transfer_course!
    update_params = {
      scope_id: to_organization.id,
      owner_id: options.fetch(:owner_group_id)
    }
    course.update!(update_params)
    logger.info ">>> transfer course #{course.id}"
  end

  def transfer_badge!
    new_badge = to_organization.training_badges.find_by!(
      title: course.badge.title
    )
    course.update!(badge_id: new_badge.id)
    logger.info ">>> sync badge #{new_badge.id}"
  end

  def transfer_assignments!
    assignments = Training::Course::Assignment.where(course_id: course.id)
    if options.fetch(:transfer_assignments, true)
      assignments.each(&method(:transfer_assignment!))
    else
      logger.info ">>>>>> destroying assignments #{assignments.pluck(:id)}"
      assignments.destroy_all
    end
  end

  def transfer_assignment!(assignment)
    assignment.group_assignments.each do |ga|
      new_group = to_organization.groups.find_by!(import_id: ga.group.import_id)

      ga.update!(group_id: new_group.id)
    end

    assignment.position_assignments.each do |pa|
      position_name = "#{from_organization.name} #{pa.position.name}".gsub(/OLD /, '').gsub(/Old-/, '')
      puts ">>> #{position_name}"
      if position_name =~ /All Positions/
        new_position = to_organization.default_position
      else
        new_position = to_organization.positions.find_by!(name: position_name)
      end

      pa.update!(position_id: new_position.id)
    end
    logger.info ">>>>>> assigment #{assignment.id} transfered"
  end

  def transfer_delegations!
    if options.fetch(:transfer_delegations, true)
      course.delegations.each do |delegation|
        new_user = to_organization.users.find_by!(
          employee_number: delegation.user.employee_number
        )
        delegation.update!(user_id: new_user.id)
      end
    else
      logger.info ">>>> destroying delegations #{course.delegations.pluck(:id)}"
      course.delegations.destroy_all
    end
  end

  def transfer_chapter_completions!
    from_chapter_ids = Training::Course::Chapter.where(course: course).pluck(:id)

    chapter_completions = Training::Course::Chapter::Completion.where(chapter_id: from_chapter_ids)

    if options.fetch(:transfer_completions, false)
      chapter_completions.each(&method(:transfer_chapter_completion!))
      logger.info ">>>> transfering #{chapter_completions.count} completions"
    else
      chapter_completions.destroy_all
      logger.info ">>>> destroying #{chapter_completions.count} completions"
    end
  end

  def transfer_chapter_completion!(completion)
    completion.update!(
      user_id: to_organization.users.find_by!(
        employee_number: completion.user.employee_number
      ).id
    )
  end

end

def transfer_courses(from_organization:, to_organization:, course_ids: nil)
  course_ids ||= from_organization.training_courses.pluck(:id)

  options = {
    transfer_completions: true,
    transfer_delegations: true,
    transfer_assignments: true,
    course_ids: course_ids,
    from_organization: from_organization,
    to_organization: to_organization,
    owner_group_id: from_organization.default_group.id
  }

  success = 0

  begin
    courses = from_organization.training_courses.find(options[:course_ids])
    puts ">>> courses to transfer #{courses.count}"

    courses.each do |course|
      transfer = CourseTransfer.new(course, options)
      begin
        transfer.call
        success += 1
      rescue => e
        puts e.message
        pp e.backtrace
      end
    end
  rescue ActiveRecord::RecordNotFound
    puts ">>> no courses found in organization #{from_organization.name} "\
      "with ID #{course_ids}"
  end

  puts ">>>> #{success} courses transfered"
end

varner = find_organization('varner')
cubus = UsersSystem::Organization.with_identifier_name('old-cubus')
dressmann = UsersSystem::Organization.with_identifier_name('old-dressmann')

# transfer_courses(from_organization: cubus, to_organization: varner)
# transfer_courses(from_organization: dressmann, to_organization: varner)