Files
simple-aircraft-manager-rails/app/services/logbook_entry_pdf.rb
T
rickyandClaude Opus 5.5 d719f663bc Electronic signatures on logbook entries (AC 120-78B chapter 2)
- Sign an entry: review exactly what's certified, choose a current
  certificate (eligibility checked: pilot only for preventive maintenance,
  inspections need their result and time), re-enter the password or sign
  in again with SSO (prompt=login, within 5 minutes), and confirm the
  "Certified by" statement (43.9 return to service, 43.11(a)(5) for
  inspections, preventive maintenance for pilots)
- The signature stores signer, certificate, statement, UTC time, how they
  authenticated, IP/browser, a SHA-256 fingerprint of the entry's content
  and a readable snapshot; an HMAC seal covers the signature record. Status
  shows Valid / Superseded / Altered since signing. The signer is emailed
- Signed entries (and their sub-components) can't be edited or deleted;
  a correction entry, once signed, supersedes the original (kept)
- Owners invite an outside mechanic by email to sign one entry: one-time,
  14-day link; they create or use their own account and certificate and
  see only that entry
- Admins can disable accounts (signed out, can't sign in or sign; past
  signatures kept); users with signatures can't be deleted
- Printouts show the electronic signature and fingerprint; archives carry
  signatures (marked imported, with their origin) and corrections

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 13:12:04 -05:00

272 lines
14 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 "prawn"
Prawn::Fonts::AFM.hide_m17n_warning = true # text is reduced to what the built-in fonts can show
# Logbook entries as a PDF to print and put in the paper logbook: on
# adhesive labels or on pages. Each entry carries what 14 CFR 43.9 / 43.11
# want (aircraft, date, airframe total time, the work, the signer's name and
# certificate) and a blank line for the signature, which must be signed by
# hand. Engine and propeller entries add the component's serial number, total
# time and time since overhaul (blanks to fill in when no component is linked),
# and a line for each sub-component the entry covers (an oil filter…).
#
# Labels: one entry per label; long entries shrink to fit, then continue on
# the next label. Pages: entries follow one another, each in a box with its
# signature line; one too long for a page continues in a box on the next.
class LogbookEntryPdf
IN = 72 # points per inch
Layout = Data.define(:key, :label, :page, :cols, :rows, :width, :height, :left, :top, :col_gap, :row_gap, :padding) do
def per_page = cols * rows
def labels? = per_page > 1 || page != [ width, height ]
end
LAYOUTS = [
Layout.new(key: "avery_5164", label: "Labels: Avery 5164 / 8164 (3⅓ × 4 in, 6 per sheet)", page: [ 8.5 * IN, 11 * IN ],
cols: 2, rows: 3, width: 4 * IN, height: 3.333 * IN, left: 0.156 * IN, top: 0.5 * IN,
col_gap: 0.188 * IN, row_gap: 0, padding: 0.15 * IN),
Layout.new(key: "avery_5163", label: "Labels: Avery 5163 / 8163 (2 × 4 in, 10 per sheet)", page: [ 8.5 * IN, 11 * IN ],
cols: 2, rows: 5, width: 4 * IN, height: 2 * IN, left: 0.156 * IN, top: 0.5 * IN,
col_gap: 0.188 * IN, row_gap: 0, padding: 0.12 * IN),
Layout.new(key: "half_letter", label: "Half-letter pages (5½ × 8½ in)", page: [ 5.5 * IN, 8.5 * IN ],
cols: 1, rows: 1, width: 5.5 * IN, height: 8.5 * IN, left: 0, top: 0, col_gap: 0, row_gap: 0, padding: 0.4 * IN),
Layout.new(key: "letter", label: "Letter pages (8½ × 11 in, also full-sheet labels)", page: [ 8.5 * IN, 11 * IN ],
cols: 1, rows: 1, width: 8.5 * IN, height: 11 * IN, left: 0, top: 0, col_gap: 0, row_gap: 0, padding: 0.6 * IN)
].freeze
# Type sizes: [small (details), body, smallest body when shrinking].
LABEL_SIZES = [ 6.5, 8, 5.5 ].freeze
PAGE_SIZES = [ 9, 11, 11 ].freeze
BOX_PADDING = 8 # inside a page entry's box
BOX_GAP = 12 # between boxes
def self.layout(key) = LAYOUTS.find { _1.key == key } || LAYOUTS.first
def initialize(aircraft, entries, layout:, start_at: 1)
@aircraft = aircraft
@entries = entries
@layout = self.class.layout(layout)
@slot = (start_at.to_i - 1).clamp(0, @layout.per_page - 1) # skip used labels on the first sheet
end
def filename = "#{@aircraft.tail_number.downcase}-logbook-entries.pdf"
def render
info = { Title: "#{@aircraft.tail_number} logbook entries", Creator: "Simple Aircraft Manager" }
if @layout.labels?
@pdf = Prawn::Document.new(page_size: @layout.page, margin: 0, info: info)
@entries.each { place_on_labels(_1) }
else
@pdf = Prawn::Document.new(page_size: @layout.page, margin: @layout.padding, info: info)
@entries.each { place_on_pages(_1) }
@pdf.number_pages clean("#{@aircraft.tail_number} · page <page> of <total>"), at: [ 0, -@layout.padding / 2 ],
width: @pdf.bounds.width, align: :right, size: 7, color: "777777"
end
@pdf.render
end
private
# ---- Labels ----
def place_on_labels(entry)
remaining = body_text(entry)
continued = false
loop do
remaining = draw(entry, next_label, remaining, continued: continued, sizes: LABEL_SIZES, shrink: true, continue_note: "label")
break if remaining.blank?
continued = true
end
end
# The next free label: [x, y_top, width, height] inside its padding.
def next_label
if @slot >= @layout.per_page
@pdf.start_new_page
@slot = 0
end
col = @slot % @layout.cols
row = @slot / @layout.cols
@slot += 1
x = @layout.left + col * (@layout.width + @layout.col_gap) + @layout.padding
y = @layout.page[1] - @layout.top - row * (@layout.height + @layout.row_gap) - @layout.padding
[ x, y, @layout.width - 2 * @layout.padding, @layout.height - 2 * @layout.padding ]
end
# ---- Pages ----
def place_on_pages(entry)
remaining = body_text(entry)
continued = false
w = @pdf.bounds.width
loop do
needed = box_height(entry, remaining, w)
# A new page if the box doesn't fit here but would on a fresh page, or
# too little of this page is left to be worth starting it.
@pdf.start_new_page if needed > @pdf.cursor && (needed <= @pdf.bounds.height || @pdf.cursor < 160)
h = [ needed, @pdf.cursor ].min
top = @pdf.cursor
@pdf.stroke_color "444444"
@pdf.line_width 0.75
@pdf.stroke_rectangle [ 0, top ], w, h
inner = [ BOX_PADDING, top - BOX_PADDING, w - 2 * BOX_PADDING, h - 2 * BOX_PADDING ]
remaining = draw(entry, inner, remaining, continued: continued, sizes: PAGE_SIZES, shrink: false, continue_note: "page")
@pdf.move_cursor_to([ top - h - BOX_GAP, 0 ].max)
break if remaining.blank?
@pdf.start_new_page
continued = true
end
end
def box_height(entry, body, width)
small, base, = PAGE_SIZES
body_h = @pdf.height_of(clean(body), width: width - 2 * BOX_PADDING, size: base, leading: 1.5)
head_h = (detail_lines(entry).size + 1) * (small + 3) + 2
head_h + body_h + 8 + signature_block_height(small) + 2 * BOX_PADDING
end
# ---- One entry in an area (a label, or the inside of a page box) ----
# Draws the entry into [x, y_top, w, h]; returns the body text that didn't fit.
def draw(entry, (x, y, w, h), body, continued:, sizes:, shrink:, continue_note:)
small, base, min = sizes
leftover = nil
@pdf.bounding_box([ x, y ], width: w, height: h) do
@pdf.text_box clean(header_line), at: [ 0, h ], width: w * 0.68, height: small + 2, size: small, style: :bold, overflow: :truncate
@pdf.text_box clean("#{LogbookEntry::LOG_TYPES[entry.log_type]} log#{' (continued)' if continued}"),
at: [ w * 0.68, h ], width: w * 0.32, height: small + 2, size: small, align: :right, overflow: :truncate
line_y = h - small - 3
detail_lines(entry).each do |line|
@pdf.text_box clean(line), at: [ 0, line_y ], width: w, height: small + 2, size: small,
overflow: :shrink_to_fit, min_font_size: small - 1.5
line_y -= small + 3
end
footer_h = signature_block_height(small)
body_top = line_y - 2
fitting = { at: [ 0, body_top ], width: w, height: body_top - footer_h - 4, size: base }
fitting = shrink ? fitting.merge(leading: 1, overflow: :shrink_to_fit, min_font_size: min) : fitting.merge(leading: 1.5, overflow: :truncate)
leftover = @pdf.text_box(clean(body), **fitting)
signature_block(entry, w, footer_h, small, more: leftover.present? ? continue_note : nil)
end
leftover
end
def header_line
[ @aircraft.tail_number, [ @aircraft.make, @aircraft.model ].compact_blank.join(" ").presence,
(@aircraft.serial_number.present? ? "S/N #{@aircraft.serial_number}" : nil) ].compact.join(" · ")
end
# Date and airframe total time; for engine / propeller entries (or any with
# a component) the component's serial number, total time and since overhaul.
def detail_lines(entry)
airframe = entry.aircraft_hours_at_entry ? "#{hrs(entry.aircraft_hours_at_entry)} (#{@aircraft.time_basis})" : "________"
lines = [ "Date: #{entry.date&.strftime('%b %-d, %Y')} Airframe total time: #{airframe}" ]
component = entry.component
noun = component_noun(entry, component)
if component
model = [ component.manufacturer, component.model ].compact_blank.join(" ")
serial = component.serial_number.present? ? " S/N #{component.serial_number}" : " S/N __________"
lines << [ "#{noun}: #{model}#{serial}",
"#{noun} total time: #{blank_or_hours(entry.component_hours_at_entry)}",
"#{component.since_overhaul_abbreviation}: #{blank_or_hours(entry.component_since_overhaul_at_entry)}" ].join(" ")
elsif noun
lines << "#{noun}: ______________ S/N __________ #{noun} total time: ________ SMOH / SFOH: ________"
end
entry.parts.each do |part|
c = part.component
name = c.component_type&.name || "Part"
model = [ c.manufacturer, c.model ].compact_blank.join(" ")
lines << [ "#{name}: #{model}#{" S/N #{c.serial_number}" if c.serial_number.present?}",
"Total time: #{blank_or_hours(part.hours_at_entry)}",
"#{c.since_overhaul_abbreviation}: #{blank_or_hours(part.since_overhaul_at_entry)}" ].join(" ")
end
lines
end
def component_noun(entry, component)
return "Engine" if component&.engine? || (component.nil? && entry.log_type == "ENG")
return "Propeller" if component&.propeller? || (component.nil? && entry.log_type == "PROP")
component&.component_type&.name
end
def blank_or_hours(value) = value ? hrs(value) : "________"
def hrs(value) = ActiveSupport::NumberHelper.number_to_delimited(format("%.1f", value))
def signature_block_height(small) = (small + 3) * 3 + 6
def signature_block(entry, w, height, small, more:)
return electronic_signature_block(entry, w, height, small, more: more) if entry.signature
@pdf.bounding_box([ 0, height ], width: w, height: height) do
if more
@pdf.text_box "Continued on the next #{more}.", at: [ 0, height ], width: w, height: small + 2, size: small,
style: :italic, overflow: :truncate
end
line_y = height - (small + 3) * 1.6
@pdf.stroke_color "555555"
@pdf.line_width 0.5
@pdf.stroke_horizontal_line 0, w * 0.62, at: line_y
@pdf.text_box "Signature", at: [ 0, line_y - 1 ], width: w * 0.6, height: small, size: small - 1, overflow: :truncate
@pdf.text_box clean(certificate(entry)), at: [ w * 0.64, line_y + small + 1 ], width: w * 0.36, height: small * 2 + 4,
size: small, overflow: :shrink_to_fit, min_font_size: 5
who = [ entry.signoff_person.presence || "Name: ____________________", entry.signoff_location.presence ].compact.join(" · ")
@pdf.text_box clean(who), at: [ 0, line_y - small - 1 ], width: w, height: small + 2, size: small, overflow: :truncate
end
end
# Signed entries: who certified it, when, and the fingerprint to check it by.
def electronic_signature_block(entry, w, height, small, more:)
sig = entry.signature
@pdf.bounding_box([ 0, height ], width: w, height: height) do
top = height
if more
@pdf.text_box "Continued on the next #{more}.", at: [ 0, top ], width: w, height: small + 2, size: small, style: :italic, overflow: :truncate
end
top -= small + 3
@pdf.text_box clean("#{EntrySignature::LABEL} #{sig.signer_name}, #{sig.certificate_label} #{sig.certificate_number}" \
"#{' (SUPERSEDED BY A CORRECTION)' if entry.superseded?}"),
at: [ 0, top ], width: w, height: small + 2, size: small, style: :bold, overflow: :shrink_to_fit, min_font_size: 5
top -= small + 3
@pdf.text_box clean("Signed electronically #{sig.signed_at.utc.strftime('%Y-%m-%d %H:%M UTC')} · fingerprint #{sig.content_digest.first(16)}"),
at: [ 0, top ], width: w, height: small + 2, size: small - 1, overflow: :shrink_to_fit, min_font_size: 5
end
end
def certificate(entry)
kind = { "AP" => "A&P", "IA" => "A&P/IA", "A" => "A", "P" => "P", "REPAIR_STATION" => "Repair station", "REPAIRMAN" => "Repairman",
"PILOT" => "Pilot", "OTHER" => "" }[entry.signoff_certificate_type].to_s
number = entry.signoff_certificate_number.presence || "__________"
"#{kind.presence || 'Cert.'} No. #{number}"
end
# The entry text, plus the 43.11(a)(5) statement for an inspection whose
# result is recorded but whose text doesn't already certify it.
def body_text(entry)
text = entry.text.to_s.strip
return "#{text}\n\n#{entry.signature.statement}" if entry.signature
return text unless entry.entry_type == "INSPECTION" && entry.inspection_result.present? && !text.match?(/I certify/i)
type = inspection_kind(entry, text)
statement =
if entry.inspection_result == "approved"
"I certify that this aircraft has been inspected in accordance with #{type} inspection and was determined to be in airworthy condition."
else
"I certify that this aircraft has been inspected in accordance with #{type} inspection and a list of discrepancies and unairworthy items " \
"dated #{entry.date&.strftime('%b %-d, %Y')} has been provided for the aircraft owner or operator."
end
"#{text}\n\n#{statement}"
end
# "an annual" / "a 100-hour": from a linked inspection record, else the text.
def inspection_kind(entry, text)
name = entry.inspection_records.first&.inspection_type&.name.to_s.sub(/\s*\(.*\)\z/, "").sub(/\s*inspection\z/i, "").strip.downcase
name = "annual" if name.empty? && text.match?(/annual/i)
name = "100-hour" if name.empty? && text.match?(/100[- ]?h(ou)?r/i)
return "a ______________" if name.empty?
"#{name.match?(/\A[aeiou]/) ? 'an' : 'a'} #{name}"
end
# The built-in PDF fonts cover Windows-1252; anything else becomes "?".
def clean(text)
text.to_s.unicode_normalize(:nfc).encode("Windows-1252", invalid: :replace, undef: :replace, replace: "?").encode("UTF-8")
end
end