diff --git a/.gitignore b/.gitignore
index fbcab40..35c4400 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,3 +33,7 @@
# Ignore key files for decrypting credentials and more.
/config/*.key
+
+# Ignore emacs backups
+*.#
+*#
diff --git a/BUILDING.md b/BUILDING.md
new file mode 100644
index 0000000..bd94824
--- /dev/null
+++ b/BUILDING.md
@@ -0,0 +1,3 @@
+# Directions to get a running docker image
+
+Clone the repo
diff --git a/app/controllers/backups_controller.rb b/app/controllers/backups_controller.rb
new file mode 100644
index 0000000..377e8b0
--- /dev/null
+++ b/app/controllers/backups_controller.rb
@@ -0,0 +1,45 @@
+require "stringio"
+require "zlib"
+
+class BackupsController < ApplicationController
+ def show
+ end
+
+ def download
+ send_data gzip(BackupExport.call),
+ filename: "car-tracker-backup-#{Time.current.strftime('%Y%m%d%H%M%S')}.yml.gz",
+ type: "application/gzip",
+ disposition: "attachment"
+ end
+
+ def restore
+ BackupImport.call(gunzip(uploaded_backup.read), mode: params[:mode])
+ redirect_to backup_path, notice: "Backup restored."
+ rescue BackupImport::Error, Zlib::GzipFile::Error => error
+ redirect_to backup_path, alert: "Backup could not be restored: #{restore_error_message(error)}"
+ end
+
+ private
+
+ def uploaded_backup
+ params.fetch(:backup_file)
+ rescue KeyError
+ raise BackupImport::Error, "Choose a backup file to restore."
+ end
+
+ def gzip(content)
+ buffer = StringIO.new
+ Zlib::GzipWriter.wrap(buffer) { |gzip| gzip.write(content) }
+ buffer.string
+ end
+
+ def gunzip(content)
+ Zlib::GzipReader.wrap(StringIO.new(content), &:read)
+ rescue Zlib::GzipFile::Error
+ raise BackupImport::Error, "Backup file must be a gzip-compressed YAML file."
+ end
+
+ def restore_error_message(error)
+ error.message.presence || "unknown error"
+ end
+end
diff --git a/app/services/backup_export.rb b/app/services/backup_export.rb
new file mode 100644
index 0000000..4a677f1
--- /dev/null
+++ b/app/services/backup_export.rb
@@ -0,0 +1,105 @@
+class BackupExport
+ FORMAT = "car_tracker_backup".freeze
+ VERSION = 1
+
+ def self.call
+ new.call
+ end
+
+ def call
+ {
+ "format" => FORMAT,
+ "version" => VERSION,
+ "exported_at" => Time.current.iso8601,
+ "vehicles" => vehicles
+ }.to_yaml
+ end
+
+ private
+
+ def vehicles
+ Vehicle.includes(
+ :maintenance_schedules,
+ { fuel_entries: :updated_by_user },
+ { maintenance_entries: :updated_by_user }
+ ).order(:make, :model, :year, :vin).map do |vehicle|
+ vehicle_data(vehicle)
+ end
+ end
+
+ def vehicle_data(vehicle)
+ {
+ "vin" => vehicle.vin,
+ "licence_plate" => vehicle.licence_plate,
+ "make" => vehicle.make,
+ "model" => vehicle.model,
+ "year" => vehicle.year,
+ "color" => vehicle.color,
+ "current_odometer" => vehicle.current_odometer,
+ "fuel_tank_size" => decimal_string(vehicle.fuel_tank_size),
+ "active" => vehicle.active?,
+ "maintenance_schedules" => maintenance_schedules(vehicle),
+ "fuel_entries" => fuel_entries(vehicle),
+ "maintenance_entries" => maintenance_entries(vehicle)
+ }
+ end
+
+ def maintenance_schedules(vehicle)
+ vehicle.maintenance_schedules.sort_by(&:maintenance_type).map do |schedule|
+ {
+ "maintenance_type" => schedule.maintenance_type,
+ "mileage_interval" => schedule.mileage_interval,
+ "time_interval" => schedule.time_interval,
+ "baseline_odometer" => schedule.baseline_odometer,
+ "baseline_date" => date_string(schedule.baseline_date),
+ "active" => schedule.active?,
+ "last_status" => schedule.last_status,
+ "last_status_changed_at" => time_string(schedule.last_status_changed_at)
+ }
+ end
+ end
+
+ def fuel_entries(vehicle)
+ vehicle.fuel_entries.sort_by { |entry| [ entry.date, entry.odometer, entry.id ] }.map do |entry|
+ {
+ "date" => date_string(entry.date),
+ "odometer" => entry.odometer,
+ "gallons_pumped" => decimal_string(entry.gallons_pumped),
+ "price_paid" => decimal_string(entry.price_paid),
+ "updated_by_user" => user_data(entry.updated_by_user)
+ }
+ end
+ end
+
+ def maintenance_entries(vehicle)
+ vehicle.maintenance_entries.sort_by { |entry| [ entry.date, entry.odometer, entry.name, entry.id ] }.map do |entry|
+ {
+ "name" => entry.name,
+ "notes" => entry.notes,
+ "date" => date_string(entry.date),
+ "odometer" => entry.odometer,
+ "cost" => decimal_string(entry.cost),
+ "updated_by_user" => user_data(entry.updated_by_user)
+ }
+ end
+ end
+
+ def user_data(user)
+ {
+ "name" => user.name,
+ "email" => user.email
+ }
+ end
+
+ def date_string(value)
+ value&.iso8601
+ end
+
+ def time_string(value)
+ value&.iso8601
+ end
+
+ def decimal_string(value)
+ value&.to_s("F")
+ end
+end
diff --git a/app/services/backup_import.rb b/app/services/backup_import.rb
new file mode 100644
index 0000000..9f18467
--- /dev/null
+++ b/app/services/backup_import.rb
@@ -0,0 +1,259 @@
+class BackupImport
+ SUPPORTED_VERSION = 1
+ 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 version == SUPPORTED_VERSION
+
+ if version > SUPPORTED_VERSION
+ 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.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"))
+ next if fuel_entry_exists?(vehicle, entry_data, user)
+
+ 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
+ })
+ 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"))
+ next if maintenance_entry_exists?(vehicle, entry_data, user)
+
+ 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
+ })
+ 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 fuel_entry_exists?(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"))
+ ).exists?
+ end
+
+ def maintenance_entry_exists?(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"))
+ ).exists?
+ 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
diff --git a/app/views/backups/show.html.erb b/app/views/backups/show.html.erb
new file mode 100644
index 0000000..1950b2f
--- /dev/null
+++ b/app/views/backups/show.html.erb
@@ -0,0 +1,55 @@
+
+ <% if notice.present? %>
+ <%= notice %>
+ <% end %>
+
+ <% if flash[:alert].present? %>
+ <%= flash[:alert] %>
+ <% end %>
+
+ <%= link_to "Back to vehicles", vehicles_path, class: "back-link" %>
+
+
+
+
+ Download Backup
+ Download a gzip-compressed YAML backup of vehicles, users, maintenance schedules, fuel entries, and maintenance entries.
+ Authentication data, access keys, and browser sessions are not included.
+ <%= link_to "Download backup", download_backup_path, class: "button button--primary" %>
+
+
+
+ Restore Backup
+ Upload a `.yml.gz` backup exported from Car Tracker.
+
+ <%= form_with url: restore_backup_path, multipart: true, class: "stacked-form" do |form| %>
+
+ <%= form.label :backup_file, "Backup file" %>
+ <%= form.file_field :backup_file, accept: ".gz,.yml.gz,application/gzip", required: true %>
+
+
+
+
+ Replace mode deletes existing vehicles, users, schedules, fuel entries, and maintenance entries before importing the backup.
+
+
+ <%= form.submit "Restore backup", class: "button button--primary" %>
+
+ <% end %>
+
+
diff --git a/app/views/vehicles/index.html.erb b/app/views/vehicles/index.html.erb
index c952905..4dec583 100644
--- a/app/views/vehicles/index.html.erb
+++ b/app/views/vehicles/index.html.erb
@@ -8,7 +8,10 @@
Fleet dashboard
Vehicles
- <%= link_to "New vehicle", new_vehicle_path, class: "button button--primary" %>
+
+ <%= link_to "Backup / Restore", backup_path, class: "button button--secondary" %>
+ <%= link_to "New vehicle", new_vehicle_path, class: "button button--primary" %>
+