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