diff --git a/app/controllers/record_versions_controller.rb b/app/controllers/record_versions_controller.rb index 4cbd465..a7cbe21 100644 --- a/app/controllers/record_versions_controller.rb +++ b/app/controllers/record_versions_controller.rb @@ -1,6 +1,9 @@ # Every change to the aircraft's maintenance records (AC 120-78B 3.2.2). class RecordVersionsController < ApplicationController include AircraftScoped + before_action :require_owner!, only: :restore + + SHARED = %w[AirworthinessDirective InspectionType].freeze def index @type = params[:type].presence_in(RecordVersion.where(aircraft_id: @aircraft.id).distinct.pluck(:item_type)) @@ -9,4 +12,34 @@ class RecordVersionsController < ApplicationController @versions = scope.limit(500) @types = RecordVersion.where(aircraft_id: @aircraft.id).distinct.pluck(:item_type).sort end + + # Puts back an AD or inspection type link that was removed (the removal + # stays in the history, and the restore is recorded as a new link). + def restore + version = RecordVersion.where(aircraft_id: @aircraft.id, event: "unlink", item_type: SHARED).find(params[:id]) + record = version.item_type.constantize.find_by(id: version.item_id) + return redirect_to(aircraft_record_versions_path(@aircraft), alert: "That record no longer exists.") unless record + c = version.changes_hash + if c["applies_to"] == "component" + component = @aircraft.components.find_by(id: c["component_id"]) + return redirect_to(aircraft_record_versions_path(@aircraft), alert: "That component no longer exists; edit the record's applicability instead.") unless component + record.components << component unless record.components.include?(component) + else + record.aircraft << @aircraft unless record.aircraft.include?(@aircraft) + end + log_event(version.item_type == "AirworthinessDirective" ? "ad" : "inspection", "Restored: #{record} applies again") + redirect_to aircraft_record_versions_path(@aircraft), notice: "#{record} applies to #{@aircraft.tail_number} again." + end + + # Whether an unlink can still be undone (the record exists and isn't linked that way now). + def self.restorable?(version, aircraft) + return false unless version.event == "unlink" && SHARED.include?(version.item_type) + record = version.item_type.constantize.find_by(id: version.item_id) or return false + c = version.changes_hash + if c["applies_to"] == "component" + record.component_ids.exclude?(c["component_id"]) && aircraft.components.exists?(id: c["component_id"]) + else + record.aircraft_ids.exclude?(aircraft.id) + end + end end diff --git a/app/models/airworthiness_directive.rb b/app/models/airworthiness_directive.rb index d95017a..205883b 100644 --- a/app/models/airworthiness_directive.rb +++ b/app/models/airworthiness_directive.rb @@ -7,8 +7,7 @@ class AirworthinessDirective < ApplicationRecord BULLETIN_LABELS = { "ad" => "AD", "saib" => "SAIB", "sb" => "SB", "alert" => "Alert", "other" => "Bulletin" }.freeze belongs_to :document, optional: true - has_and_belongs_to_many :aircraft - has_and_belongs_to_many :components + include SharedRecordHistory # has_and_belongs_to_many :aircraft and :components, with history has_many :ad_compliances, dependent: :destroy validates :name, :short_description, presence: true diff --git a/app/models/component.rb b/app/models/component.rb index 32dbcb1..d219dbe 100644 --- a/app/models/component.rb +++ b/app/models/component.rb @@ -19,6 +19,8 @@ class Component < ApplicationRecord has_many :logbook_entry_parts, dependent: :destroy has_and_belongs_to_many :inspection_types has_and_belongs_to_many :airworthiness_directives + # Its AD and inspection links go with it; keep that in the record history. + before_destroy(prepend: true) { (airworthiness_directives.to_a + inspection_types.to_a).each { _1.history_component_deleted(self) } } validates :manufacturer, :model, :date_in_service, presence: true validates :status, inclusion: { in: STATUSES.keys } diff --git a/app/models/concerns/shared_record_history.rb b/app/models/concerns/shared_record_history.rb new file mode 100644 index 0000000..1df6180 --- /dev/null +++ b/app/models/concerns/shared_record_history.rb @@ -0,0 +1,43 @@ +# Record history for records shared between aircraft (ADs and inspection +# types). Their applicability lives in plain join tables, so linking one to +# an aircraft or a component, unlinking it, and changes to the shared record +# are written to each affected aircraft's history chain here (AC 120-78B 3.2.2; +# for ADs, the AD status kept under 14 CFR 91.417(a)(2)(v)). +module SharedRecordHistory + extend ActiveSupport::Concern + + IGNORED = %w[created_at updated_at].freeze + + included do + has_and_belongs_to_many :aircraft, after_add: :history_link_aircraft, after_remove: :history_unlink_aircraft + has_and_belongs_to_many :components, after_add: :history_link_component, after_remove: :history_unlink_component + after_update { (c = saved_changes.except(*IGNORED)).any? && linked_aircraft_ids.each { |id| history!(id, "update", c) } } + before_destroy { linked_aircraft_ids.each { |id| history!(id, "destroy", attributes.except(*IGNORED)) } } + end + + # Aircraft this record applies to, directly or through a component. + def linked_aircraft_ids = (aircraft_ids + components.map(&:aircraft_id)).compact.uniq + + # Logs that a component it applied to is being deleted (the join row goes + # with the component, without the callbacks above). + def history_component_deleted(component) = history_link(component.aircraft_id, "unlink", component, reason: "component deleted") + + private + + def history_link_aircraft(aircraft) = history_link(aircraft.id, "link", nil) + def history_unlink_aircraft(aircraft) = history_link(aircraft.id, "unlink", nil) + def history_link_component(component) = history_link(component.aircraft_id, "link", component) + def history_unlink_component(component) = history_link(component.aircraft_id, "unlink", component) + + def history_link(aircraft_id, event, component, reason: nil) + return unless persisted? && aircraft_id + changes = { "record" => to_s, "applies_to" => component ? "component" : "airframe" } + changes.merge!("component_id" => component.id, "component" => "#{component} #{component.model}".strip) if component + changes["reason"] = reason if reason + history!(aircraft_id, event, changes) + end + + def history!(aircraft_id, event, changes) + RecordVersion.append!(item: self, aircraft_id: aircraft_id, event: event, changes: changes.as_json) + end +end diff --git a/app/models/inspection_type.rb b/app/models/inspection_type.rb index 0f2ab7a..99c6df2 100644 --- a/app/models/inspection_type.rb +++ b/app/models/inspection_type.rb @@ -12,8 +12,7 @@ class InspectionType < ApplicationRecord # Short form for the airworthiness status ("VFR only"). LIMITATIONS = { "no_ifr" => "VFR only", "no_transponder" => "No transponder" }.freeze - has_and_belongs_to_many :aircraft - has_and_belongs_to_many :components + include SharedRecordHistory # has_and_belongs_to_many :aircraft and :components, with history has_many :inspection_records, dependent: :destroy belongs_to :satisfies, class_name: "InspectionType", optional: true has_many :satisfied_by, class_name: "InspectionType", foreign_key: :satisfies_id, inverse_of: :satisfies, dependent: :nullify diff --git a/app/views/record_versions/_list.html.erb b/app/views/record_versions/_list.html.erb index 2d6882c..6ed7cfb 100644 --- a/app/views/record_versions/_list.html.erb +++ b/app/views/record_versions/_list.html.erb @@ -4,9 +4,18 @@
  • <%= v.item_type.underscore.humanize %> #<%= v.item_id %> - <%= { "create" => "created", "update" => "changed", "destroy" => "deleted" }[v.event] %> + <%= { "create" => "created", "update" => "changed", "destroy" => "deleted", "link" => "applied", "unlink" => "removed" }[v.event] %> <%= v.created_at.utc.strftime("%Y-%m-%d %H:%M:%S UTC") %> · <%= v.user&.display_name || "system" %><%= " · #{v.ip_address}" if v.ip_address %>
    + <% if v.event.in?(%w[link unlink]) %> + <% c = v.changes_hash %> +

    + <%= c["record"] %> <%= v.event == "link" ? "applies to" : "no longer applies to" %> <%= c["applies_to"] == "component" ? c["component"] : "the airframe" %><%= " (#{c['reason']})" if c["reason"] %>. + <% if v.event == "unlink" && local_assigns[:aircraft] && local_assigns[:can_restore] && RecordVersionsController.restorable?(v, aircraft) %> + <%= button_to "Restore", restore_aircraft_record_version_path(aircraft, v), method: :post, class: "btn-secondary btn-sm ml-2", form: { class: "inline" } %> + <% end %> +

    + <% end %> <% if v.event == "update" %>
    <% v.changes_hash.each do |field, (before, after)| %> diff --git a/app/views/record_versions/index.html.erb b/app/views/record_versions/index.html.erb index 4541cf0..22a8966 100644 --- a/app/views/record_versions/index.html.erb +++ b/app/views/record_versions/index.html.erb @@ -10,5 +10,5 @@ <%= select_tag :type, options_for_select([ [ "All records", "" ] ] + @types.map { [ _1.underscore.humanize, _1 ] }, @type), class: "input w-48", data: { submit_on_change: true } %> <% end %> - <% if @versions.any? %><%= render "record_versions/list", versions: @versions %><% else %><%= empty_state "No changes recorded yet." %><% end %> + <% if @versions.any? %><%= render "record_versions/list", versions: @versions, aircraft: @aircraft, can_restore: owner? %><% else %><%= empty_state "No changes recorded yet." %><% end %> diff --git a/config/routes.rb b/config/routes.rb index f820aca..647597e 100644 --- a/config/routes.rb +++ b/config/routes.rb @@ -109,7 +109,9 @@ Rails.application.routes.draw do resource :export, controller: "aircraft_exports", only: :show resource :report, controller: "maintenance_reports", only: :show resource :records_package, path: "records", only: :show - resources :record_versions, path: "history", only: :index + resources :record_versions, path: "history", only: :index do + member { post :restore } + end resources :events, only: :index end diff --git a/docs/guide/ads.md b/docs/guide/ads.md index fd703b2..9d9b9c9 100644 --- a/docs/guide/ads.md +++ b/docs/guide/ads.md @@ -16,4 +16,6 @@ The app searches the Federal Register weekly for new ADs mentioning the aircraft **Comply** records the date, aircraft hours, the component, the logbook entry, the method (inspection, terminating action, AMOC) and the AD revision complied with, with details of what was done. **N/A** records that an AD doesn't apply, and why (for example, serial number outside the affected range). Recurring ADs then show when they're next due. +Applying an AD to the aircraft or a component, removing it, and changes to it are kept in **Activity → Record history**, with who and when. An owner can **Restore** an AD that was removed by mistake from there. + Make the logbook entry for the work as well; the status report lists each AD with its method and revision (91.417(a)(2)(v)). diff --git a/test/integration/ad_history_test.rb b/test/integration/ad_history_test.rb new file mode 100644 index 0000000..2b07911 --- /dev/null +++ b/test/integration/ad_history_test.rb @@ -0,0 +1,68 @@ +require "test_helper" + +# ADs and inspection types are shared between aircraft; linking, unlinking +# and changing them is kept in each aircraft's record history. +class AdHistoryTest < ActionDispatch::IntegrationTest + setup do + @owner = create_user("owner@example.com") + @a = create_aircraft(owner: @owner, tail_number: "N12345") + @engine = create_component(@a, component_type: component_type("Engine"), model: "O-200A") + sign_in @owner + end + + def history(event = nil) + scope = RecordVersion.where(aircraft_id: @a.id, item_type: "AirworthinessDirective") + event ? scope.where(event: event) : scope + end + + test "applying, changing, removing and restoring an AD are all in the history, with who did it" do + post aircraft_airworthiness_directives_path(@a), params: { applies_to_airframe: "1", + airworthiness_directive: { name: "2000-06-01", bulletin_type: "ad", compliance_type: "standard", short_description: "Fuel strainer" } } + ad = AirworthinessDirective.find_by!(name: "2000-06-01") + assert_equal [ "airframe" ], history("link").map { _1.changes_hash["applies_to"] } + assert_equal @owner, history("link").last.user + + patch aircraft_airworthiness_directive_path(@a, ad), params: { applies_to_airframe: "0", component_ids: [ @engine.id ], + airworthiness_directive: { short_description: "Fuel strainer assembly" } } + assert_equal [ "Fuel strainer", "Fuel strainer assembly" ], history("update").last.changes_hash["short_description"] + assert_equal "component", history("link").last.changes_hash["applies_to"] + assert_equal "airframe", history("unlink").last.changes_hash["applies_to"] + + delete aircraft_airworthiness_directive_path(@a, ad) # removed from this aircraft (no compliance: the AD record goes too) + assert_equal "component", history("unlink").last.changes_hash["applies_to"] + + ad2 = AirworthinessDirective.create!(name: "71-22-02", short_description: "Nose gear fork") + ad2.aircraft << @a + ad2.ad_compliances.create!(aircraft: @a, date_complied: Date.current, compliance_method: "inspection", compliance_notes: "Inspected, no cracks") + delete aircraft_airworthiness_directive_path(@a, ad2) + refute_includes @a.reload.applicable_ads, ad2 + unlink = history("unlink").where(item_id: ad2.id).last + get aircraft_record_versions_path(@a) + assert_select "button", text: "Restore" + assert_includes response.body, "71-22-02 no longer applies to the airframe" + + post restore_aircraft_record_version_path(@a, unlink) + assert_includes @a.reload.applicable_ads, ad2 + assert_equal 2, history("link").where(item_id: ad2.id).count # the restore is a new link + assert RecordsIntegrity.check!.ok # the chain still verifies + end + + test "deleting a component records that its ADs no longer apply; DRS-style links are recorded too" do + ad = AirworthinessDirective.create!(name: "96-12-22", short_description: "Oil adapter") + ad.components << @engine + assert_equal "O-200A", history("link").last.changes_hash["component"].split.last + delete aircraft_component_path(@a, @engine) + assert_equal "component deleted", history("unlink").last.changes_hash["reason"] + end + + test "pilots can't restore" do + pilot = create_user("pilot@example.com") + @a.roles.create!(user: pilot, role: "pilot") + ad = AirworthinessDirective.create!(name: "68-17-04", short_description: "Stall warning") + ad.aircraft << @a + ad.aircraft.delete(@a) + sign_in pilot + post restore_aircraft_record_version_path(@a, history("unlink").last) + refute_includes @a.reload.applicable_ads, ad + end +end