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 @@
+ <%= 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" %>