Lost Keys

api/src/model/entitites/key.entity.ts

@@ -29,8 +29,11 @@ export class Key implements IKey {
   @Column({ name: 'handed_out', default: false })
   handedOut: boolean;
 
-  @Column({ name: 'lost', default: false })
-  keyLost: boolean;
+  @Column({ name: 'lost', default: null })
+  keyLost: Date;
+
+  @Column({ name: 'is_digital', default: false })
+  digital: boolean;
 
   @ManyToMany(() => Cylinder, (cylinder) => cylinder.keys)
   @JoinTable()

api/src/model/interface/key.interface.ts

@@ -8,4 +8,6 @@ export interface IKey {
   cylinder: Cylinder[];
   customer: Customer;
   createdAt: Date;
+  digital: boolean;
+  keyLost: Date;
 }

api/src/modules/cylinder/cylinder.service.ts

@@ -1,7 +1,7 @@
 import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
 import { Cylinder, User } from 'src/model/entitites';
 import { ActivityRepository, CylinderRepository, KeyRepository } from 'src/model/repositories';
-import { ManageHelperService } from 'src/shared/service/system.helper.service';
+import { HelperService } from 'src/shared/service/system.helper.service';
 
 @Injectable()
 export class CylinderService {
@@ -9,7 +9,7 @@ export class CylinderService {
     private readonly cylinderRepo: CylinderRepository,
     private readonly keyRepo: KeyRepository,
     private systemActivityRepo: ActivityRepository, 
-    private readonly helper: ManageHelperService
+    private readonly helper: HelperService
   ) {}
 
   async getCylinders(user: User): Promise<Cylinder[]> {

api/src/modules/key/key.controller.ts

@@ -24,6 +24,11 @@ export class KeyController {
     return this.service.getUsersKeys(req.user);
   }
 
+  @Get('lost')
+  getLostKeys(@Req() req: AuthenticatedRequest) {
+    return this.service.getLostKeys(req.user);
+  }
+
   @Post()
   postKey(@Req() req: AuthenticatedRequest, @Body() key: Key) {
     return this.service.createKey(req.user, key);

api/src/modules/key/key.service.ts

@@ -1,14 +1,13 @@
 import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
 import { Customer, Cylinder, Key, User } from 'src/model/entitites';
-import { IUser } from 'src/model/interface';
 import {
-  ActivityRepository,
   CylinderRepository,
   KeyRepository,
   KeySystemRepository,
 } from 'src/model/repositories';
 import { KeyHandoutRepository } from 'src/model/repositories/key-handout.repository';
 import { ActivityHelperService } from 'src/shared/service/activity.logger.service';
+import { HelperService } from 'src/shared/service/system.helper.service';
 import { IsNull, Not } from 'typeorm';
 
 @Injectable()
@@ -16,14 +15,25 @@ export class KeyService {
   constructor(
     private readonly keyrepository: KeyRepository,
     private readonly cylinderRepository: CylinderRepository,
-    private readonly systemRepo: KeySystemRepository,
-    private handoverRepo: KeyHandoutRepository,
-    private readonly activityService: ActivityHelperService
+    private readonly handoverRepo: KeyHandoutRepository,
+    private readonly activityService: ActivityHelperService,
+    private readonly helper: HelperService,
   ) {}
 
   async getUsersKeys(user: User): Promise<Key[]> {
     const keys = await this.keyrepository.find({
-      where: { cylinder: { system: { managers: { id: user.id } } } },
+      where: { cylinder: { system: { managers: { id: user.id } } }, keyLost: IsNull() },
+      relations: ['cylinder', 'cylinder.system', 'customer'],
+    });
+    for (let k of keys) {
+      k.customer = await this.getCustomerOfLastHandout(user, k.id);
+    }
+    return keys;
+  }
+
+  async getLostKeys(user: User): Promise<Key[]> {
+    const keys = await this.keyrepository.find({
+      where: { cylinder: { system: { managers: { id: user.id } } }, keyLost: Not(IsNull()) },
       relations: ['cylinder', 'cylinder.system', 'customer'],
     });
     for (let k of keys) {
@@ -36,10 +46,19 @@ export class KeyService {
     if (!user || !user.id) {
       throw new HttpException('forbidden', HttpStatus.FORBIDDEN);
     }
-    await this.keyrepository.findOneOrFail({
-      where: { cylinder: { system: { managers: { id: user.id } } } },
+
+    const k = await this.keyrepository.findOneOrFail({
+      where: { id: key.id, cylinder: { system: { managers: { id: user.id } } } },
+      relations: ['cylinder', 'cylinder.system'],
+      withDeleted: true
     });
 
+    if (k.name != key.name) {
+      await this.activityService.logKeyRenamed(user, key, key.cylinder[0].system, k.name);
+    }
+    if (k.keyLost != key.keyLost) {
+      await this.activityService.logKeyLostUpdate(user, key, key.keyLost);
+    }
     return this.keyrepository.save(this.keyrepository.create(key));
   }
 
@@ -121,6 +140,7 @@ export class KeyService {
     const key = await this.keyrepository.findOneOrFail({
       where: { id, cylinder: { system: { managers: { id: user.id } } } },
     });
+    await this.activityService.logDeleteKey(user, key);
     return this.keyrepository.softRemove(key);
   }
 
@@ -136,11 +156,14 @@ export class KeyService {
   }
 
   async restoreKey(user: User, keyID: string) {
+    
     const key = await this.keyrepository.findOneOrFail({
       where: { cylinder: { system: { managers: { id: user.id } } }, id: keyID },
       withDeleted: true,
     });
     key.deletedAt = null;
+    await this.activityService.logKeyRestored(user, key);
+    await this.helper.deleteKeyArchiveCache();
     return this.keyrepository.save(key);
   }
 }

api/src/modules/user/user.service.ts

@@ -2,7 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { User } from 'src/model/entitites';
 import { IUser } from 'src/model/interface';
 import { ActivityRepository, KeySystemRepository, RoleRepository, UserRepository } from 'src/model/repositories';
-import { ManageHelperService } from 'src/shared/service/system.helper.service';
+import { HelperService } from 'src/shared/service/system.helper.service';
 @Injectable()
 export class UserService {
   constructor(
@@ -10,7 +10,7 @@ export class UserService {
     private readonly roleRepo: RoleRepository,
     private readonly systemRepo: KeySystemRepository,
     private readonly systemActivityRepo: ActivityRepository,
-    private readonly helper: ManageHelperService,
+    private readonly helper: HelperService,
   ) {}
 
   getAllUsers(): Promise<User[]> {

api/src/shared/service/activity.logger.service.ts

@@ -2,11 +2,13 @@ import { Injectable } from "@nestjs/common";
 import { Key, KeyHandout, User } from "src/model/entitites";
 import { KeySystem } from "src/model/entitites/system.entity";
 import { ActivityRepository, CylinderRepository, KeyRepository } from "src/model/repositories";
+import { HelperService } from "./system.helper.service";
 
 @Injectable()
 export class ActivityHelperService {
 
   constructor(
+    private readonly helper: HelperService,
     private readonly activityRepo: ActivityRepository,
     private readonly keyRepository: KeyRepository,
     private readonly cylinderRepo: CylinderRepository,
@@ -54,8 +56,8 @@ export class ActivityHelperService {
     }))
   }
 
-  async logKeyRenamed(user: User, key: Key, system: KeySystem) {
-    let msg = `Schlüssel ${key.nr} in ${key.name} umbenannt`;
+  async logKeyRenamed(user: User, key: Key, system: KeySystem, oldName?: string) {
+    let msg = `Schlüssel ${key.nr} ${oldName ? 'von ' + oldName + ' in ' : ''}in ${key.name} umbenannt`;
     this.activityRepo.save(
       this.activityRepo.create({
       system,
@@ -64,6 +66,31 @@ export class ActivityHelperService {
     }))
   }
 
+  /**
+   * Logs when a key is reported as lost or misplaced in the system.
+   * 
+   * @param user - The user who reported the key as lost
+   * @param key - The key that was reported as lost
+   * @param system - The key system the lost key belongs to
+   * @param lostDate - The date when the key was reported as lost
+   */
+  async logKeyLostUpdate(user: User, key: Key,lostDate: Date | string) {
+    const sys = await this.helper.getSystemOfKey(key);
+    let msg;
+    if (lostDate == null) {
+      msg = `Schlüssel ${key.nr} als gefunden gemeldet`;
+    } else {
+       msg = `Schlüssel ${key.nr} als verloren gemeldet`
+    }
+    this.activityRepo.save(
+      this.activityRepo.create({
+        system: sys,
+        user,
+        message: msg,
+      })
+    )
+  }
+
   logKeyHandover(user: User, key: Key, system: KeySystem, handover: KeyHandout) {
 
     const msg = `Schlüssel ${key.nr} ${handover.direction == 'out' ? 'ausgegeben an ' : 'zurückgegeben von '}${handover.customer.name}`
@@ -75,4 +102,17 @@ export class ActivityHelperService {
     }))
 
   }
+
+  async logKeyRestored(user: User, key: Key) {
+    let msg = `Schlüssel ${key.nr} wiederhergestellt`;
+
+    const system: KeySystem = await this.helper.getSystemOfKey(key);
+
+    this.activityRepo.save(
+      this.activityRepo.create({
+      system,
+      user,
+      message: msg,
+    }))
+  }
 }

api/src/shared/service/shared.service.module.ts

@@ -1,14 +1,15 @@
 import { Module } from "@nestjs/common";
 import { DatabaseModule } from "../database/database.module";
-import { ManageHelperService } from "./system.helper.service";
+import { HelperService } from "./system.helper.service";
 import { CylinderRepository, KeySystemRepository } from "src/model/repositories";
 import { Cylinder, User } from "src/model/entitites";
 import { ActivityHelperService } from "./activity.logger.service";
+import { CacheModule } from "@nestjs/cache-manager";
 
 @Module({
   imports: [ DatabaseModule ],
-  providers: [ ManageHelperService, ActivityHelperService ],
-  exports: [ ManageHelperService, ActivityHelperService ],
+  providers: [ HelperService, ActivityHelperService ],
+  exports: [ HelperService, ActivityHelperService ],
 })
 
 export class SharedServiceModule {

api/src/shared/service/system.helper.service.ts

@@ -1,14 +1,17 @@
-import { Injectable } from "@nestjs/common";
+import { Inject, Injectable } from "@nestjs/common";
 import { User, Cylinder, Key } from "src/model/entitites";
+import { KeySystem } from "src/model/entitites/system.entity";
 import { KeySystemRepository, CylinderRepository, KeyRepository } from "src/model/repositories";
+import { Cache } from "@nestjs/cache-manager";
 
 @Injectable()
-export class ManageHelperService {
+export class HelperService {
 
   constructor(
     private readonly systemRepository: KeySystemRepository,
     private readonly cylinderRepository: CylinderRepository,
     private readonly keyRepo: KeyRepository,
+    private cacheManager: Cache
   ) {}
 
 
@@ -35,4 +38,24 @@ export class ManageHelperService {
     });
     return keys;
   }
+
+  async getSystemOfKey(key: Key): Promise<KeySystem> {
+    const k = await this.keyRepo.findOne({
+      where: { id: key.id },
+      relations: ['cylinder', 'cylinder.system'],
+      withDeleted: true,
+    });
+    this.cache()
+    const found = k.cylinder.find(c => c.system != null);
+    return found.system;
+  }
+
+  async cache() {
+    const value = await this.cacheManager.store.keys()
+    console.log(value)
+  }
+
+  async deleteKeyArchiveCache() {
+    await this.cacheManager.del('/key/archive');
+  }
 }