Crew Rostering Integration

Connect existing rostering systems with CrewOps and Crew Management — automatically ensure FTL compliance.

The Problem

Many airlines use legacy rostering systems (AIMS, Jeppesen Crew Planning, etc.) that do not offer a modern REST API. Changes must be maintained twice. FTL violations are only discovered during manual review.

Solution: CrewOps as FTL Layer

CrewOps sits as a validating layer between your rostering system and operational crew scheduling:

Legacy Rostering → CrewOps API → FTL Validation → Assignment
                                         ↓ Violation?
                              Rejection + Reason → Rostering

Import FTL-compliant Roster

import-roster.jsJavaScript
const CREW_OPS_BASE = "https://api.aeroselect.io/api/v1/crewops";

async function importRosterFromLegacySystem(rosterData) {
  const results = { success: [], failed: [] };

  for (const duty of rosterData.duties) {
    const res = await fetch(`${CREW_OPS_BASE}/duties`, {
      method: "POST",
      headers: {
        "X-API-Key": process.env.AEROSELECT_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        crew_member_id: await resolveCrewMemberId(duty.crew_id),
        flight_ids: await resolveFlightIds(duty.flight_numbers),
        report_time_utc: duty.report_time,
        duty_type: "flight_duty",
      }),
    });

    const data = await res.json();

    if (res.ok) {
      results.success.push(duty);
    } else if (res.status === 422) {
      // FTL violation — send back to rostering system
      results.failed.push({
        duty,
        reason: data.errors,
      });
      console.warn(`FTL violation: ${duty.crew_id} — ${JSON.stringify(data.errors)}`);
    }
  }

  return results;
}

Check Qualifications Before Assignment

Mandatory Check

Check a crew member's qualifications before every duty assignment. A crew member without a valid type rating for the aircraft type is not deployable.
qualification-check.jsJavaScript
const CREW_BASE = "https://api.aeroselect.io/api/v1/crew";

async function isCrewMemberQualifiedForFlight(
  crewMemberId: number,
  aircraftType: string
) {
  const res = await fetch(
    `${CREW_BASE}/crew/${crewMemberId}/qualifications?type=type_rating`,
    { headers: { "X-API-Key": process.env.AEROSELECT_API_KEY } }
  );
  const { data: qualifications } = await res.json();

  const rating = qualifications.find(
    (q) => q.name === aircraftType && q.status === "valid"
  );

  return {
    qualified: !!rating,
    rating,
    reason: rating
      ? null
      : `No valid type rating for ${aircraftType}`,
  };
}

// Usage before duty assignment
const check = await isCrewMemberQualifiedForFlight(201, "A320");
if (!check.qualified) {
  throw new Error(check.reason);
}

Automatic Crew Swap on Unavailability

auto-swap.jsJavaScript
async function findAndSwapCrew(
  flightId: number,
  unavailableMemberId: number,
  aircraftType: string
) {
  // 1. Fetch all crew members with matching type rating
  const crewRes = await fetch(
    `${CREW_BASE}/crew?status=active&per_page=100`,
    { headers: { "X-API-Key": API_KEY } }
  );
  const { data: allCrew } = await crewRes.json();

  // 2. Find qualified and available crew
  for (const member of allCrew) {
    if (member.id === unavailableMemberId) continue;

    const [qualCheck, availCheck] = await Promise.all([
      isCrewMemberQualifiedForFlight(member.id, aircraftType),
      checkCrewAvailability(member.id),
    ]);

    if (qualCheck.qualified && availCheck.available) {
      // 3. Perform swap
      const swapRes = await fetch(
        `${CREW_OPS_BASE}/flights/${flightId}/crew`,
        {
          method: "PATCH",
          headers: { ...headers, "Content-Type": "application/json" },
          body: JSON.stringify({
            remove_crew_member_id: unavailableMemberId,
            add_crew_member_id: member.id,
            reason: "Automated swap — crew member unavailable",
          }),
        }
      );

      if (swapRes.ok) {
        return { success: true, new_crew: member };
      }
    }
  }

  return { success: false, reason: "No qualified replacement available" };
}