Import ADs from FAA DRS exports; N/A determinations and DRS links

AD import (owners, ADs tab → Import from FAA DRS):
- Upload a DRS export (.xlsx recommended, .csv works), preview, confirm.
- Per AD: track, not applicable, or skip, with suggestions and flags for
  superseded/non-current ADs, model mismatches, appliance and STC-only
  ADs, repetitive actions, and older ADs this one supersedes.
- ADs are matched by number; re-importing updates existing ADs from the
  FAA data (preview lists what will change) without touching compliance
  records, recurrence or applicability. Superseded tracked ADs are
  updated and flagged rather than skipped.
- DRS's Excel export hyperlinks each AD number to its DRS page; those
  links are kept (http(s) only). DRS ids aren't derivable from the AD
  number, so no links are guessed.

Also:
- Per-aircraft "not applicable" AD determinations (N/A badge, quick
  action, excluded from airworthiness).
- AD numbers link to their DRS document in the AD list, compliance
  history (now with description, logbook/inspection links) and share page.
- Saved DRS search link per aircraft with an "Open in DRS" button.
- Upload storage extracted to a StoredUpload concern shared with the
  flight import.
- document_url / drs_search_url added in their own guarded migration
  (they were briefly in an already-applied migration).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
rickyandClaude Opus 5.5 committed 2026-11-05 18:35:38 -05:00
1 parent f94ccee99b
commit b75fd7cf62
31 files changed
+817 -57

No files matched your search

+5 -3
View File
@@ -6,14 +6,16 @@ class AdCompliancesController < ApplicationController
def new
ad = @aircraft.applicable_ads.find_by(id: params[:ad_id])
@compliance = AdCompliance.new(aircraft: @aircraft, airworthiness_directive: ad, date_complied: Date.current,
aircraft_hours_at_compliance: @aircraft.tach_time)
aircraft_hours_at_compliance: @aircraft.tach_time,
not_applicable: params[:not_applicable] == "1")
@compliance.compliance_notes = "Not applicable: " if @compliance.not_applicable?
@compliance.fill_next_due
end
def create
@compliance = AdCompliance.new(compliance_params.merge(aircraft: @aircraft))
if @compliance.save
log_event("ad", "Compliance recorded: #{@compliance.airworthiness_directive.name}")
log_event("ad", "#{@compliance.not_applicable? ? "Marked N/A" : "Compliance recorded"}: #{@compliance.airworthiness_directive.name}")
redirect_to aircraft_airworthiness_directives_path(@aircraft), notice: "Compliance recorded."
else
render :new, status: :unprocessable_entity
@@ -44,7 +46,7 @@ class AdCompliancesController < ApplicationController
def compliance_params
p = params.require(:ad_compliance).permit(
:airworthiness_directive_id, :date_complied, :compliance_notes, :permanent, :next_due_at_time,
:aircraft_hours_at_compliance, :logbook_entry_id, :inspection_record_id, :component_id
:aircraft_hours_at_compliance, :logbook_entry_id, :inspection_record_id, :component_id, :not_applicable
)
p[:airworthiness_directive_id] = scoped_id(@aircraft.applicable_ads, p[:airworthiness_directive_id])
p[:logbook_entry_id] = scoped_id(@aircraft.logbook_entries, p[:logbook_entry_id])
+45
View File
@@ -0,0 +1,45 @@
# Owner-only import of ADs from an FAA DRS export: upload → preview → confirm.
class AdImportsController < ApplicationController
include AircraftScoped
include StoredUpload
before_action :require_owner!
def new; end
def create
token, error = store_upload(params[:file])
return redirect_to_upload(error) if error
redirect_to aircraft_ad_import_path(@aircraft, token: token, filename: params[:file].original_filename)
end
def show
@token = params[:token].to_s
return redirect_to_upload("Upload expired. Please upload the file again.") unless stored_file?(@token)
@filename = params[:filename].to_s
@import = AdImport.new(@aircraft, path: stored_path(@token), filename: @filename)
@import.rows
rescue AdImport::Error => e
redirect_to_upload(e.message)
end
def confirm
token = params[:token].to_s
return redirect_to_upload("Upload expired. Please upload the file again.") unless stored_file?(token)
import = AdImport.new(@aircraft, path: stored_path(token), filename: params[:filename])
# Only AD numbers present in the uploaded file; values are checked against AdImport::ACTIONS.
decisions = params.fetch(:decisions, {}).permit(*import.rows.map(&:number)).to_h
result = import.import!(decisions: decisions, user: current_user)
discard_upload(token)
redirect_to aircraft_airworthiness_directives_path(@aircraft),
notice: "Imported #{result[:tracked]} ADs to track and #{result[:not_applicable]} marked N/A; " \
"#{result[:updated]} existing ADs updated, #{result[:skipped]} skipped."
rescue AdImport::Error => e
redirect_to_upload(e.message)
end
private
def redirect_to_upload(message)
redirect_to new_aircraft_ad_import_path(@aircraft), alert: message
end
end
+1 -1
View File
@@ -68,7 +68,7 @@ class AircraftController < ApplicationController
params.require(:aircraft).permit(
:tail_number, :make, :model, :serial_number, :description, :purchased, :status,
:tach_time, :tach_time_offset, :hobbs_time, :hobbs_time_offset,
:airworthiness_enforcement, :picture
:airworthiness_enforcement, :picture, :drs_search_url
)
end
end
@@ -6,7 +6,8 @@ class AirworthinessDirectivesController < ApplicationController
def index
@rows = Compliance.ad_rows(@aircraft)
@history = AdCompliance.for_aircraft(@aircraft).recent_first.includes(:airworthiness_directive, :component)
@history = AdCompliance.for_aircraft(@aircraft).recent_first
.includes(:component, :logbook_entry, airworthiness_directive: :document, inspection_record: :inspection_type)
@attachable = AirworthinessDirective.where.not(id: @aircraft.applicable_ads.select(:id)).ordered if owner?
end
@@ -66,7 +67,7 @@ class AirworthinessDirectivesController < ApplicationController
def ad_params
p = params.require(:airworthiness_directive).permit(
:name, :short_description, :required_action, :compliance_type, :trigger_condition, :recurring,
:recurring_hours, :recurring_months, :recurring_days, :bulletin_type, :mandatory, :document_id
:recurring_hours, :recurring_months, :recurring_days, :bulletin_type, :mandatory, :document_id, :document_url
)
p[:document_id] = scoped_id(@aircraft.documents, p[:document_id])
p
+40
View File
@@ -0,0 +1,40 @@
# Keeps an uploaded spreadsheet in tmp/imports between the upload and confirm
# steps of an import. Tokens are server-generated "<uuid>.<ext>" and files are
# namespaced by aircraft, so a token can't be replayed elsewhere or used to
# reach other paths.
module StoredUpload
extend ActiveSupport::Concern
UPLOAD_DIR = Rails.root.join("tmp/imports")
UPLOAD_MAX_SIZE = 10.megabytes
UPLOAD_EXTENSIONS = %w[xlsx csv].freeze
TOKEN_FORMAT = /\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\.(xlsx|csv)\z/
private
# Returns [token, nil] on success or [nil, error message].
def store_upload(file)
return [ nil, "Choose a file to upload." ] unless file.respond_to?(:path)
return [ nil, "File is too large." ] if file.size > UPLOAD_MAX_SIZE
ext = File.extname(file.original_filename.to_s).delete(".").downcase
return [ nil, "Upload an .xlsx or .csv file." ] unless ext.in?(UPLOAD_EXTENSIONS)
FileUtils.mkdir_p(UPLOAD_DIR)
Dir.glob(UPLOAD_DIR.join("*")).each { |f| File.delete(f) if File.mtime(f) < 1.day.ago }
token = "#{SecureRandom.uuid}.#{ext}"
FileUtils.cp(file.path, stored_path(token))
[ token, nil ]
end
def stored_file?(token)
TOKEN_FORMAT.match?(token.to_s) && File.exist?(stored_path(token))
end
def stored_path(token)
UPLOAD_DIR.join("#{@aircraft.id}-#{File.basename(token.to_s)}")
end
def discard_upload(token)
File.delete(stored_path(token)) if stored_file?(token)
end
end
+5 -35
View File
@@ -1,32 +1,16 @@
# Owner-only bulk import of historical flights: upload → preview → confirm.
# The uploaded file is kept in tmp/imports between the two steps.
class FlightImportsController < ApplicationController
include AircraftScoped
include StoredUpload
before_action :require_owner!
MAX_SIZE = 10.megabytes
DIR = Rails.root.join("tmp/imports")
# Server-generated "<uuid>.<ext>"; anything else is rejected before touching the filesystem.
TOKEN_FORMAT = /\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\.(xlsx|csv)\z/
def new; end
# Store the upload, then redirect to the preview (Turbo requires a redirect after a form POST).
def create
file = params[:file]
return redirect_to(new_aircraft_flight_import_path(@aircraft), alert: "Choose a file to upload.") unless file.respond_to?(:path)
return redirect_to(new_aircraft_flight_import_path(@aircraft), alert: "File is too large.") if file.size > MAX_SIZE
ext = File.extname(file.original_filename).delete(".").downcase
unless ext.in?(FlightImport::EXTENSIONS)
return redirect_to new_aircraft_flight_import_path(@aircraft), alert: "Upload an .xlsx or .csv file."
end
cleanup_old_files
FileUtils.mkdir_p(DIR)
token = "#{SecureRandom.uuid}.#{ext}"
FileUtils.cp(file.path, stored_path(token))
redirect_to aircraft_flight_import_path(@aircraft, token: token, filename: file.original_filename,
token, error = store_upload(params[:file])
return redirect_to_upload(error) if error
redirect_to aircraft_flight_import_path(@aircraft, token: token, filename: params[:file].original_filename,
starting_tach: params[:starting_tach].presence,
starting_hobbs: params[:starting_hobbs].presence)
end
@@ -48,11 +32,10 @@ class FlightImportsController < ApplicationController
def confirm
token = params[:token].to_s
return redirect_to_upload("Upload expired. Please upload the file again.") unless stored_file?(token)
path = stored_path(token)
import = build_import(token, params[:filename], starting_tach: params[:starting_tach], starting_hobbs: params[:starting_hobbs])
count = import.import!(user: current_user, update_aircraft_hours: params[:update_aircraft_hours] == "1")
File.delete(path)
discard_upload(token)
redirect_to aircraft_flight_logs_path(@aircraft), notice: "Imported #{count} flights."
rescue FlightImport::Error => e
redirect_to new_aircraft_flight_import_path(@aircraft), alert: e.message
@@ -63,10 +46,6 @@ class FlightImportsController < ApplicationController
private
def stored_file?(token)
TOKEN_FORMAT.match?(token) && File.exist?(stored_path(token))
end
def redirect_to_upload(message)
redirect_to new_aircraft_flight_import_path(@aircraft), alert: message
end
@@ -75,13 +54,4 @@ class FlightImportsController < ApplicationController
FlightImport.new(@aircraft, path: stored_path(token), filename: filename,
starting_tach: starting_tach, starting_hobbs: starting_hobbs)
end
# Files are namespaced by aircraft so a token can't be replayed on another aircraft.
def stored_path(token)
DIR.join("#{@aircraft.id}-#{File.basename(token)}")
end
def cleanup_old_files
Dir.glob(DIR.join("*")).each { |f| File.delete(f) if File.mtime(f) < 1.day.ago }
end
end