Files
simple-aircraft-manager-rails/app/services/flight_import.rb
T
rickyandClaude Opus 5.5 4d3dc7150a Add spreadsheet flight import; fix oil/fuel consumption charts
Flight import (owners, Flights tab → Import from spreadsheet):
- Upload .xlsx or .csv, preview, then confirm. Columns are matched by
  header name (Date, From, To, Tach, Hobbs, Oil, Fuel, Flight Time).
- Each flight's time is derived from the previous row's meter reading;
  rows are kept in file order so typos (tach going backwards) are
  flagged and skipped while the next good row absorbs the time.
- Unchanged tach imports as a 0.0 hr entry so fuel/oil isn't lost;
  "Full" fuel is warned about; re-imports skip existing rows.
- History only: component hours are untouched unless the owner opts in
  to advancing the aircraft's meters to the last reading.
- Upload redirects to a GET preview (Turbo ignores 200 renders after a
  form POST, which made the button appear to do nothing).

Consumption charts:
- Replace per-fill math (qty ÷ hours since last add), which spiked to
  80 gal/hr on partial fills and top-offs, with a rolling rate (total
  added ÷ hours over a trailing 10 h fuel / 25 h oil window).
- Headline shows recent (last ~50/100 hrs) and lifetime rates; straight
  chart lines instead of splines.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 19:23:47 -05:00

253 lines
9.1 KiB
Ruby
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
require "roo"
# Imports historical flights from a spreadsheet (.xlsx or .csv) where each row
# holds the meter readings at the END of a flight:
#
# Date | From | To | Tach Time | Hobbs Time | Oil Added | Fuel Added | Flight Time
#
# Flight duration is derived from the previous row's reading. Rows are processed
# in file order (not re-sorted), so a reading that goes backwards is reported as
# an error instead of silently reshuffled.
#
# Importing records history only: it does NOT add time to components (that
# would double-count). Optionally, the aircraft's meters are advanced to the
# last reading afterwards via a normal hours update.
class FlightImport
class Error < StandardError; end
EXTENSIONS = %w[xlsx csv].freeze
BLANK_VALUES = [ "", "n", "no", "none", "-", "—", "0", "0.0" ].freeze
LONG_FLIGHT_HOURS = 15
DATE_FORMATS = [ "%m/%d/%y", "%m/%d/%Y", "%Y-%m-%d", "%m-%d-%y", "%m-%d-%Y", "%d-%b-%y", "%d-%b-%Y" ].freeze
# Header aliases, matched after lowercasing and stripping non-letters.
COLUMNS = {
date: ->(h) { h == "date" || h.start_with?("date") },
from: ->(h) { h.start_with?("from", "dep", "origin") },
to: ->(h) { %w[to dest destination arr arrival arrive].include?(h) },
tach: ->(h) { h.start_with?("tach") },
hobbs: ->(h) { h.start_with?("hobbs", "hobs") },
oil: ->(h) { h.start_with?("oil") },
fuel: ->(h) { h.start_with?("fuel") },
flight_time: ->(h) { h.include?("flighttime") || h.include?("duration") }
}.freeze
Row = Struct.new(:line, :date, :from, :to, :tach_out, :tach_in, :tach_time,
:hobbs_out, :hobbs_in, :hobbs_time, :oil, :fuel, :status, :messages, :baseline,
keyword_init: true) do
def importable? = status.in?(%i[ok warning])
def warn(msg) = (messages << msg; self.status = :warning if status == :ok)
def error(msg) = (messages << msg; self.status = :error)
end
attr_reader :columns, :headers
def initialize(aircraft, path:, filename:, starting_tach: nil, starting_hobbs: nil)
@aircraft = aircraft
@path = path.to_s
@filename = filename.to_s
@starting_tach = decimal(starting_tach, 1)
@starting_hobbs = decimal(starting_hobbs, 1)
end
def rows
@rows ||= build_rows
end
def importable = rows.select(&:importable?)
def count(status) = rows.count { _1.status == status }
def total_tach_hours = importable.sum(&:tach_time)
def last_reading = importable.last
def mapped?(column) = columns.key?(column)
# Creates flight logs + oil/fuel records. Returns the number of flights imported.
def import!(user:, update_aircraft_hours: false)
flights = importable
raise Error, "Nothing to import." if flights.empty?
Aircraft.transaction do
flights.each do |r|
log = @aircraft.flight_logs.create!(
user: user, date: r.date, departure_location: r.from, destination_location: r.to,
tach_out: r.tach_out, tach_in: r.tach_in, tach_time: r.tach_time,
hobbs_out: r.hobbs_out, hobbs_in: r.hobbs_in, hobbs_time: r.hobbs_time,
oil_added: r.oil, fuel_added: r.fuel, notes: "Imported from #{@filename}"
)
{ "oil" => r.oil, "fuel" => r.fuel }.each do |type, qty|
next unless qty
@aircraft.consumable_records.create!(record_type: type, flight_log: log, date: r.date,
quantity_added: qty, flight_hours: r.tach_in,
notes: "Imported from #{@filename}")
end
end
@aircraft.log_event!("flight", "Imported #{flights.size} flights from spreadsheet", user: user,
notes: "#{@filename}: #{flights.first.date} – #{flights.last.date}, #{total_tach_hours} tach hrs")
end
advance_aircraft_hours!(user) if update_aircraft_hours
flights.size
end
# Moves the aircraft's meters up to the last imported reading (never down).
# Returns the delta applied, or nil if nothing changed.
def advance_aircraft_hours!(user)
last = last_reading
return nil unless last && last.tach_in > @aircraft.tach_time
hobbs = last.hobbs_in if last.hobbs_in && last.hobbs_in >= @aircraft.hobbs_time
HoursService.new(@aircraft, user: user).update_hours!(tach_time: last.tach_in, hobbs_time: hobbs)
end
private
def build_rows
sheet, header_index = locate_header
existing = @aircraft.flight_logs.where.not(tach_in: nil).pluck(:date, :tach_in).to_set { |d, t| [ d, t.to_d ] }
prev_tach = @starting_tach
prev_hobbs = @starting_hobbs
result = []
((header_index + 1)..sheet.last_row).each do |i|
raw = sheet.row(i)
next if raw.compact.all? { _1.to_s.strip.empty? }
row = Row.new(line: i, status: :ok, messages: [])
row.date = parse_date(cell(raw, :date))
row.from = code(cell(raw, :from))
row.to = code(cell(raw, :to))
row.tach_in = decimal(cell(raw, :tach), 1)
row.hobbs_in = decimal(cell(raw, :hobbs), 1)
row.oil = quantity(row, cell(raw, :oil), "Oil")
row.fuel = quantity(row, cell(raw, :fuel), "Fuel")
flight_time = decimal(cell(raw, :flight_time), 1)
row.error("Date missing or not recognized (#{cell(raw, :date).inspect})") unless row.date
row.error("Tach reading missing") unless row.tach_in
if row.tach_in
if prev_tach.nil?
if flight_time&.positive?
row.tach_time = flight_time
row.tach_out = row.tach_in - flight_time
row.warn("First row: duration taken from Flight Time column (enter the starting tach to be exact)")
else
row.error("Starting reading only: no previous tach to measure from. Enter the tach before the first flight to import this row")
row.baseline = true
end
elsif row.tach_in < prev_tach
row.error("Tach went backwards (#{prev_tach} → #{row.tach_in}). Likely a typo")
elsif row.tach_in == prev_tach
row.tach_out = prev_tach
row.tach_time = BigDecimal("0")
row.warn("Tach didn't change (#{row.tach_in}). Imported as 0.0 hrs; check for a typo")
else
row.tach_out = prev_tach
row.tach_time = row.tach_in - prev_tach
row.warn("Long flight: #{row.tach_time} tach hrs. Missing rows?") if row.tach_time > LONG_FLIGHT_HOURS
end
end
if row.hobbs_in && prev_hobbs && row.hobbs_in > prev_hobbs
row.hobbs_out = prev_hobbs
row.hobbs_time = row.hobbs_in - prev_hobbs
elsif flight_time&.positive?
row.hobbs_time = flight_time
end
if row.hobbs_in && prev_hobbs && row.hobbs_in < prev_hobbs
row.warn("Hobbs went backwards (#{prev_hobbs} → #{row.hobbs_in}). Meter replaced?")
end
if row.status != :error && existing.include?([ row.date, row.tach_in ])
row.status = :duplicate
row.messages = [ "Already imported" ]
end
# Bad rows don't move the baseline, so the next good row absorbs the time.
if row.status != :error || row.baseline
prev_tach = row.tach_in
prev_hobbs = row.hobbs_in if row.hobbs_in
end
result << row
end
result
end
def locate_header
book = open_spreadsheet
book.sheets.each do |name|
sheet = book.sheet(name)
next unless sheet.first_row
(sheet.first_row..[ sheet.first_row + 20, sheet.last_row ].min).each do |i|
cols = detect_columns(sheet.row(i))
if cols.key?(:date) && cols.key?(:tach)
@columns = cols
@headers = sheet.row(i)
return [ sheet, i ]
end
end
end
raise Error, "Couldn't find a header row with Date and Tach columns."
end
def open_spreadsheet
ext = File.extname(@filename).delete(".").downcase
raise Error, "Upload an .xlsx or .csv file." unless ext.in?(EXTENSIONS)
Roo::Spreadsheet.open(@path, extension: ext.to_sym)
rescue Zip::Error, ArgumentError, CSV::MalformedCSVError => e
raise Error, "Couldn't read the file (#{e.message})."
end
def detect_columns(header_row)
found = {}
header_row.each_with_index do |h, idx|
norm = h.to_s.downcase.gsub(/[^a-z]/, "")
next if norm.empty?
COLUMNS.each { |key, match| found[key] ||= idx if match.(norm) }
end
found
end
def cell(raw, key)
idx = @columns[key]
idx && raw[idx]
end
def parse_date(value)
case value
when Date, DateTime, Time then value.to_date
when nil then nil
else
str = value.to_s.strip
DATE_FORMATS.each do |fmt|
date = Date.strptime(str, fmt) rescue next
return date
end
nil
end
end
def decimal(value, scale = 2)
return nil if value.nil? || value.to_s.strip.empty?
BigDecimal(value.to_s.strip.delete(",")).round(scale)
rescue ArgumentError
nil
end
def quantity(row, value, label)
return nil if value.nil? || BLANK_VALUES.include?(value.to_s.strip.downcase)
if value.to_s.strip.casecmp?("full")
row.warn("#{label} “Full” has no quantity, so it isn't recorded")
return nil
end
qty = decimal(value)
if qty.nil? || qty.negative?
row.warn("#{label} value #{value.inspect} ignored")
return nil
end
qty
end
def code(value)
value.to_s.strip.upcase.presence
end
end