ManageIQ/manageiq-content

PROVISION_DIALOG_PASSWORD_FIELDS = [:root_password, :sysprep_password, :sysprep_domain_password, :sysprep_admin_password].freeze

def vmdb_object_from_array_entry(entry)
  model, id = entry.split("::")
  $evm.vmdb(model, id.to_i) if model && id
end

def parent_task(task)
  return task if task.miq_request_task.nil?
  parent_task(task.miq_request_task)
end

def add_hash_value(sequence_id, option_key, value, hash)
  $evm.log("info", "Adding seq_id: #{sequence_id} key: #{option_key} value: #{value} ")
  hash[sequence_id][option_key] = value
end

def process_comma_separated_object_array(sequence_id, option_key, value, hash)
  return if value.nil?
  options_value_array = []
  value.split(",").each do |entry|
    next if entry.blank?
    vmdb_obj = vmdb_object_from_array_entry(entry)
    options_value_array << if vmdb_obj.nil?
                             entry
                           else
                             (vmdb_obj.respond_to?(:name) ? vmdb_obj.name : "#{vmdb_obj.class.name}::#{vmdb_obj.id}")
                           end
  end
  hash[sequence_id][option_key] = options_value_array
end

def option_password_value(dialog_key, dialog_value, options_hash)
  return false unless /^password::dialog_option_(?<sequence>\d*)_(?<option_key>.*)/i =~ dialog_key
  add_password_value(sequence.to_i, option_key, dialog_value, options_hash)
  true
end

def generic_password_value(dialog_key, dialog_value, options_hash)
  return false unless /^password::dialog_(?<option_key>.*)/i =~ dialog_key
  add_password_value(0, option_key, dialog_value, options_hash)
  true
end

def add_password_value(sequence, option_key, value, options_hash)
  stripped_option_key = 'password::' + option_key
  prefixed_option_key = 'password::dialog_' + option_key
  add_hash_value(sequence, stripped_option_key.to_sym, value, options_hash)
  add_hash_value(sequence, prefixed_option_key.to_sym, value, options_hash)

  if provision_dialog_password?(option_key.to_sym)
    add_hash_value(sequence, option_key.to_sym, value, options_hash)
  end
end

def provision_dialog_password?(option_key)
  PROVISION_DIALOG_PASSWORD_FIELDS.include?(option_key) ? true : false
end

def option_hash_value(dialog_key, dialog_value, options_hash)
  return false unless /^dialog_option_(?<sequence>\d*)_(?<option_key>.*)/i =~ dialog_key
  add_hash_value(sequence.to_i, option_key.to_sym, dialog_value, options_hash)
  true
end

def option_array_value(dialog_key, dialog_value, options_hash)
  return false unless /^array::dialog_option_(?<sequence>\d*)_(?<option_key>.*)/i =~ dialog_key
  process_comma_separated_object_array(sequence.to_i, option_key.to_sym, dialog_value, options_hash)
  true
end

def tag_hash_value(dialog_key, dialog_value, tags_hash)
  return false unless /^dialog_tag_(?<sequence>\d*)_(?<option_key>.*)/i =~ dialog_key
  add_hash_value(sequence.to_i, option_key.to_sym, dialog_value, tags_hash)
  true
end

def tag_array_value(dialog_key, dialog_value, tags_hash)
  return false unless /^array::dialog_tag_(?<sequence>\d*)_(?<option_key>.*)/i =~ dialog_key
  process_comma_separated_object_array(sequence.to_i, option_key.to_sym, dialog_value, tags_hash)
  true
end

def generic_dialog_value(dialog_key, dialog_value, options_hash)
  return false unless /^dialog_(?<option_key>.*)/i =~ dialog_key
  add_hash_value(0, option_key.to_sym, dialog_value, options_hash)
  add_hash_value(0, dialog_key.to_sym, dialog_value, options_hash)
  true
end

def generic_dialog_array_value(dialog_key, dialog_value, options_hash)
  return false unless /^array::(?<generic_dialog_key>dialog_(?<option_key>.*))/i =~ dialog_key
  process_comma_separated_object_array(0, option_key.to_sym, dialog_value, options_hash)
  process_comma_separated_object_array(0, generic_dialog_key.to_sym, dialog_value, options_hash)
  true
end

def set_dialog_value(key, value, options_hash, tags_hash)
  option_hash_value(key, value, options_hash) ||
    option_array_value(key, value, options_hash) ||
    option_password_value(key, value, options_hash) ||
    tag_hash_value(key, value, tags_hash) ||
    tag_array_value(key, value, tags_hash) ||
    generic_dialog_value(key, value, options_hash) ||
    generic_dialog_array_value(key, value, options_hash) ||
    generic_password_value(key, value, options_hash)
end

def parse_dialog_entries(dialog_options)
  options_hash        = Hash.new { |h, k| h[k] = {} }
  tags_hash           = Hash.new { |h, k| h[k] = {} }

  dialog_options.each do |key, value|
    next if value.blank?
    set_dialog_value(key, value, options_hash, tags_hash)
  end
  return options_hash, tags_hash
end

def parent_task_dialog_information(task)
  bundle_task = parent_task(task)
  if bundle_task.nil?
    $evm.log('error', "Unable to locate Dialog information")
    exit MIQ_ABORT
  end
  $evm.log('info', "Current task has empty dialogs, getting dialog information from parent task")
  return YAML.load(bundle_task.get_option(:parsed_dialog_options) || "{}"),
         YAML.load(bundle_task.get_option(:parsed_dialog_tags) || "{}")
end

def save_parsed_dialog_information(options_hash, tags_hash, task)
  task.set_option(:parsed_dialog_options, YAML.dump(options_hash))
  task.set_option(:parsed_dialog_tags, YAML.dump(tags_hash))
  $evm.log('info', "parsed_dialog_options: #{task.get_option(:parsed_dialog_options).inspect}")
  $evm.log('info', "parsed_dialog_tags: #{task.get_option(:parsed_dialog_tags).inspect}")
end

task = $evm.root['service_template_provision_task']

dialog_entries = task.dialog_options

$evm.log('info', "dialog_options: #{dialog_entries.inspect}")

options_hash, tags_hash = parse_dialog_entries(dialog_entries)

if options_hash.blank? && tags_hash.blank?
  options_hash, tags_hash = parent_task_dialog_information(task)
else
  $evm.log('info', "Current task has dialog information")
end

save_parsed_dialog_information(options_hash, tags_hash, task)