update the weather data

src/inbound/inbound.controller.ts

@@ -8,10 +8,13 @@ import {
   HttpStatus,
 } from '@nestjs/common';
 import { ApiBody, ApiQuery, ApiResponse } from '@nestjs/swagger';
+import { WGS84 } from '../math';
+import { WeatherService } from 'src/weather/weather.service';
 import { AirportService } from '../airport/airport.service';
 import { CoordinateConverter, WaypointConverter } from '../generic/converters';
 import { CoordinateDto } from '../generic/dto/coordinate.dto';
 import { WaypointDto } from '../generic/dto/waypoint.dto';
+import { PerformanceService } from '../performance/performance.service';
 import { AircraftDto } from './dto/aircraft.dto';
 import { ControllerInputDto } from './dto/controllerinput.dto';
 import { FlightStateDto } from './dto/flightstate.dto';
@@ -31,6 +34,8 @@ export class InboundController {
   constructor(
     private readonly inboundService: InboundService,
     private readonly airportService: AirportService,
+    private readonly performanceService: PerformanceService,
+    private readonly weatherService: WeatherService,
   ) {}
 
   private static convertAircraft<T>(aircraft: Aircraft | AircraftDto): T {
@@ -196,22 +201,54 @@ export class InboundController {
     description: 'The destination airport is unknown',
   })
   async insert(inbound: InboundDto): Promise<boolean> {
-    return this.airportService.airport(inbound.destination).then((airport) => {
+    return this.airportService
+      .airport(inbound.destination)
+      .then(async (airport) => {
         if (!airport) {
           throw new HttpException('Airport not found', HttpStatus.NOT_FOUND);
         }
 
-      return this.inboundService
-        .callsignKnown(inbound.callsign)
-        .then((known) => {
+        // update the weather data
+        if (inbound.controllerData.remainingRoute.length >= 1) {
+          await this.weatherService.update(
+            inbound.destination,
+            inbound.controllerData.remainingRoute[0].identifier,
+            WGS84.distance(
+              {
+                lat: inbound.flightState.position.latitude,
+                lon: inbound.flightState.position.longitude,
+              },
+              {
+                lat: inbound.controllerData.remainingRoute[0].coordinate
+                  .latitude,
+                lon: inbound.controllerData.remainingRoute[0].coordinate
+                  .longitude,
+              },
+            ) * 0.000539957,
+            inbound.flightState.groundSpeed,
+            inbound.flightState.heading,
+            inbound.flightState.groundTrack,
+            inbound.flightState.altitude,
+          );
+        }
+
+        const performance = await this.performanceService.findAircraft(
+          inbound.aircraft.type,
+          inbound.aircraft.wtc,
+          inbound.aircraft.engineCount,
+        );
         const internalInbound =
           InboundController.convertInboundDtoInbound(inbound);
 
+        // TODO calculate remaining route predictions
+
+        return this.inboundService
+          .callsignKnown(inbound.callsign)
+          .then((known) => {
             if (known) {
               return this.inboundService.update(internalInbound);
-          } else {
-            return this.inboundService.add(internalInbound);
             }
+            return this.inboundService.add(internalInbound);
           });
       });
   }

src/inbound/inbound.module.ts

@@ -4,11 +4,15 @@ import { InboundSchema } from './models/inbound.model';
 import { InboundService } from './inbound.service';
 import { InboundController } from './inbound.controller';
 import { AirportModule } from '../airport/airport.module';
+import { PerformanceModule } from '../performance/performance.module';
+import { WeatherModule } from '../weather/weather.module';
 
 @Module({
   imports: [
     MongooseModule.forFeature([{ name: 'inbound', schema: InboundSchema }]),
     AirportModule,
+    PerformanceModule,
+    WeatherModule,
   ],
   providers: [InboundService],
   controllers: [InboundController],