Update dependency eslint to v9.39.5

Reviewed-on: #12

package.json

@@ -32,24 +32,27 @@
     "graphql": "^16.12.0",
     "mercurius": "^16.7.0",
     "mysql2": "^3.16.2",
+    "node-addon-api": "^8.7.0",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1",
+    "sharp": "^0.35.0",
     "typeorm": "^0.3.28"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.2.0",
-    "@eslint/js": "^9.18.0",
+    "@eslint/js": "^9.39.2",
     "@nestjs/cli": "^11.0.0",
     "@nestjs/schematics": "^11.0.0",
     "@nestjs/testing": "^11.0.1",
     "@types/jest": "^30.0.0",
-    "@types/node": "^22.10.7",
-    "@types/supertest": "^6.0.2",
-    "eslint": "^9.18.0",
+    "@types/node": "^22.20.0",
+    "@types/supertest": "^7.0.0",
+    "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-prettier": "^5.2.2",
     "globals": "^16.0.0",
     "jest": "^30.0.0",
+    "node-gyp": "^12.3.0",
     "prettier": "^3.4.2",
     "source-map-support": "^0.5.21",
     "supertest": "^7.0.0",

src/app.module.ts

@@ -11,6 +11,7 @@ import { FormularEntity } from './formular/formular.entity';
 import { FieldEntity } from './formular/fields.entity';
 import { FormResultEntity } from './formular/result.entity';
 import { FormResultsEntity } from './formular/results.entity';
+import { GalerieModule } from './galerie/galerie.module';
 
 @Module({
 	imports: [
@@ -31,6 +32,7 @@ import { FormResultsEntity } from './formular/results.entity';
 			entities: [EventEntity, FormularEntity,FieldEntity,FormResultEntity,FormResultsEntity]
 		}),
 		FormularModule,
+		GalerieModule
 		
 	],
   controllers: [AppController],

src/galerie/galerie.controller.ts

@@ -0,0 +1,118 @@
+import { Controller, Get, Header, Inject, Param, Res } from '@nestjs/common';
+import { GalerieService } from './galerie.service';
+import sharp from 'sharp';
+import path from 'path';
+import { Args, Field, ObjectType, Query, Resolver } from '@nestjs/graphql';
+import { JahrMitBild } from 'src/dto/galerie.dto';
+
+@Controller('/api/galerie')
+export class GalerieController {
+  constructor(
+    @Inject()
+    private readonly galerieService: GalerieService,
+  ) {}
+
+  @Get('/bilder/:event/:jahr')
+  async getBilder(
+    @Param('event') event: string,
+    @Param('jahr') jahr: number,
+  ): Promise<string[]> {
+    return this.galerieService.getBilder(event, jahr);
+  }
+
+  @Get('/jahre/:event')
+  async getJahre(@Param('event') event: string): Promise<JahrMitBild[]> {
+    return this.galerieService.getJahre(event);
+  }
+
+  @Get('/bild/:event/:jahr/:bild')
+  @Header('Content-Type', 'image/png')
+  async getBild(
+    @Param('event')
+    event: string,
+    @Param('jahr')
+    jahr: number,
+    @Param('bild')
+    bild: string,
+  ): Promise<Buffer> {
+    const filePath =
+      '/bilder/' +
+      path.basename(event) +
+      '/' +
+      path.basename(jahr.toString()) +
+      '/' +
+      path.basename(bild);
+
+    return sharp(filePath).png().toBuffer();
+  }
+  @Get('/randomimage/:event')
+  @Header('Content-Type', 'image/png')
+  async getRandomImageOhneJahr(
+    @Param('event')
+    event: string,
+  ): Promise<Buffer> {
+    const jahr=await this.galerieService.getRandomYear(event)
+    const filePath =
+      '/bilder/' +
+      path.basename(event) +
+      '/' +
+      jahr+
+      '/' +
+      await this.galerieService.getRandomImage(event,jahr)
+
+    return sharp(filePath).png().toBuffer();
+  }
+  @Get('/randomimage/:event/:jahr')
+  @Header('Content-Type', 'image/png')
+  async getRandomImage(
+    @Param('event')
+    event: string,
+    @Param('jahr')
+    jahr: number,
+  ): Promise<Buffer> {
+    const filePath =
+      '/bilder/' +
+      path.basename(event) +
+      '/' +
+      path.basename(jahr.toString()) +
+      '/' +
+      await this.galerieService.getRandomImage(event,jahr)
+
+    return sharp(filePath).png().toBuffer();
+  }
+}
+
+@Resolver()
+export class GalerieResolver {
+  constructor(private readonly galerieService: GalerieService) {}
+
+  @Query(() => [String])
+  async getBilder(
+    @Args('event', { type: () => String }) event: string,
+    @Args('jahr', { type: () => Number }) jahr: number,
+  ): Promise<string[]> {
+    return this.galerieService.getBilder(event, jahr);
+  }
+
+  @Query(() => [JahrMitBildEntity])
+  async bilder(
+    @Args('event', { type: () => String }) event: string,
+    @Args('jahr', { type: () => Number, nullable: true }) jahr: number,
+  ): Promise<JahrMitBildEntity[]> {
+    if(jahr==null) return this.galerieService.getJahre(event);
+    return (await this.galerieService.getJahre(event))
+    .filter(jahrmitbild=>jahrmitbild.jahr==jahr);
+  }
+}
+
+@ObjectType()
+export class JahrMitBildEntity implements JahrMitBild {
+  @Field(() => Number)
+  jahr: number;
+  @Field(() => [String])
+  bild: string[];
+  constructor(jahr: number, bild: string[]) {
+    this.jahr = jahr;
+    this.bild = bild;
+  }
+}

src/galerie/galerie.module.ts

@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { GalerieController, GalerieResolver } from './galerie.controller';
+import { GalerieService } from './galerie.service';
+
+@Module({
+    imports:[
+        TypeOrmModule.forFeature([])
+    ],
+    controllers: [
+        GalerieController
+    ],
+    providers: [
+        GalerieService, GalerieResolver
+    ]
+})
+export class GalerieModule {}

src/galerie/galerie.service.ts

@@ -0,0 +1,61 @@
+import { Injectable } from "@nestjs/common";
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { JahrMitBild } from "src/dto/galerie.dto";
+
+@Injectable()
+export class GalerieService {
+    private readonly imagesPath = "/bilder";
+
+    constructor(
+    ){}
+
+    async getBilder(
+        event: string,
+        jahr: number
+    ): Promise<string[]> {
+        const files= await fs.readdir(path.join(this.imagesPath,event, jahr.toString()));
+
+        // Nur Bilddateien filtern
+        const imageFiles = files.filter(file =>
+            /\.(jpg|jpeg|png|gif|webp)$/i.test(file)
+        );
+
+        return imageFiles;
+    }
+
+    async getJahre(
+        event: string
+    ): Promise<JahrMitBild[]> {
+        const files= await fs.readdir(path.join(this.imagesPath,event).toString());
+        
+        // Nur Verzeichnisse filtern (Jahre)
+        const directories: JahrMitBild[] = [];
+        for (const file of files) {
+            const filePath = path.join(this.imagesPath, event, file);
+            const stat = await fs.stat(filePath);
+            if (stat.isDirectory()) {
+                directories.push(new JahrMitBild(parseInt(file), await this.getBilder(event,parseInt(file))));
+            }
+        }
+        return directories;
+    }
+
+    async getRandomImage(event: string, jahr: number): Promise<string>{
+
+        const bilder=await this.getBilder(event,jahr);
+        
+        const index = Math.floor(Math.random() * bilder.length);
+
+        return bilder[index];
+
+    }
+
+    async getRandomYear(event:string): Promise<number>{
+        const jahre=(await this.getJahre(event)).map((jahr)=>jahr.jahr);
+        
+        const index = Math.floor(Math.random() * jahre.length);
+        return jahre[index];
+    }
+
+}