Flight School Management for Odoo 19

Flight School Management is a modular Odoo 19 addon suite for managing flight school operations. It covers fleet readiness, personnel records, training programs, document compliance, mission scheduling, and daily flight execution in one integrated workflow.

The suite is designed for aviation training organizations that need auditable records, structured training workflows, and operational visibility across students, instructors, aircraft, schedules, and completed flights.

• Key features
• Addon modules
• Requirements and dependencies
• Installation
• Configuration
• Usage examples
• Project structure
• Development and validation
• Documentation standards
• Contributing
• Security
• License

• Central settings and security: shared Flight School menus, departments, access groups, and system-wide configuration.
• Fleet management: aircraft categories, aircraft types, aircraft records, airworthiness state, maintenance thresholds, and certificate expiry tracking.
• People management: students, instructors, pilots, administrative staff, licenses, ranks, qualifications, English levels, medical classes, and linked Odoo user accounts.
• Training management: class types, training classes, enrollments, flight disciplines, flight activities, missions, hour requirements, completion tracking, and training dashboards.
• Document management: document types, entity links, upload workflows, version history, current-version previews, and expiry status synchronization.
• Scheduling: planned flights, routes, cancellation reasons, pilot functions, custom activities, crew-member search, conflict detection, batch scheduling, and timeline views.
• Flight operations: daily and simulator operations boards, scheduled-flight publishing, actual time tracking, cancellation workflows, ADD flights, schedule import, and controlled ledger corrections.
• Authoritative hour ledger: immutable, idempotent integer-minute postings for personnel identity totals, enrollment progress, aircraft utilization, and instructor workload.

Install the modules you need, or install the full suite for the complete end-to-end workflow.

The Flight School addons use standard Odoo modules (base, base_setup, auth_signup, mail, web, and bus) plus the external web_timeline addon for scheduling timeline views.

Important: Install or make web_timeline available in addons_path before installing fs_scheduling or the full suite.

This repository contains Odoo addons and does not vendor a separate Python requirements file. Install the Python packages required by your Odoo 19 server from the Odoo distribution you use, then add this repository to the server's addons_path.

The repository includes Node-based formatting tools for frontend/XML assets:

npm install
npx prettier --check "**/*.{js,xml,css,md}"

The commands below assume that odoo-bin is available from your Odoo 19 server installation and that this repository is cloned as a custom addons directory. Adjust paths for your deployment.

# Example custom addons location
mkdir -p /opt/odoo/custom/addons
cd /opt/odoo/custom/addons
git clone https://github.com/GM-327/odoo-Flight_School_Management.git Flight_School_Management

On Windows, place the repository in an Odoo addons path, for example:

git clone https://github.com/GM-327/odoo-Flight_School_Management.git D:\Odoo19\server\addons\Flight_School_Management

Example odoo.conf excerpt:

[options]
db_host = localhost
db_port = 5432
db_user = odoo
db_password = <set-a-secure-password>
addons_path = /opt/odoo/odoo/addons,/opt/odoo/custom/addons/Flight_School_Management,/opt/odoo/custom/addons

Use environment-specific secrets or protected configuration management for production credentials. Do not commit real database passwords.

Make sure web_timeline is present in one of the configured addons paths. It is required by fs_scheduling.

createdb flight_school

Alternatively, create the database from the Odoo database manager if it is enabled in your environment.

Install the complete suite from the command line:

odoo-bin -c /path/to/odoo.conf -d flight_school \
  -i fs_core,fs_access_control,fs_people,fs_fleet,fs_hour_ledger,fs_training,fs_documents,fs_scheduling,fs_flights \
  --stop-after-init

Or install the modules from Apps in Odoo after updating the apps list. Odoo will resolve manifest dependencies, but the recommended installation order is:

1. fs_core
2. fs_access_control
3. fs_people and fs_fleet
4. fs_hour_ledger
5. fs_training
6. fs_documents
7. fs_scheduling
8. fs_flights

odoo-bin -c /path/to/odoo.conf -d flight_school

After installation, open the Flight School menus in Odoo and configure the suite in this order:

1. Core settings and security
   • Assign users to the appropriate Flight School security groups.
   • Configure shared settings and departments.
2. Fleet
   • Configure aircraft categories and aircraft types.
   • Register aircraft with an authorized opening balance in HH:MM, status, maintenance dates, and certificate expiry dates.
3. People
   • Configure ranks, license types, qualification types, English levels, and medical classes.
   • Create students, instructors, pilots, and administrative staff.
   • Add qualifications and expiry dates.
4. Training
   • Configure disciplines, flight types, activities, class requirements, class types, and missions.
   • Create training classes and enroll students.
5. Documents
   • Configure document entity types and document types.
   • Upload required files and monitor expiry status from dashboards.
6. Scheduling
   • Configure pilot functions, routes, cancellation reasons, callsign settings, and buffer times.
   • Use the scheduling wizard to generate planned flights.
7. Flights
   • Configure operations board behavior.
   • Publish scheduled flights and manage daily operations.

1. Register aircraft categories, aircraft types, and aircraft.
2. Create instructor and student records.
3. Define class types, hour requirements, flight activities, and missions.
4. Create a training class and enroll students.

Example from an Odoo shell:

student = env['fs.student'].create({
    'name': 'Student Pilot',
    'callsign': 'SP01',
    'email': 'student@example.invalid',
})

training_class = env['fs.training.class'].create({
    'name': 'Initial Flight Training 2026-A',
    'class_type_id': class_type.id,
    'start_date': fields.Date.today(),
})

enrollment = env['fs.student.enrollment'].create({
    'student_id': student.id,
    'training_class_id': training_class.id,
    'instructor_id': instructor.id,
    'status': 'active',
})

1. Open the scheduling wizard.
2. Select active enrollments and available instructors.
3. Review generated lines, routes, aircraft types, and ADD missions.
4. Assign times, aircraft, and callsigns.
5. Confirm the schedule.
6. Publish the day to flight operations.

Example from an Odoo shell:

wizard = env['fs.scheduling.wizard'].create({
    'date': fields.Date.today(),
    'selected_enrollment_ids': [(6, 0, enrollment_ids)],
    'selected_instructor_ids': [(6, 0, instructor_ids)],
})
wizard.action_next_step()
wizard.action_schedule()

scheduled_flights = env['fs.scheduled.flight'].search([
    ('date', '=', fields.Date.today()),
])
scheduled_flights.action_publish_day()

flight = env['fs.flight'].search([('status', '=', 'scheduled')], limit=1)
flight.action_start_flight()
flight.write({
    'atd_minutes': 8 * 60,
    'ata_minutes': 9 * 60 + 12,
})
flight.action_complete_flight()

Completing a flight creates one immutable integer-minute ledger posting. Effective entries update identity, enrollment, instructor, and aircraft projections. A completed flight is corrected only through the Operations Manager reversal and repost workflow; direct aggregate edits are not supported.

Flight_School_Management/
|-- fs_core/                  # Shared settings, security, departments, menus
|-- fs_access_control/        # Functional department authorization
|-- fs_fleet/                 # Aircraft categories, types, records, dashboard
|-- fs_people/                # Personnel, qualifications, user links, dashboard
|-- fs_hour_ledger/           # Immutable minute postings and projections
|-- fs_training/              # Training classes, enrollments, missions, hours
|-- fs_documents/             # Document types, uploads, versions, expiry status
|-- fs_scheduling/            # Planned flights, crew view, wizard, timeline
|-- fs_flights/               # Operations boards, flight logs, hour updates
|-- .github/                  # Pull request templates and repository metadata
|-- .kilo/                    # Local automation commands and agent configs
|-- CONTRIBUTING.md           # Contribution guidelines
|-- SECURITY.md               # Security policy
|-- LICENSE                   # LGPL-3.0 license text
`-- README.md                 # Project overview and setup guide

Each addon contains its own manifest, security rules, data files, views, and module-specific README.rst.

# Upgrade the full suite after code changes
odoo-bin -c /path/to/odoo.conf -d flight_school \
  -u fs_core,fs_access_control,fs_people,fs_fleet,fs_hour_ledger,fs_training,fs_documents,fs_scheduling,fs_flights \
  --stop-after-init

odoo-bin -c /path/to/odoo.conf -d test_db --test-enable \
  -i fs_core,fs_access_control,fs_people,fs_fleet,fs_hour_ledger,fs_training,fs_documents,fs_scheduling,fs_flights \
  --stop-after-init

python -m compileall -q fs_core fs_access_control fs_people fs_fleet fs_hour_ledger fs_training fs_documents fs_scheduling fs_flights

If Node dependencies are installed, validate frontend/XML formatting:

npm install
npx prettier --check "**/*.{js,xml,css,md}"

Recommended checks before submitting a change:

• Start Odoo and upgrade affected modules.
• Exercise the changed workflow in the Odoo UI.
• Run Python syntax checks.
• Run relevant Odoo tests.
• Update module README.rst files and docstrings when behavior changes.

• Root-level documentation belongs in this README.md.
• Module-specific documentation belongs in each addon's README.rst.
• Python modules, models, public methods, wizards, and migrations use Google-style docstrings.
• Complex or non-obvious business logic should include concise inline comments.
• Links should be checked when documentation is updated.

Contributions are welcome. See CONTRIBUTING.md for the full process.

Basic contribution workflow:

1. Fork the repository.
2. Create a focused feature or fix branch.
3. Follow existing Odoo and Flight School coding patterns.
4. Add or update tests and documentation where appropriate.
5. Run validation checks locally.
6. Open a pull request with a clear summary and testing notes.

Do not open public issues for security vulnerabilities. Follow the reporting process in SECURITY.md.

Production recommendations:

• Use HTTPS.
• Keep Odoo and addon dependencies updated.
• Restrict PostgreSQL and Odoo administration access.
• Set list_db = False for public deployments.
• Use strong passwords and, where possible, two-factor authentication.
• Maintain tested backups.

This project is licensed under the GNU Lesser General Public License v3.0 or later (LGPL-3.0-or-later). See LICENSE for details.

• Odoo S.A. for the Odoo ERP framework.
• European Union Aviation Safety Agency (EASA) for aviation safety references.
• Flight School Management contributors and maintainers.