318 lines
10 KiB
Ruby
318 lines
10 KiB
Ruby
require "base64"
|
|
require "digest/md5"
|
|
require "stringio"
|
|
|
|
class BackupImport
|
|
SUPPORTED_VERSIONS = [ 1, 2 ].freeze
|
|
MODES = %w[merge replace].freeze
|
|
|
|
class Error < StandardError; end
|
|
|
|
def self.call(yaml, mode:)
|
|
new(yaml, mode: mode).call
|
|
end
|
|
|
|
def initialize(yaml, mode:)
|
|
@yaml = yaml
|
|
@mode = mode.to_s
|
|
end
|
|
|
|
def call
|
|
validate_mode!
|
|
backup = load_backup
|
|
backup = migrate_backup(backup)
|
|
|
|
ActiveRecord::Base.transaction do
|
|
replace_app_data! if mode == "replace"
|
|
import_backup(backup)
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
attr_reader :yaml, :mode
|
|
|
|
def validate_mode!
|
|
return if MODES.include?(mode)
|
|
|
|
raise Error, "Choose a valid restore mode."
|
|
end
|
|
|
|
def load_backup
|
|
backup = YAML.safe_load(yaml, aliases: false)
|
|
raise Error, "Backup file is empty." unless backup.is_a?(Hash)
|
|
raise Error, "Backup format is not supported." unless backup["format"] == BackupExport::FORMAT
|
|
|
|
backup
|
|
rescue Psych::Exception
|
|
raise Error, "Backup file is not valid YAML."
|
|
end
|
|
|
|
def migrate_backup(backup)
|
|
version = backup["version"].to_i
|
|
return backup if SUPPORTED_VERSIONS.include?(version)
|
|
|
|
if version > SUPPORTED_VERSIONS.max
|
|
raise Error, "Backup version #{version} is newer than this application supports."
|
|
end
|
|
|
|
raise Error, "Backup version #{version} does not have an available migration path."
|
|
end
|
|
|
|
def replace_app_data!
|
|
UserSession.delete_all
|
|
FuelEntry.find_each { |entry| entry.images.purge }
|
|
MaintenanceEntry.find_each { |entry| entry.images.purge }
|
|
FuelEntry.delete_all
|
|
MaintenanceEntry.delete_all
|
|
MaintenanceSchedule.delete_all
|
|
Vehicle.delete_all
|
|
User.delete_all
|
|
end
|
|
|
|
def import_backup(backup)
|
|
vehicles = backup.fetch("vehicles") { raise Error, "Backup is missing vehicles." }
|
|
raise Error, "Backup vehicles must be a list." unless vehicles.is_a?(Array)
|
|
|
|
vehicles.each do |vehicle_data|
|
|
import_vehicle(vehicle_data)
|
|
end
|
|
end
|
|
|
|
def import_vehicle(vehicle_data)
|
|
vehicle = find_or_initialize_vehicle(vehicle_data)
|
|
incoming_odometer = integer_value(vehicle_data.fetch("current_odometer"))
|
|
|
|
vehicle.assign_attributes(vehicle_attributes(vehicle_data).merge(current_odometer: incoming_odometer))
|
|
vehicle.save!
|
|
|
|
import_schedules(vehicle, array_value(vehicle_data, "maintenance_schedules"))
|
|
import_fuel_entries(vehicle, array_value(vehicle_data, "fuel_entries"))
|
|
import_maintenance_entries(vehicle, array_value(vehicle_data, "maintenance_entries"))
|
|
recalculate_odometer(vehicle, incoming_odometer)
|
|
rescue KeyError => error
|
|
raise Error, "Vehicle is missing required field #{error.key}."
|
|
rescue ActiveRecord::RecordInvalid => error
|
|
raise Error, error.record.errors.full_messages.to_sentence
|
|
end
|
|
|
|
def find_or_initialize_vehicle(vehicle_data)
|
|
vin = string_value(vehicle_data.fetch("vin"))
|
|
raise Error, "Vehicle VIN is required." if vin.blank?
|
|
|
|
Vehicle.find_or_initialize_by(vin: vin.upcase)
|
|
end
|
|
|
|
def vehicle_attributes(vehicle_data)
|
|
{
|
|
licence_plate: string_value(vehicle_data.fetch("licence_plate")),
|
|
make: string_value(vehicle_data.fetch("make")),
|
|
model: string_value(vehicle_data.fetch("model")),
|
|
year: integer_value(vehicle_data.fetch("year")),
|
|
color: string_value(vehicle_data.fetch("color")),
|
|
fuel_tank_size: decimal_value(vehicle_data.fetch("fuel_tank_size")),
|
|
active: boolean_value(vehicle_data.fetch("active"))
|
|
}
|
|
end
|
|
|
|
def import_schedules(vehicle, schedules)
|
|
schedules.each do |schedule_data|
|
|
schedule = vehicle.maintenance_schedules.find_or_initialize_by(
|
|
maintenance_type: string_value(schedule_data.fetch("maintenance_type"))
|
|
)
|
|
schedule.assign_attributes(
|
|
mileage_interval: integer_value(schedule_data.fetch("mileage_interval")),
|
|
time_interval: integer_value(schedule_data.fetch("time_interval")),
|
|
baseline_odometer: integer_value(schedule_data.fetch("baseline_odometer")),
|
|
baseline_date: date_value(schedule_data.fetch("baseline_date")),
|
|
active: boolean_value(schedule_data.fetch("active")),
|
|
last_status: optional_string_value(schedule_data["last_status"]),
|
|
last_status_changed_at: optional_time_value(schedule_data["last_status_changed_at"])
|
|
)
|
|
schedule.save!
|
|
end
|
|
rescue KeyError => error
|
|
raise Error, "Maintenance schedule is missing required field #{error.key}."
|
|
end
|
|
|
|
def import_fuel_entries(vehicle, entries)
|
|
entries.each do |entry_data|
|
|
user = import_user(entry_data.fetch("updated_by_user"))
|
|
entry = matching_fuel_entry(vehicle, entry_data, user)
|
|
|
|
unless entry
|
|
FuelEntry.insert!({
|
|
vehicle_id: vehicle.id,
|
|
updated_by_user_id: user.id,
|
|
odometer: integer_value(entry_data.fetch("odometer")),
|
|
gallons_pumped: decimal_value(entry_data.fetch("gallons_pumped")),
|
|
price_paid: decimal_value(entry_data.fetch("price_paid")),
|
|
date: date_value(entry_data.fetch("date")),
|
|
created_at: Time.current,
|
|
updated_at: Time.current
|
|
})
|
|
entry = matching_fuel_entry(vehicle, entry_data, user)
|
|
end
|
|
|
|
import_images(entry, array_value(entry_data, "images"))
|
|
end
|
|
rescue KeyError => error
|
|
raise Error, "Fuel entry is missing required field #{error.key}."
|
|
end
|
|
|
|
def import_maintenance_entries(vehicle, entries)
|
|
entries.each do |entry_data|
|
|
user = import_user(entry_data.fetch("updated_by_user"))
|
|
entry = matching_maintenance_entry(vehicle, entry_data, user)
|
|
|
|
unless entry
|
|
MaintenanceEntry.insert!({
|
|
vehicle_id: vehicle.id,
|
|
updated_by_user_id: user.id,
|
|
name: string_value(entry_data.fetch("name")),
|
|
notes: string_value(entry_data.fetch("notes")),
|
|
odometer: integer_value(entry_data.fetch("odometer")),
|
|
cost: decimal_value(entry_data.fetch("cost")),
|
|
date: date_value(entry_data.fetch("date")),
|
|
created_at: Time.current,
|
|
updated_at: Time.current
|
|
})
|
|
entry = matching_maintenance_entry(vehicle, entry_data, user)
|
|
end
|
|
|
|
import_images(entry, array_value(entry_data, "images"))
|
|
end
|
|
rescue KeyError => error
|
|
raise Error, "Maintenance entry is missing required field #{error.key}."
|
|
end
|
|
|
|
def import_user(user_data)
|
|
raise Error, "Updated by user must be present." unless user_data.is_a?(Hash)
|
|
|
|
email = string_value(user_data.fetch("email")).downcase
|
|
user = User.find_or_initialize_by(email: email)
|
|
user.name = string_value(user_data.fetch("name"))
|
|
user.save!
|
|
user
|
|
rescue KeyError => error
|
|
raise Error, "User is missing required field #{error.key}."
|
|
end
|
|
|
|
def matching_fuel_entry(vehicle, entry_data, user)
|
|
vehicle.fuel_entries.where(
|
|
updated_by_user: user,
|
|
odometer: integer_value(entry_data.fetch("odometer")),
|
|
gallons_pumped: decimal_value(entry_data.fetch("gallons_pumped")),
|
|
price_paid: decimal_value(entry_data.fetch("price_paid")),
|
|
date: date_value(entry_data.fetch("date"))
|
|
).first
|
|
end
|
|
|
|
def matching_maintenance_entry(vehicle, entry_data, user)
|
|
vehicle.maintenance_entries.where(
|
|
updated_by_user: user,
|
|
name: string_value(entry_data.fetch("name")),
|
|
notes: string_value(entry_data.fetch("notes")),
|
|
odometer: integer_value(entry_data.fetch("odometer")),
|
|
cost: decimal_value(entry_data.fetch("cost")),
|
|
date: date_value(entry_data.fetch("date"))
|
|
).first
|
|
end
|
|
|
|
def import_images(entry, images)
|
|
images.each do |image_data|
|
|
filename = string_value(image_data.fetch("filename"))
|
|
checksum = string_value(image_data.fetch("checksum"))
|
|
next if image_attached?(entry, filename, checksum)
|
|
|
|
content_type = string_value(image_data.fetch("content_type"))
|
|
byte_size = integer_value(image_data.fetch("byte_size"))
|
|
validate_image_metadata!(content_type, byte_size)
|
|
|
|
content = Base64.strict_decode64(string_value(image_data.fetch("data_base64")))
|
|
raise Error, "Image byte size does not match backup metadata." unless content.bytesize == byte_size
|
|
raise Error, "Image checksum does not match backup metadata." unless Digest::MD5.base64digest(content) == checksum
|
|
|
|
entry.images.attach(
|
|
io: StringIO.new(content),
|
|
filename: filename,
|
|
content_type: content_type
|
|
)
|
|
end
|
|
rescue ArgumentError
|
|
raise Error, "Image data is not valid Base64."
|
|
rescue KeyError => error
|
|
raise Error, "Image is missing required field #{error.key}."
|
|
end
|
|
|
|
def image_attached?(entry, filename, checksum)
|
|
entry.images.any? do |image|
|
|
image.filename.to_s == filename && image.checksum == checksum
|
|
end
|
|
end
|
|
|
|
def validate_image_metadata!(content_type, byte_size)
|
|
unless EntryImageValidation::ALLOWED_IMAGE_CONTENT_TYPES.include?(content_type)
|
|
raise Error, "Images must be JPEG or PNG."
|
|
end
|
|
|
|
return if byte_size <= EntryImageValidation::MAX_IMAGE_SIZE
|
|
|
|
raise Error, "Images must be 10 MB or smaller."
|
|
end
|
|
|
|
def recalculate_odometer(vehicle, incoming_odometer)
|
|
max_odometer = [
|
|
incoming_odometer,
|
|
vehicle.fuel_entries.maximum(:odometer),
|
|
vehicle.maintenance_entries.maximum(:odometer)
|
|
].compact.max
|
|
vehicle.update!(current_odometer: max_odometer)
|
|
end
|
|
|
|
def array_value(data, key)
|
|
value = data.fetch(key, [])
|
|
raise Error, "#{key.humanize} must be a list." unless value.is_a?(Array)
|
|
|
|
value
|
|
end
|
|
|
|
def string_value(value)
|
|
value.to_s.strip
|
|
end
|
|
|
|
def optional_string_value(value)
|
|
value.present? ? value.to_s : nil
|
|
end
|
|
|
|
def integer_value(value)
|
|
Integer(value)
|
|
rescue ArgumentError, TypeError
|
|
raise Error, "Expected an integer value."
|
|
end
|
|
|
|
def decimal_value(value)
|
|
BigDecimal(value.to_s)
|
|
rescue ArgumentError, TypeError
|
|
raise Error, "Expected a decimal value."
|
|
end
|
|
|
|
def date_value(value)
|
|
Date.iso8601(value.to_s)
|
|
rescue Date::Error, TypeError
|
|
raise Error, "Expected an ISO 8601 date."
|
|
end
|
|
|
|
def optional_time_value(value)
|
|
value.present? ? Time.zone.iso8601(value.to_s) : nil
|
|
rescue ArgumentError, TypeError
|
|
raise Error, "Expected an ISO 8601 time."
|
|
end
|
|
|
|
def boolean_value(value)
|
|
return value if value == true || value == false
|
|
|
|
raise Error, "Expected a boolean value."
|
|
end
|
|
end
|