Merge pull request #29 from EVNotify/stations-association

✨ Stations association

Author: GPlay97

src/logs/handler/station-association.handler.ts

@@ -0,0 +1,89 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { LOG_FINISHED_EVENT } from '../entities/log.entity';
+import { Log } from '../schemas/log.schema';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model, Types } from 'mongoose';
+import { LogsService } from '../logs.service';
+import { TYPE } from '../entities/type.entity';
+import { HISTORY_TYPE } from '../entities/history-type.entity';
+import { Station } from '../../stations/schemas/station.schema';
+import { MissingStation } from '../../stations/schemas/missing-station.schema';
+
+@Injectable()
+export class StationAssociationHandler {
+  constructor(
+    private readonly logsService: LogsService,
+    @InjectModel(Station.name) private readonly stationModel: Model<Station>,
+    @InjectModel(MissingStation.name) private readonly missingStationModel: Model<MissingStation>,
+    @InjectModel(Log.name) private readonly logModel: Model<Log>,
+  ) {}
+
+  @OnEvent(LOG_FINISHED_EVENT)
+  async handleFinished(log: Log) {
+    try {
+      if (log.type !== TYPE.CHARGE) {
+        return;
+      }
+
+      const history = await this.logsService.findOneWithHistory(log.akey, log._id.toString(), HISTORY_TYPE.LOCATION_DATA);
+
+      const firstWithLocation = history.find((entry) => entry.latitude != null && entry.longitude != null);
+
+      if (!firstWithLocation) {
+        return;
+      }
+
+      const latitude = firstWithLocation.latitude;
+      const longitude = firstWithLocation.longitude;
+
+      await this.stationModel.ensureIndexes();
+
+      const results = await this.stationModel.aggregate([
+        {
+          $geoNear: {
+            near: { type: 'Point', coordinates: [longitude, latitude] },
+            distanceField: 'distance',
+            spherical: true,
+            maxDistance: 200,
+            key: 'location',
+          },
+        },
+        { $sort: { distance: 1 } },
+        { $limit: 1 },
+      ]);
+
+      if (results.length) {
+        const stationDoc = results[0];
+
+        await this.logModel.updateOne({ _id: log._id, akey: log.akey }, { $set: { station: stationDoc._id } });
+      } else {
+        await this.missingStationModel.ensureIndexes();
+
+        const msResults = await this.missingStationModel.aggregate([
+          {
+            $geoNear: {
+              near: { type: 'Point', coordinates: [longitude, latitude] },
+              distanceField: 'distance',
+              spherical: true,
+              maxDistance: 200,
+              key: 'location',
+            },
+          },
+          { $sort: { distance: 1 } },
+          { $limit: 1 },
+        ]);
+
+        if (!msResults.length) {
+          await this.missingStationModel.create({
+            akey: log.akey,
+            logRef: log._id,
+            location: { type: 'Point', coordinates: [longitude, latitude] },
+          });
+        }
+      }
+    } catch (error) {
+      Logger.error('Error in StationAssociationHandler', error);
+    }
+  }
+}

src/logs/logs.module.ts

@@ -9,18 +9,23 @@ import { LastSyncHandler } from './handler/last-sync';
 import { LastSync, LastSyncSchema } from './schemas/last-sync.schema';
 import { CronHandler } from './handler/cron';
 import { PremiumModule } from '../premium/premium.module';
+import { Station, StationSchema } from '../stations/schemas/station.schema';
+import { MissingStation, MissingStationSchema } from '../stations/schemas/missing-station.schema';
+import { StationAssociationHandler } from './handler/station-association.handler';
 
 @Module({
   controllers: [LogsController],
-  providers: [LogsService, MetadataHandler, LastSyncHandler, CronHandler],
   imports: [
     AccountModule,
     MongooseModule.forFeature([
       { name: Log.name, schema: LogSchema },
       { name: LastSync.name, schema: LastSyncSchema },
+      { name: Station.name, schema: StationSchema },
+      { name: MissingStation.name, schema: MissingStationSchema },
     ]),
     PremiumModule,
   ],
+  providers: [LogsService, MetadataHandler, LastSyncHandler, CronHandler, StationAssociationHandler],
   exports: [LogsService],
 })
 export class LogsModule {}

src/logs/schemas/log.schema.ts

@@ -124,6 +124,9 @@ export class Log {
 
   @Prop()
   thresholdReached: Date;
+
+  @Prop({ type: Types.ObjectId, ref: 'Station' })
+  station: Types.ObjectId;
 }
 
 export const LogSchema = SchemaFactory.createForClass(Log);

src/stations/schemas/missing-station.schema.ts

@@ -0,0 +1,38 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Document, Types } from 'mongoose';
+
+export type MissingStationDocument = MissingStation & Document;
+
+@Schema({ timestamps: true })
+export class MissingStation {
+  _id: Types.ObjectId;
+
+  @Prop({ required: true })
+  akey: string;
+
+  @Prop({ type: Types.ObjectId, ref: 'Log', required: true })
+  logRef: Types.ObjectId;
+
+  @Prop({
+    type: {
+      type: String,
+      enum: ['Point'],
+      default: 'Point',
+    },
+    coordinates: {
+      type: [Number],
+      required: true,
+    },
+  })
+  location: {
+    type: 'Point';
+    coordinates: [number, number];
+  };
+
+  @Prop()
+  note: string;
+}
+
+export const MissingStationSchema = SchemaFactory.createForClass(MissingStation);
+
+MissingStationSchema.index({ location: '2dsphere' });