feat(backend): Benachrichtigungssystem (Modul 26)

NotificationsModule: Notification-Modell mit Prioritaeten INFO/
HINWEIS/WARNUNG/KRITISCH, GET /notifications (eigene + Broadcast),
POST /notifications/:id/read. record() als interne API fuer
kuenftige Automatisierungsregeln (Modul 30) vorgesehen.

ApiCore-Backend/src/app.module.ts

@@ -26,6 +26,7 @@ import { ProductsModule } from './products/products.module';
 import { BottlingModule } from './bottling/bottling.module';
 import { EquipmentModule } from './equipment/equipment.module';
 import { CalendarModule } from './calendar/calendar.module';
+import { NotificationsModule } from './notifications/notifications.module';
 import { JwtAuthGuard } from './auth/guards/jwt-auth.guard';
 import { RolesGuard } from './auth/guards/roles.guard';
 
@@ -57,6 +58,7 @@ import { RolesGuard } from './auth/guards/roles.guard';
     BottlingModule,
     EquipmentModule,
     CalendarModule,
+    NotificationsModule,
   ],
   controllers: [],
   providers: [

ApiCore-Backend/src/notifications/notifications.controller.ts

@@ -0,0 +1,28 @@
+import { Controller, Get, Param, Post, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { CurrentUser } from '../auth/decorators/current-user.decorator';
+import type { AuthenticatedUser } from '../auth/types/authenticated-user';
+import { NotificationsService } from './notifications.service';
+
+@ApiTags('notifications')
+@ApiBearerAuth()
+@Controller('notifications')
+export class NotificationsController {
+  constructor(private readonly notificationsService: NotificationsService) {}
+
+  @Get()
+  findAll(
+    @CurrentUser() actor: AuthenticatedUser,
+    @Query('unreadOnly') unreadOnly?: string,
+  ) {
+    return this.notificationsService.findAll({
+      userId: actor.id,
+      unreadOnly: unreadOnly === 'true',
+    });
+  }
+
+  @Post(':id/read')
+  markRead(@Param('id') id: string) {
+    return this.notificationsService.markRead(id);
+  }
+}

ApiCore-Backend/src/notifications/notifications.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { NotificationsController } from './notifications.controller';
+import { NotificationsService } from './notifications.service';
+
+@Module({
+  controllers: [NotificationsController],
+  providers: [NotificationsService],
+  exports: [NotificationsService],
+})
+export class NotificationsModule {}

ApiCore-Backend/src/notifications/notifications.service.spec.ts

@@ -0,0 +1,74 @@
+import { NotFoundException } from '@nestjs/common';
+import { NotificationsService } from './notifications.service';
+import { PrismaService } from '../prisma/prisma.service';
+
+describe('NotificationsService', () => {
+  let service: NotificationsService;
+  let prisma: {
+    notification: {
+      create: jest.Mock;
+      findMany: jest.Mock;
+      findUnique: jest.Mock;
+      update: jest.Mock;
+    };
+  };
+
+  beforeEach(() => {
+    prisma = {
+      notification: {
+        create: jest.fn(),
+        findMany: jest.fn(),
+        findUnique: jest.fn(),
+        update: jest.fn(),
+      },
+    };
+    service = new NotificationsService(prisma as unknown as PrismaService);
+  });
+
+  it('records a notification with the given priority and message', async () => {
+    const created = {
+      id: 'n1',
+      priority: 'KRITISCH',
+      message: 'Keine Königin gesehen',
+    };
+    prisma.notification.create.mockResolvedValueOnce(created);
+
+    const result = await service.record({
+      priority: 'KRITISCH',
+      message: 'Keine Königin gesehen',
+    });
+
+    expect(result).toEqual(created);
+    expect(prisma.notification.create).toHaveBeenCalledWith({
+      data: { priority: 'KRITISCH', message: 'Keine Königin gesehen' },
+    });
+  });
+
+  it('lists notifications for a user including broadcast notifications', async () => {
+    await service.findAll({ userId: 'user-1' });
+
+    const [[queryArg]] = prisma.notification.findMany.mock.calls as [
+      [{ where: { OR?: { userId: string | null }[] } }],
+    ];
+    expect(queryArg.where.OR).toEqual([{ userId: 'user-1' }, { userId: null }]);
+  });
+
+  it('throws NotFoundException when marking an unknown notification as read', async () => {
+    prisma.notification.findUnique.mockResolvedValueOnce(null);
+    await expect(service.markRead('missing')).rejects.toBeInstanceOf(
+      NotFoundException,
+    );
+  });
+
+  it('marks a notification as read', async () => {
+    prisma.notification.findUnique.mockResolvedValueOnce({
+      id: 'n1',
+      read: false,
+    });
+    prisma.notification.update.mockResolvedValueOnce({ id: 'n1', read: true });
+
+    const result = await service.markRead('n1');
+
+    expect(result.read).toBe(true);
+  });
+});

ApiCore-Backend/src/notifications/notifications.service.ts

@@ -0,0 +1,51 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { PrismaService } from '../prisma/prisma.service';
+import { Notification, NotificationPriority } from '../../generated/prisma';
+
+export interface CreateNotificationInput {
+  userId?: string;
+  priority: NotificationPriority;
+  message: string;
+  relatedType?: string;
+  relatedId?: string;
+}
+
+export interface NotificationFilter {
+  userId?: string;
+  unreadOnly?: boolean;
+}
+
+@Injectable()
+export class NotificationsService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async record(input: CreateNotificationInput): Promise<Notification> {
+    return this.prisma.notification.create({ data: { ...input } });
+  }
+
+  async findAll(filter: NotificationFilter = {}): Promise<Notification[]> {
+    return this.prisma.notification.findMany({
+      where: {
+        OR: filter.userId
+          ? [{ userId: filter.userId }, { userId: null }]
+          : undefined,
+        read: filter.unreadOnly ? false : undefined,
+      },
+      orderBy: { createdAt: 'desc' },
+      take: 100,
+    });
+  }
+
+  async markRead(id: string): Promise<Notification> {
+    const notification = await this.prisma.notification.findUnique({
+      where: { id },
+    });
+    if (!notification) {
+      throw new NotFoundException('Notification not found');
+    }
+    return this.prisma.notification.update({
+      where: { id },
+      data: { read: true },
+    });
+  }
+}