mirror of
https://github.com/rickbarrette/simple-aircraft-manager-rails.git
synced 2026-11-17 23:50:36 -05:00
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>
This commit is contained in:
1 parent
38df19c331
commit
4d3dc7150a
21 files changed
+820
-75
No files matched your search
@@ -1,58 +1,74 @@
|
||||
# Oil/fuel consumption: per-interval datapoints between consecutive records
|
||||
# (sorted by flight hours), averaged over the last 20 with IQR outliers and
|
||||
# excluded records left out. Oil → hours per quart; fuel → gallons per hour.
|
||||
# Oil/fuel consumption as a rolling rate: total added ÷ tach hours flown over a
|
||||
# trailing window. Unlike per-fill math (qty added ÷ hours since the last add),
|
||||
# this tolerates partial fills and top-offs: a 15 gal top-off 0.2 h after a
|
||||
# partial fill no longer reads as 75 gal/hr.
|
||||
#
|
||||
# oil → hours per quart (higher is better)
|
||||
# fuel → gallons per hour
|
||||
#
|
||||
# Records marked "exclude from averages" (e.g. oil changes) still mark a point
|
||||
# in time, but their quantity isn't counted.
|
||||
class ConsumptionStats
|
||||
WINDOW = 20
|
||||
Point = Struct.new(:record, :hours, :value, :excluded, :outlier, keyword_init: true)
|
||||
CHART_WINDOW_HOURS = { "oil" => 25, "fuel" => 10 }.freeze
|
||||
RECENT_WINDOW_HOURS = { "oil" => 100, "fuel" => 50 }.freeze
|
||||
|
||||
attr_reader :record_type, :records
|
||||
|
||||
def initialize(aircraft, record_type)
|
||||
@record_type = record_type
|
||||
@records = aircraft.consumable_records.where(record_type: record_type).order(:flight_hours, :date).to_a
|
||||
@records = aircraft.consumable_records.where(record_type: record_type).order(:flight_hours, :date, :id).to_a
|
||||
@hours = @records.map { _1.flight_hours.to_f }
|
||||
# @prefix[i] = counted quantity of records[0...i]
|
||||
@prefix = @records.each_with_object([ 0.0 ]) do |r, acc|
|
||||
acc << acc.last + (r.excluded_from_averages? ? 0.0 : r.quantity_added.to_f)
|
||||
end
|
||||
end
|
||||
|
||||
def oil? = record_type == "oil"
|
||||
def metric_label = oil? ? "hrs/qt" : "gal/hr"
|
||||
def chart_window_hours = CHART_WINDOW_HOURS.fetch(record_type)
|
||||
def recent_window_hours = RECENT_WINDOW_HOURS.fetch(record_type)
|
||||
|
||||
# [[tach_hours, rate]] — the rolling rate at each record.
|
||||
def points
|
||||
@points ||= begin
|
||||
pts = @records.each_cons(2).filter_map do |prev, cur|
|
||||
dh = (cur.flight_hours - prev.flight_hours).to_f
|
||||
qty = cur.quantity_added.to_f
|
||||
next unless qty > 0 && dh > 0
|
||||
Point.new(record: cur, hours: cur.flight_hours.to_f, value: oil? ? dh / qty : qty / dh,
|
||||
excluded: cur.excluded_from_averages?)
|
||||
end
|
||||
bounds = iqr_bounds(pts.map(&:value))
|
||||
pts.each { |p| p.outlier = bounds && !(bounds[0]..bounds[1]).cover?(p.value) }
|
||||
@points ||= @records.each_index.filter_map do |i|
|
||||
rate = rate_ending_at(i, chart_window_hours)
|
||||
[ @hours[i].round(1), rate.round(2) ] if rate
|
||||
end
|
||||
end
|
||||
alias_method :chart_data, :points
|
||||
|
||||
def average
|
||||
window = points.last(WINDOW)
|
||||
return nil if window.empty?
|
||||
included = window.reject { |p| p.excluded || p.outlier }
|
||||
source = included.presence || window
|
||||
(source.sum(&:value) / source.size).round(1)
|
||||
# Rate over roughly the last RECENT_WINDOW_HOURS (or all history if shorter).
|
||||
def recent
|
||||
return nil if @records.size < 2
|
||||
rate_ending_at(@records.size - 1, recent_window_hours, allow_shorter: true)&.round(1)
|
||||
end
|
||||
alias_method :average, :recent
|
||||
|
||||
def lifetime
|
||||
return nil if @records.size < 2
|
||||
rate_between(0, @records.size - 1)&.round(1)
|
||||
end
|
||||
|
||||
def latest = points.last&.value&.round(1)
|
||||
|
||||
def chart_data
|
||||
points.map { |p| [ p.hours.round(1), p.value.round(2) ] }
|
||||
end
|
||||
def latest = points.last&.last&.round(1)
|
||||
|
||||
private
|
||||
|
||||
def iqr_bounds(values)
|
||||
return nil if values.size < 5
|
||||
nums = values.sort
|
||||
n = nums.size
|
||||
q1 = nums[n / 4]
|
||||
q3 = nums[(3 * n) / 4]
|
||||
iqr = q3 - q1
|
||||
return nil if iqr.zero?
|
||||
[ q1 - 1.5 * iqr, q3 + 1.5 * iqr ]
|
||||
# Rate over the shortest span ending at record i that covers >= window hours,
|
||||
# measured from an earlier record so it starts at a known fill point.
|
||||
def rate_ending_at(i, window, allow_shorter: false)
|
||||
target = @hours[i] - window
|
||||
j = (@hours.bsearch_index { _1 > target } || @hours.size) - 1 # last record at or before target
|
||||
j = 0 if j.negative? && allow_shorter
|
||||
return nil if j.negative? || j >= i
|
||||
rate_between(j, i)
|
||||
end
|
||||
|
||||
# Quantity added after record j up to and including i, over the hours between them.
|
||||
def rate_between(j, i)
|
||||
span = @hours[i] - @hours[j]
|
||||
qty = @prefix[i + 1] - @prefix[j + 1]
|
||||
return nil unless span.positive? && qty.positive?
|
||||
oil? ? span / qty : qty / span
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,252 @@
|
||||
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
|
||||
Reference in new issue
Block a user