0.9.0

README.md

@@ -78,10 +78,6 @@ For production environments, you can use the file `docker-compose.coding-box.pro
 
 ---
 
-## Key Features
-
-
----
 
 ## Useful Scripts
 

apps/backend/project.json

@@ -47,7 +47,7 @@
       }
     },
     "lint": {
-      "executor": "@nx/linter:eslint",
+      "executor": "@nx/eslint:lint",
       "outputs": [
         "{options.outputFile}"
       ],

apps/backend/src/app/admin/logo/logo.controller.ts

@@ -30,7 +30,7 @@ import { AppLogoDto } from '../../../../../../api-dto/app-logo-dto';
 @Controller('admin/logo')
 @ApiTags('admin')
 export class LogoController {
-  LOGO_PATH = path.join(process.cwd(), 'apps', 'frontend', 'src', 'assets', 'logo');
+  LOGO_PATH = path.join(process.cwd(), 'apps', 'frontend', 'src', 'assets', 'images');
   ALLOWED_MIME_TYPES = ['image/jpeg', 'image/png', 'image/gif', 'image/svg+xml', 'image/webp'];
   MAX_FILE_SIZE = 4 * 1024 * 1024; // 4MB
 
@@ -42,7 +42,7 @@ export class LogoController {
     FileInterceptor('logo', {
       storage: diskStorage({
         destination: (req, file, cb) => {
-          const uploadPath = path.join(process.cwd(), 'apps', 'frontend', 'src', 'assets');
+          const uploadPath = path.join(process.cwd(), 'apps', 'frontend', 'src', 'assets', 'images');
           if (!fs.existsSync(uploadPath)) {
             fs.mkdirSync(uploadPath, { recursive: true });
           }
@@ -93,7 +93,7 @@ export class LogoController {
     try {
       // Always return the consistent path to the uploaded file
       // This ensures the path matches the actual saved filename (logo + extension)
-      return { path: `assets/logo${path.extname(file.originalname)}` };
+      return { path: `assets/images/logo${path.extname(file.originalname)}` };
     } catch (error) {
       throw new InternalServerErrorException('Failed to upload logo');
     }
@@ -106,8 +106,8 @@ export class LogoController {
   @ApiOkResponse({ description: 'Logo deleted successfully', type: Boolean })
   async deleteLogo(): Promise<{ success: boolean }> {
     try {
-      // Find all files starting with 'logo' in the assets directory
-      const assetsDir = path.join(process.cwd(), 'apps', 'frontend', 'src', 'assets');
+      // Find all files starting with 'logo' in the images directory
+      const assetsDir = path.join(process.cwd(), 'apps', 'frontend', 'src', 'assets', 'images');
       const files = fs.readdirSync(assetsDir);
 
       let deleted = false;
@@ -119,7 +119,7 @@ export class LogoController {
       }
 
       // Delete logo settings file if it exists
-      const settingsPath = path.join(process.cwd(), 'apps', 'frontend', 'src', 'assets', 'logo-settings.json');
+      const settingsPath = path.join(process.cwd(), 'apps', 'frontend', 'src', 'assets', 'data', 'logo-settings.json');
       if (fs.existsSync(settingsPath)) {
         fs.unlinkSync(settingsPath);
       }
@@ -138,7 +138,13 @@ export class LogoController {
   @ApiOkResponse({ description: 'Logo settings saved successfully', type: Boolean })
   async saveLogoSettings(@Body() logoSettings: AppLogoDto): Promise<{ success: boolean }> {
     try {
-      const settingsPath = path.join(process.cwd(), 'apps', 'frontend', 'src', 'assets', 'logo-settings.json');
+      const dataDir = path.join(process.cwd(), 'apps', 'frontend', 'src', 'assets', 'data');
+      const settingsPath = path.join(dataDir, 'logo-settings.json');
+
+      // Ensure data directory exists
+      if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+      }
 
       // Save the settings to a file
       fs.writeFileSync(settingsPath, JSON.stringify(logoSettings, null, 2));
@@ -156,7 +162,7 @@ export class LogoController {
   @ApiOkResponse({ description: 'Logo settings retrieved successfully', type: AppLogoDto })
   async getLogoSettings(): Promise<AppLogoDto> {
     try {
-      const settingsPath = path.join(process.cwd(), 'apps', 'frontend', 'src', 'assets', 'logo-settings.json');
+      const settingsPath = path.join(process.cwd(), 'apps', 'frontend', 'src', 'assets', 'data', 'logo-settings.json');
 
       // Check if settings file exists
       if (fs.existsSync(settingsPath)) {
@@ -167,7 +173,7 @@ export class LogoController {
 
       // Return default settings if file doesn't exist
       return {
-        data: 'assets/IQB-LogoA.png',
+        data: 'assets/images/IQB-LogoA.png',
         alt: 'Zur Startseite',
         bodyBackground: 'linear-gradient(180deg, rgba(7,70,94,1) 0%, rgba(6,112,123,1) 24%, rgba(1,192,229,1) 85%)',
         boxBackground: 'lightgray'

apps/backend/src/app/admin/workspace/workspace-coding.controller.ts

@@ -1,6 +1,6 @@
 import {
   Controller,
-  Get, Query, Res, UseGuards
+  Get, Param, Query, Res, UseGuards
 } from '@nestjs/common';
 import {
   ApiOkResponse,
@@ -173,4 +173,138 @@ export class WorkspaceCodingController {
   async getCodingStatistics(@WorkspaceId() workspace_id: number): Promise<CodingStatistics> {
     return this.workspaceCodingService.getCodingStatistics(workspace_id);
   }
+
+  @Get(':workspace_id/coding/job/:jobId')
+  @UseGuards(JwtAuthGuard, WorkspaceGuard)
+  @ApiTags('coding')
+  @ApiParam({ name: 'workspace_id', type: Number })
+  @ApiParam({ name: 'jobId', type: String, description: 'ID of the background job' })
+  @ApiOkResponse({
+    description: 'Job status retrieved successfully.',
+    schema: {
+      type: 'object',
+      properties: {
+        status: {
+          type: 'string',
+          enum: ['pending', 'processing', 'completed', 'failed', 'cancelled'],
+          description: 'Current status of the job'
+        },
+        progress: {
+          type: 'number',
+          description: 'Progress percentage (0-100)'
+        },
+        result: {
+          type: 'object',
+          description: 'Result of the job (only available when status is completed)',
+          properties: {
+            totalResponses: { type: 'number' },
+            statusCounts: {
+              type: 'object',
+              additionalProperties: { type: 'number' }
+            }
+          }
+        },
+        error: {
+          type: 'string',
+          description: 'Error message (only available when status is failed)'
+        }
+      }
+    }
+  })
+  async getJobStatus(@Param('jobId') jobId: string): Promise<{ status: string; progress: number; result?: CodingStatistics; error?: string } | { error: string }> {
+    const status = this.workspaceCodingService.getJobStatus(jobId);
+    if (!status) {
+      return { error: `Job with ID ${jobId} not found` };
+    }
+    return status;
+  }
+
+  @Get(':workspace_id/coding/job/:jobId/cancel')
+  @UseGuards(JwtAuthGuard, WorkspaceGuard)
+  @ApiTags('coding')
+  @ApiParam({ name: 'workspace_id', type: Number })
+  @ApiParam({ name: 'jobId', type: String, description: 'ID of the background job to cancel' })
+  @ApiOkResponse({
+    description: 'Job cancellation request processed.',
+    schema: {
+      type: 'object',
+      properties: {
+        success: {
+          type: 'boolean',
+          description: 'Whether the cancellation request was successful'
+        },
+        message: {
+          type: 'string',
+          description: 'Message describing the result of the cancellation request'
+        }
+      }
+    }
+  })
+  async cancelJob(@Param('jobId') jobId: string): Promise<{ success: boolean; message: string }> {
+    return this.workspaceCodingService.cancelJob(jobId);
+  }
+
+  @Get(':workspace_id/coding/jobs')
+  @UseGuards(JwtAuthGuard, WorkspaceGuard)
+  @ApiTags('coding')
+  @ApiParam({ name: 'workspace_id', type: Number })
+  @ApiOkResponse({
+    description: 'List of all jobs retrieved successfully.',
+    schema: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          jobId: {
+            type: 'string',
+            description: 'Unique identifier for the job'
+          },
+          status: {
+            type: 'string',
+            enum: ['pending', 'processing', 'completed', 'failed', 'cancelled'],
+            description: 'Current status of the job'
+          },
+          progress: {
+            type: 'number',
+            description: 'Progress percentage (0-100)'
+          },
+          result: {
+            type: 'object',
+            description: 'Result of the job (only available when status is completed)',
+            properties: {
+              totalResponses: { type: 'number' },
+              statusCounts: {
+                type: 'object',
+                additionalProperties: { type: 'number' }
+              }
+            }
+          },
+          error: {
+            type: 'string',
+            description: 'Error message (only available when status is failed)'
+          },
+          workspaceId: {
+            type: 'number',
+            description: 'ID of the workspace the job belongs to'
+          },
+          createdAt: {
+            type: 'string',
+            format: 'date-time',
+            description: 'Date and time when the job was created'
+          }
+        }
+      }
+    }
+  })
+  async getAllJobs(@WorkspaceId() workspace_id: number): Promise<{
+    jobId: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+    progress: number;
+    result?: CodingStatistics;
+    error?: string;
+    workspaceId?: number;
+    createdAt?: Date;
+  }[]> {
+    return this.workspaceCodingService.getAllJobs(workspace_id);
+  }
 }

apps/backend/src/app/admin/workspace/workspace.controller.spec.ts

@@ -5,6 +5,7 @@ import { AuthService } from '../../auth/service/auth.service';
 import { UsersService } from '../../database/services/users.service';
 import { TestcenterService } from '../../database/services/testcenter.service';
 import { UploadResultsService } from '../../database/services/upload-results.service'; // ggf. anpassen, falls anderer Pfad
+import { WorkspaceCoreService } from '../../database/services/workspace-core.service';
 
 describe('WorkspaceController', () => {
   let controller: WorkspaceController;
@@ -28,6 +29,10 @@ describe('WorkspaceController', () => {
         {
           provide: UploadResultsService,
           useValue: createMock<UploadResultsService>() // Mock-Implementierung für UploadResultsService
+        },
+        {
+          provide: WorkspaceCoreService,
+          useValue: createMock<WorkspaceCoreService>()
         }
       ]
     }).compile();

apps/backend/src/app/app.controller.spec.ts

@@ -4,6 +4,7 @@ import { AppController } from './app.controller';
 import { AuthService } from './auth/service/auth.service';
 import { UsersService } from './database/services/users.service';
 import { TestcenterService } from './database/services/testcenter.service';
+import { WorkspaceUsersService } from './database/services/workspace-users.service';
 
 describe('AppController', () => {
   beforeEach(async () => {
@@ -21,6 +22,10 @@ describe('AppController', () => {
         {
           provide: TestcenterService,
           useValue: createMock<TestcenterService>()
+        },
+        {
+          provide: WorkspaceUsersService,
+          useValue: createMock<WorkspaceUsersService>()
         }
       ]
     }).compile();

apps/backend/src/app/database/services/person.service.ts

@@ -367,6 +367,7 @@ export class PersonService {
       });
   }
 
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   private extractVariablesFromSubforms(subforms: any[]): Set<string> {
     const variables = new Set<string>();
     subforms.forEach(subform => subform.responses.forEach(response => variables.add(response.id))
@@ -654,6 +655,7 @@ export class PersonService {
 
   async saveSubformResponsesForUnit(
     savedUnit: Unit,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     subforms: any[]
   ): Promise<{ success: boolean; saved: number; skipped: number }> {
     try {
@@ -765,7 +767,9 @@ export class PersonService {
 
   async processPersonLogs(
     persons: Person[],
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     unitLogs: any,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     bookletLogs: any,
     overwriteExistingLogs: boolean = true
   ): Promise<{

apps/backend/src/app/database/services/shared-types.ts

@@ -108,3 +108,8 @@ export interface CodingStatistics {
     [key: string]: number;
   };
 }
+
+export interface CodingStatisticsWithJob extends CodingStatistics {
+  jobId?: string;
+  message?: string;
+}

apps/backend/src/app/database/services/unit-tag.service.ts

@@ -1,6 +1,6 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { Repository, In } from 'typeorm';
 import { UnitTag } from '../entities/unitTag.entity';
 import { Unit } from '../entities/unit.entity';
 import { CreateUnitTagDto } from '../../../../../../api-dto/unit-tags/create-unit-tag.dto';
@@ -82,6 +82,32 @@ export class UnitTagService {
     }));
   }
 
+  /**
+   * Find all tags for multiple units in a single query
+   * @param unitIds Array of unit IDs
+   * @returns An array of tags for all specified units
+   */
+  async findAllByUnitIds(unitIds: number[]): Promise<UnitTagDto[]> {
+    if (!unitIds || unitIds.length === 0) {
+      return [];
+    }
+
+    // Find all tags for the units in a single query
+    const tags = await this.unitTagRepository.find({
+      where: { unitId: In(unitIds) },
+      order: { createdAt: 'DESC' }
+    });
+
+    // Return the DTOs
+    return tags.map(tag => ({
+      id: tag.id,
+      unitId: tag.unitId,
+      tag: tag.tag,
+      color: tag.color,
+      createdAt: tag.createdAt
+    }));
+  }
+
   /**
    * Find a tag by ID
    * @param id The ID of the tag