Update training group management and enhance UI components

This commit introduces the `TrainingGroup` model and related functionality, allowing for the management of training groups within the application. The `ClubService` is updated to automatically create preset groups upon club creation. The frontend is enhanced with new views and components, including `TrainingGroupsView` and `TrainingGroupsTab`, to facilitate the display and management of training groups. Additionally, the `MembersView` is updated to allow adding and removing members from training groups, improving the overall user experience and interactivity in managing club members and their associated training groups.

backend/controllers/trainingGroupController.js

@@ -0,0 +1,128 @@
+import trainingGroupService from '../services/trainingGroupService.js';
+import { getSafeErrorMessage } from '../utils/errorUtils.js';
+
+export const getTrainingGroups = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId } = req.params;
+        const groups = await trainingGroupService.getTrainingGroups(userToken, clubId);
+        res.status(200).json(groups);
+    } catch (error) {
+        console.error('[getTrainingGroups] - Error:', error);
+        const msg = getSafeErrorMessage(error, 'Fehler beim Laden der Trainingsgruppen');
+        res.status(error.statusCode || 500).json({ error: msg });
+    }
+};
+
+export const createTrainingGroup = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId } = req.params;
+        const { name, sortOrder } = req.body;
+        const group = await trainingGroupService.createTrainingGroup(userToken, clubId, name, sortOrder);
+        res.status(201).json(group);
+    } catch (error) {
+        console.error('[createTrainingGroup] - Error:', error);
+        const msg = getSafeErrorMessage(error, 'Fehler beim Erstellen der Trainingsgruppe');
+        res.status(error.statusCode || 500).json({ error: msg });
+    }
+};
+
+export const updateTrainingGroup = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId, groupId } = req.params;
+        const { name, sortOrder } = req.body;
+        const group = await trainingGroupService.updateTrainingGroup(userToken, clubId, groupId, name, sortOrder);
+        res.status(200).json(group);
+    } catch (error) {
+        console.error('[updateTrainingGroup] - Error:', error);
+        const msg = getSafeErrorMessage(error, 'Fehler beim Aktualisieren der Trainingsgruppe');
+        res.status(error.statusCode || 500).json({ error: msg });
+    }
+};
+
+export const deleteTrainingGroup = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId, groupId } = req.params;
+        await trainingGroupService.deleteTrainingGroup(userToken, clubId, groupId);
+        res.status(200).json({ success: true });
+    } catch (error) {
+        console.error('[deleteTrainingGroup] - Error:', error);
+        const msg = getSafeErrorMessage(error, 'Fehler beim Löschen der Trainingsgruppe');
+        res.status(error.statusCode || 500).json({ error: msg });
+    }
+};
+
+export const addMemberToGroup = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId, groupId, memberId } = req.params;
+        const memberGroup = await trainingGroupService.addMemberToGroup(userToken, clubId, groupId, memberId);
+        res.status(201).json(memberGroup);
+    } catch (error) {
+        console.error('[addMemberToGroup] - Error:', error);
+        const msg = getSafeErrorMessage(error, 'Fehler beim Hinzufügen des Mitglieds zur Gruppe');
+        res.status(error.statusCode || 500).json({ error: msg });
+    }
+};
+
+export const removeMemberFromGroup = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId, groupId, memberId } = req.params;
+        await trainingGroupService.removeMemberFromGroup(userToken, clubId, groupId, memberId);
+        res.status(200).json({ success: true });
+    } catch (error) {
+        console.error('[removeMemberFromGroup] - Error:', error);
+        const msg = getSafeErrorMessage(error, 'Fehler beim Entfernen des Mitglieds aus der Gruppe');
+        res.status(error.statusCode || 500).json({ error: msg });
+    }
+};
+
+export const getMemberGroups = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId, memberId } = req.params;
+        const groups = await trainingGroupService.getMemberGroups(userToken, clubId, memberId);
+        res.status(200).json(groups);
+    } catch (error) {
+        console.error('[getMemberGroups] - Error:', error);
+        const msg = getSafeErrorMessage(error, 'Fehler beim Laden der Gruppen des Mitglieds');
+        res.status(error.statusCode || 500).json({ error: msg });
+    }
+};
+
+export const ensurePresetGroups = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId } = req.params;
+        const groups = await trainingGroupService.ensurePresetGroups(userToken, clubId);
+        res.status(200).json({ 
+            message: 'Preset-Gruppen wurden erstellt/überprüft',
+            groups: groups.length 
+        });
+    } catch (error) {
+        console.error('[ensurePresetGroups] - Error:', error);
+        const msg = getSafeErrorMessage(error, 'Fehler beim Erstellen der Preset-Gruppen');
+        res.status(error.statusCode || 500).json({ error: msg });
+    }
+};
+
+export const enablePresetGroup = async (req, res) => {
+    try {
+        const { authcode: userToken } = req.headers;
+        const { clubId, presetType } = req.params;
+        const group = await trainingGroupService.enablePresetGroup(userToken, clubId, presetType);
+        res.status(200).json({ 
+            message: 'Preset-Gruppe wurde aktiviert',
+            group 
+        });
+    } catch (error) {
+        console.error('[enablePresetGroup] - Error:', error);
+        const msg = getSafeErrorMessage(error, 'Fehler beim Aktivieren der Preset-Gruppe');
+        res.status(error.statusCode || 500).json({ error: msg });
+    }
+};
+

backend/migrations/create_club_disabled_preset_groups.sql

@@ -0,0 +1,17 @@
+-- Migration: Create club_disabled_preset_groups table
+-- Date: 2025-01-16
+-- For MariaDB/MySQL
+-- Stores which preset groups are disabled for each club
+
+CREATE TABLE IF NOT EXISTS `club_disabled_preset_groups` (
+  `id` INT(11) NOT NULL AUTO_INCREMENT,
+  `club_id` INT(11) NOT NULL,
+  `preset_type` ENUM('anfaenger', 'fortgeschrittene', 'erwachsene', 'nachwuchs', 'leistungsgruppe') NOT NULL,
+  `created_at` DATETIME NOT NULL,
+  `updated_at` DATETIME NOT NULL,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `unique_club_preset_type` (`club_id`, `preset_type`),
+  KEY `club_id` (`club_id`),
+  CONSTRAINT `club_disabled_preset_groups_ibfk_1` FOREIGN KEY (`club_id`) REFERENCES `clubs` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+

backend/migrations/create_training_group_tables.sql

@@ -0,0 +1,34 @@
+-- Migration: Create training_group and member_training_group tables
+-- Date: 2025-01-16
+-- For MariaDB/MySQL
+
+-- Create training_group table
+CREATE TABLE IF NOT EXISTS `training_group` (
+  `id` INT(11) NOT NULL AUTO_INCREMENT,
+  `club_id` INT(11) NOT NULL,
+  `name` VARCHAR(255) NOT NULL,
+  `is_preset` TINYINT(1) NOT NULL DEFAULT 0,
+  `preset_type` ENUM('anfaenger', 'fortgeschrittene', 'erwachsene', 'nachwuchs', 'leistungsgruppe') NULL,
+  `sort_order` INT(11) NOT NULL DEFAULT 0,
+  `created_at` DATETIME NOT NULL,
+  `updated_at` DATETIME NOT NULL,
+  PRIMARY KEY (`id`),
+  KEY `club_id` (`club_id`),
+  CONSTRAINT `training_group_ibfk_1` FOREIGN KEY (`club_id`) REFERENCES `clubs` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- Create member_training_group junction table
+CREATE TABLE IF NOT EXISTS `member_training_group` (
+  `id` INT(11) NOT NULL AUTO_INCREMENT,
+  `member_id` INT(11) NOT NULL,
+  `training_group_id` INT(11) NOT NULL,
+  `created_at` DATETIME NOT NULL,
+  `updated_at` DATETIME NOT NULL,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `unique_member_group` (`member_id`, `training_group_id`),
+  KEY `member_id` (`member_id`),
+  KEY `training_group_id` (`training_group_id`),
+  CONSTRAINT `member_training_group_ibfk_1` FOREIGN KEY (`member_id`) REFERENCES `member` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT `member_training_group_ibfk_2` FOREIGN KEY (`training_group_id`) REFERENCES `training_group` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+

backend/models/ClubDisabledPresetGroup.js

@@ -0,0 +1,33 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import Club from './Club.js';
+
+const ClubDisabledPresetGroup = sequelize.define('ClubDisabledPresetGroup', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+    },
+    clubId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: {
+            model: Club,
+            key: 'id',
+        },
+        onDelete: 'CASCADE',
+    },
+    presetType: {
+        type: DataTypes.ENUM('anfaenger', 'fortgeschrittene', 'erwachsene', 'nachwuchs', 'leistungsgruppe'),
+        allowNull: false,
+        comment: 'Type of preset group that is disabled for this club'
+    }
+}, {
+    tableName: 'club_disabled_preset_groups',
+    underscored: true,
+    timestamps: true,
+});
+
+export default ClubDisabledPresetGroup;
+

backend/models/MemberTrainingGroup.js

@@ -0,0 +1,38 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import Member from './Member.js';
+import TrainingGroup from './TrainingGroup.js';
+
+const MemberTrainingGroup = sequelize.define('MemberTrainingGroup', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+    },
+    memberId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: {
+            model: Member,
+            key: 'id',
+        },
+        onDelete: 'CASCADE',
+    },
+    trainingGroupId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: {
+            model: TrainingGroup,
+            key: 'id',
+        },
+        onDelete: 'CASCADE',
+    }
+}, {
+    tableName: 'member_training_group',
+    underscored: true,
+    timestamps: true,
+});
+
+export default MemberTrainingGroup;
+

backend/models/TrainingGroup.js

@@ -0,0 +1,49 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import Club from './Club.js';
+
+const TrainingGroup = sequelize.define('TrainingGroup', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+    },
+    clubId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: {
+            model: Club,
+            key: 'id',
+        },
+        onDelete: 'CASCADE',
+    },
+    name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+    },
+    isPreset: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+        comment: 'True if this is a preset group (Anfänger, Fortgeschrittene, etc.)'
+    },
+    presetType: {
+        type: DataTypes.ENUM('anfaenger', 'fortgeschrittene', 'erwachsene', 'nachwuchs', 'leistungsgruppe'),
+        allowNull: true,
+        comment: 'Type of preset group'
+    },
+    sortOrder: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+        comment: 'Order for displaying groups'
+    }
+}, {
+    tableName: 'training_group',
+    underscored: true,
+    timestamps: true,
+});
+
+export default TrainingGroup;
+

backend/models/index.js

@@ -44,6 +44,9 @@ import ApiLog from './ApiLog.js';
 import MemberTransferConfig from './MemberTransferConfig.js';
 import MemberContact from './MemberContact.js';
 import MemberImage from './MemberImage.js';
+import TrainingGroup from './TrainingGroup.js';
+import MemberTrainingGroup from './MemberTrainingGroup.js';
+import ClubDisabledPresetGroup from './ClubDisabledPresetGroup.js';
 // Official tournaments relations
 OfficialTournament.hasMany(OfficialCompetition, { foreignKey: 'tournamentId', as: 'competitions' });
 OfficialCompetition.belongsTo(OfficialTournament, { foreignKey: 'tournamentId', as: 'tournament' });
@@ -292,6 +295,27 @@ MemberContact.belongsTo(Member, { foreignKey: 'memberId', as: 'member' });
 Member.hasMany(MemberImage, { foreignKey: 'memberId', as: 'images' });
 MemberImage.belongsTo(Member, { foreignKey: 'memberId', as: 'member' });
 
+// Training Groups
+Club.hasMany(TrainingGroup, { foreignKey: 'clubId', as: 'trainingGroups' });
+TrainingGroup.belongsTo(Club, { foreignKey: 'clubId', as: 'club' });
+
+Member.belongsToMany(TrainingGroup, { 
+    through: MemberTrainingGroup, 
+    foreignKey: 'memberId', 
+    otherKey: 'trainingGroupId',
+    as: 'trainingGroups'
+});
+TrainingGroup.belongsToMany(Member, { 
+    through: MemberTrainingGroup, 
+    foreignKey: 'trainingGroupId', 
+    otherKey: 'memberId',
+    as: 'members'
+});
+
+// Club Disabled Preset Groups
+Club.hasMany(ClubDisabledPresetGroup, { foreignKey: 'clubId', as: 'disabledPresetGroups' });
+ClubDisabledPresetGroup.belongsTo(Club, { foreignKey: 'clubId', as: 'club' });
+
 export {
     User,
     Log,
@@ -338,4 +362,7 @@ export {
     MemberTransferConfig,
     MemberContact,
     MemberImage,
+    TrainingGroup,
+    MemberTrainingGroup,
+    ClubDisabledPresetGroup,
 };

backend/node_modules/.package-lock.json

@@ -2670,7 +2670,9 @@
       "license": "ISC"
     },
     "node_modules/js-yaml": {
-      "version": "4.1.0",
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
       "dev": true,
       "license": "MIT",
       "peer": true,

backend/package-lock.json

@@ -2706,7 +2706,9 @@
       "license": "ISC"
     },
     "node_modules/js-yaml": {
-      "version": "4.1.0",
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
       "dev": true,
       "license": "MIT",
       "peer": true,

backend/routes/trainingGroupRoutes.js

@@ -0,0 +1,33 @@
+import express from 'express';
+import { authenticate } from '../middleware/authMiddleware.js';
+import {
+    getTrainingGroups,
+    createTrainingGroup,
+    updateTrainingGroup,
+    deleteTrainingGroup,
+    addMemberToGroup,
+    removeMemberFromGroup,
+    getMemberGroups,
+    ensurePresetGroups,
+    enablePresetGroup,
+} from '../controllers/trainingGroupController.js';
+
+const router = express.Router();
+
+router.use(authenticate);
+
+// Spezifischere Routen zuerst (mit /member/ im Pfad)
+router.get('/:clubId/member/:memberId', getMemberGroups);
+router.post('/:clubId/:groupId/member/:memberId', addMemberToGroup);
+router.delete('/:clubId/:groupId/member/:memberId', removeMemberFromGroup);
+
+// Allgemeinere Routen danach
+router.post('/:clubId/ensure-preset-groups', ensurePresetGroups);
+router.post('/:clubId/enable-preset-group/:presetType', enablePresetGroup);
+router.get('/:clubId', getTrainingGroups);
+router.post('/:clubId', createTrainingGroup);
+router.put('/:clubId/:groupId', updateTrainingGroup);
+router.delete('/:clubId/:groupId', deleteTrainingGroup);
+
+export default router;
+

backend/server.js

@@ -46,6 +46,7 @@ import memberActivityRoutes from './routes/memberActivityRoutes.js';
 import permissionRoutes from './routes/permissionRoutes.js';
 import apiLogRoutes from './routes/apiLogRoutes.js';
 import memberTransferConfigRoutes from './routes/memberTransferConfigRoutes.js';
+import trainingGroupRoutes from './routes/trainingGroupRoutes.js';
 import schedulerService from './services/schedulerService.js';
 import { requestLoggingMiddleware } from './middleware/requestLoggingMiddleware.js';
  
@@ -132,6 +133,7 @@ app.use('/api/member-activities', memberActivityRoutes);
 app.use('/api/permissions', permissionRoutes);
 app.use('/api/logs', apiLogRoutes);
 app.use('/api/member-transfer-config', memberTransferConfigRoutes);
+app.use('/api/training-groups', trainingGroupRoutes);
 
 app.use(express.static(path.join(__dirname, '../frontend/dist')));
 

backend/services/clubService.js

@@ -5,6 +5,7 @@ import Member from '../models/Member.js';
 import { Op, fn, where, col } from 'sequelize';
 import { checkAccess } from '../utils/userUtils.js';
 import permissionService from './permissionService.js';
+import trainingGroupService from './trainingGroupService.js';
 
 class ClubService {
     async getAllClubs() { 
@@ -18,7 +19,10 @@ class ClubService {
     }
 
     async createClub(clubName) {
-        return await Club.create({ name: clubName });
+        const club = await Club.create({ name: clubName });
+        // Erstelle automatisch die Vorgaben-Gruppen
+        await trainingGroupService.createPresetGroups(club.id);
+        return club;
     }
 
     async addUserToClub(userId, clubId, isOwner = false) {

backend/services/trainingGroupService.js

@@ -0,0 +1,324 @@
+import { Op } from 'sequelize';
+import { checkAccess } from '../utils/userUtils.js';
+import TrainingGroup from '../models/TrainingGroup.js';
+import MemberTrainingGroup from '../models/MemberTrainingGroup.js';
+import Member from '../models/Member.js';
+import ClubDisabledPresetGroup from '../models/ClubDisabledPresetGroup.js';
+import HttpError from '../exceptions/HttpError.js';
+
+class TrainingGroupService {
+    // Vorgaben-Gruppen beim Vereins-Erstellen anlegen (idempotent - erstellt nur fehlende)
+    async createPresetGroups(clubId) {
+        const presetGroups = [
+            { name: 'Anfänger', presetType: 'anfaenger', sortOrder: 1 },
+            { name: 'Fortgeschrittene', presetType: 'fortgeschrittene', sortOrder: 2 },
+            { name: 'Erwachsene', presetType: 'erwachsene', sortOrder: 3 },
+            { name: 'Nachwuchs', presetType: 'nachwuchs', sortOrder: 4 },
+            { name: 'Leistungsgruppe', presetType: 'leistungsgruppe', sortOrder: 5 },
+        ];
+
+        // Hole alle deaktivierten Preset-Gruppen für diesen Verein
+        const disabledPresetGroups = await ClubDisabledPresetGroup.findAll({
+            where: { clubId },
+        });
+        const disabledPresetTypes = new Set(disabledPresetGroups.map(d => d.presetType));
+
+        const createdGroups = [];
+        for (const preset of presetGroups) {
+            // Überspringe deaktivierte Preset-Gruppen
+            if (disabledPresetTypes.has(preset.presetType)) {
+                continue;
+            }
+
+            // Prüfe, ob diese Preset-Gruppe bereits existiert
+            const existing = await TrainingGroup.findOne({
+                where: { 
+                    clubId, 
+                    isPreset: true, 
+                    presetType: preset.presetType 
+                },
+            });
+            
+            if (!existing) {
+                const group = await TrainingGroup.create({
+                    clubId,
+                    name: preset.name,
+                    isPreset: true,
+                    presetType: preset.presetType,
+                    sortOrder: preset.sortOrder,
+                });
+                createdGroups.push(group);
+            } else {
+                createdGroups.push(existing);
+            }
+        }
+        return createdGroups;
+    }
+
+    // Stelle sicher, dass alle Preset-Gruppen für einen Verein existieren
+    async ensurePresetGroups(userToken, clubId) {
+        await checkAccess(userToken, clubId);
+        return await this.createPresetGroups(clubId);
+    }
+
+    // Aktiviere eine deaktivierte Preset-Gruppe wieder
+    async enablePresetGroup(userToken, clubId, presetType) {
+        await checkAccess(userToken, clubId);
+        
+        // Entferne die Deaktivierung
+        await ClubDisabledPresetGroup.destroy({
+            where: { clubId, presetType },
+        });
+        
+        // Erstelle die Gruppe, falls sie nicht existiert
+        const presetGroups = [
+            { name: 'Anfänger', presetType: 'anfaenger', sortOrder: 1 },
+            { name: 'Fortgeschrittene', presetType: 'fortgeschrittene', sortOrder: 2 },
+            { name: 'Erwachsene', presetType: 'erwachsene', sortOrder: 3 },
+            { name: 'Nachwuchs', presetType: 'nachwuchs', sortOrder: 4 },
+            { name: 'Leistungsgruppe', presetType: 'leistungsgruppe', sortOrder: 5 },
+        ];
+        
+        const preset = presetGroups.find(p => p.presetType === presetType);
+        if (!preset) {
+            throw new HttpError('Ungültiger Preset-Typ', 400);
+        }
+        
+        const existing = await TrainingGroup.findOne({
+            where: { 
+                clubId, 
+                isPreset: true, 
+                presetType: presetType 
+            },
+        });
+        
+        if (!existing) {
+            return await TrainingGroup.create({
+                clubId,
+                name: preset.name,
+                isPreset: true,
+                presetType: preset.presetType,
+                sortOrder: preset.sortOrder,
+            });
+        }
+        
+        return existing;
+    }
+
+    async getTrainingGroups(userToken, clubId) {
+        await checkAccess(userToken, clubId);
+        
+        // Stelle sicher, dass alle Preset-Gruppen existieren
+        await this.ensurePresetGroups(userToken, clubId);
+        
+        const groups = await TrainingGroup.findAll({
+            where: { clubId },
+            order: [
+                ['isPreset', 'DESC'], // Preset-Gruppen zuerst
+                ['sortOrder', 'ASC'],
+                ['name', 'ASC'],
+            ],
+            include: [
+                {
+                    model: Member,
+                    as: 'members',
+                    through: { attributes: [] }, // Keine Junction-Table-Attribute
+                    attributes: ['id', 'firstName', 'lastName'],
+                    required: false, // LEFT JOIN, damit auch Gruppen ohne Mitglieder zurückgegeben werden
+                },
+            ],
+        });
+        // Stelle sicher, dass es ein Array ist und dass jedes Gruppen-Objekt ein members-Array hat
+        return groups.map(group => {
+            const groupData = group.toJSON ? group.toJSON() : group;
+            return {
+                ...groupData,
+                members: Array.isArray(groupData.members) ? groupData.members : []
+            };
+        });
+    }
+
+    async createTrainingGroup(userToken, clubId, name, sortOrder = 0) {
+        await checkAccess(userToken, clubId);
+        
+        // Prüfe, ob bereits eine Gruppe mit diesem Namen existiert
+        const existing = await TrainingGroup.findOne({
+            where: { clubId, name },
+        });
+        if (existing) {
+            throw new HttpError('Eine Gruppe mit diesem Namen existiert bereits', 409);
+        }
+
+        const group = await TrainingGroup.create({
+            clubId,
+            name,
+            isPreset: false,
+            presetType: null,
+            sortOrder,
+        });
+        return group;
+    }
+
+    async updateTrainingGroup(userToken, clubId, groupId, name, sortOrder) {
+        await checkAccess(userToken, clubId);
+        
+        const group = await TrainingGroup.findOne({
+            where: { id: groupId, clubId },
+        });
+        if (!group) {
+            throw new HttpError('Gruppe nicht gefunden', 404);
+        }
+
+        // Preset-Gruppen können nicht umbenannt werden
+        if (group.isPreset && name !== group.name) {
+            throw new HttpError('Vorgaben-Gruppen können nicht umbenannt werden', 400);
+        }
+
+        // Prüfe, ob bereits eine andere Gruppe mit diesem Namen existiert
+        if (name !== group.name) {
+            const existing = await TrainingGroup.findOne({
+                where: { clubId, name, id: { [Op.ne]: groupId } },
+            });
+            if (existing) {
+                throw new HttpError('Eine Gruppe mit diesem Namen existiert bereits', 409);
+            }
+        }
+
+        group.name = name;
+        if (sortOrder !== undefined) {
+            group.sortOrder = sortOrder;
+        }
+        await group.save();
+        return group;
+    }
+
+    async deleteTrainingGroup(userToken, clubId, groupId) {
+        await checkAccess(userToken, clubId);
+        
+        const group = await TrainingGroup.findOne({
+            where: { id: groupId, clubId },
+        });
+        if (!group) {
+            throw new HttpError('Gruppe nicht gefunden', 404);
+        }
+
+        // Wenn es eine Preset-Gruppe ist, markiere sie als deaktiviert statt sie zu löschen
+        if (group.isPreset && group.presetType) {
+            // Prüfe, ob bereits als deaktiviert markiert
+            const existing = await ClubDisabledPresetGroup.findOne({
+                where: { clubId, presetType: group.presetType },
+            });
+            
+            if (!existing) {
+                await ClubDisabledPresetGroup.create({
+                    clubId,
+                    presetType: group.presetType,
+                });
+            }
+            
+            // Lösche die Gruppe
+            await group.destroy();
+            return { success: true, message: 'Preset-Gruppe wurde deaktiviert und wird nicht automatisch wieder erstellt' };
+        }
+
+        await group.destroy();
+        return { success: true };
+    }
+
+    async addMemberToGroup(userToken, clubId, groupId, memberId) {
+        await checkAccess(userToken, clubId);
+        
+        // Prüfe, ob Gruppe existiert und zum Verein gehört
+        const group = await TrainingGroup.findOne({
+            where: { id: groupId, clubId },
+        });
+        if (!group) {
+            throw new HttpError('Gruppe nicht gefunden', 404);
+        }
+
+        // Prüfe, ob Mitglied existiert und zum Verein gehört
+        const member = await Member.findOne({
+            where: { id: memberId, clubId },
+        });
+        if (!member) {
+            throw new HttpError('Mitglied nicht gefunden', 404);
+        }
+
+        // Prüfe, ob Zuordnung bereits existiert
+        const existing = await MemberTrainingGroup.findOne({
+            where: { memberId, trainingGroupId: groupId },
+        });
+        if (existing) {
+            throw new HttpError('Mitglied ist bereits in dieser Gruppe', 409);
+        }
+
+        const memberGroup = await MemberTrainingGroup.create({
+            memberId,
+            trainingGroupId: groupId,
+        });
+        return memberGroup;
+    }
+
+    async removeMemberFromGroup(userToken, clubId, groupId, memberId) {
+        await checkAccess(userToken, clubId);
+        
+        // Prüfe, ob Gruppe existiert und zum Verein gehört
+        const group = await TrainingGroup.findOne({
+            where: { id: groupId, clubId },
+        });
+        if (!group) {
+            throw new HttpError('Gruppe nicht gefunden', 404);
+        }
+
+        // Prüfe, ob Mitglied existiert und zum Verein gehört
+        const member = await Member.findOne({
+            where: { id: memberId, clubId },
+        });
+        if (!member) {
+            throw new HttpError('Mitglied nicht gefunden', 404);
+        }
+        
+        const memberGroup = await MemberTrainingGroup.findOne({
+            where: { memberId, trainingGroupId: groupId },
+        });
+        if (!memberGroup) {
+            throw new HttpError('Zuordnung nicht gefunden', 404);
+        }
+
+        await memberGroup.destroy();
+        return { success: true };
+    }
+
+    async getMemberGroups(userToken, clubId, memberId) {
+        await checkAccess(userToken, clubId);
+        
+        const member = await Member.findOne({
+            where: { id: memberId, clubId },
+        });
+        if (!member) {
+            throw new HttpError('Mitglied nicht gefunden', 404);
+        }
+
+        const groups = await TrainingGroup.findAll({
+            where: { clubId },
+            include: [
+                {
+                    model: Member,
+                    as: 'members',
+                    where: { id: memberId },
+                    through: { attributes: [] },
+                    required: true,
+                },
+            ],
+            order: [
+                ['isPreset', 'DESC'],
+                ['sortOrder', 'ASC'],
+                ['name', 'ASC'],
+            ],
+        });
+        return groups;
+    }
+}
+
+export default new TrainingGroupService();
+

backend/utils/errorUtils.js

@@ -0,0 +1,33 @@
+/**
+ * Gibt eine sichere Fehlermeldung zurück, die an den Client gesendet werden kann.
+ * Verhindert, dass sensible Informationen (wie Stack-Traces oder interne Details) nach außen gelangen.
+ * 
+ * @param {Error} error - Der Fehler-Objekt
+ * @param {string} defaultMessage - Standard-Nachricht, die verwendet wird, wenn keine sichere Nachricht verfügbar ist
+ * @returns {string} - Sichere Fehlermeldung
+ */
+export function getSafeErrorMessage(error, defaultMessage = 'Ein Fehler ist aufgetreten') {
+    // Wenn kein Fehler vorhanden ist, gib die Standard-Nachricht zurück
+    if (!error) {
+        return defaultMessage;
+    }
+
+    // Wenn der Fehler eine message hat und es keine interne/technische Nachricht ist
+    if (error.message) {
+        const message = error.message;
+        
+        // Prüfe, ob die Nachricht sicher ist (keine Stack-Traces, keine internen Pfade, etc.)
+        // Erlaube nur benutzerfreundliche Nachrichten
+        if (message && 
+            !message.includes('at ') && // Keine Stack-Traces
+            !message.includes('Error:') && // Keine technischen Fehler-Präfixe
+            !message.startsWith('/') && // Keine Dateipfade
+            message.length < 500) { // Keine sehr langen Nachrichten (könnten Stack-Traces sein)
+            return message;
+        }
+    }
+
+    // Fallback: Standard-Nachricht verwenden
+    return defaultMessage;
+}
+