Fügt Funktionen zum Zusammenführen und Entfernen von Duplikaten vordefinierter Aktivitäten hinzu. Implementiert die entsprechenden Controller-Methoden und Routen. Aktualisiert die Benutzeroberfläche in PredefinedActivities.vue, um die neuen Funktionen zur Verfügung zu stellen und die Aktivitäten nach Namen und Code zu sortieren.

backend/controllers/predefinedActivityController.js

@@ -61,3 +61,24 @@ export const searchPredefinedActivities = async (req, res) => {
         res.status(500).json({ error: 'Error searching predefined activities' });
     }
 };
+
+export const mergePredefinedActivities = async (req, res) => {
+    try {
+        const { sourceId, targetId } = req.body;
+        await predefinedActivityService.mergeActivities(sourceId, targetId);
+        res.status(200).json({ ok: true });
+    } catch (error) {
+        console.error('[mergePredefinedActivities] - Error:', error);
+        res.status(500).json({ error: 'Error merging predefined activities' });
+    }
+};
+
+export const deduplicatePredefinedActivities = async (req, res) => {
+    try {
+        const result = await predefinedActivityService.deduplicateActivities();
+        res.status(200).json(result);
+    } catch (error) {
+        console.error('[deduplicatePredefinedActivities] - Error:', error);
+        res.status(500).json({ error: 'Error deduplicating predefined activities' });
+    }
+};

backend/routes/predefinedActivityRoutes.js

@@ -5,6 +5,8 @@ import {
     getPredefinedActivityById,
     updatePredefinedActivity,
     searchPredefinedActivities,
+    mergePredefinedActivities,
+    deduplicatePredefinedActivities,
 } from '../controllers/predefinedActivityController.js';
 import multer from 'multer';
 import { authenticate } from '../middleware/authMiddleware.js';
@@ -22,6 +24,8 @@ router.get('/:id', authenticate, getPredefinedActivityById);
 router.put('/:id', authenticate, updatePredefinedActivity);
 router.post('/:id/image', authenticate, upload.single('image'), uploadPredefinedActivityImage);
 router.get('/search/query', authenticate, searchPredefinedActivities);
+router.post('/merge', authenticate, mergePredefinedActivities);
+router.post('/deduplicate', authenticate, deduplicatePredefinedActivities);
 router.get('/:id/image/:imageId', authenticate, async (req, res) => {
   try {
     const { id, imageId } = req.params;

backend/services/predefinedActivityService.js

@@ -1,4 +1,8 @@
 import PredefinedActivity from '../models/PredefinedActivity.js';
+import DiaryDateActivity from '../models/DiaryDateActivity.js';
+import GroupActivity from '../models/GroupActivity.js';
+import PredefinedActivityImage from '../models/PredefinedActivityImage.js';
+import sequelize from '../database.js';
 import { Op } from 'sequelize';
 
 class PredefinedActivityService {
@@ -33,7 +37,13 @@ class PredefinedActivityService {
 
     async getAllPredefinedActivities() {
         console.log('[PredefinedActivityService::getAllPredefinedActivities] - Fetching all predefined activities');
-        return await PredefinedActivity.findAll();
+        return await PredefinedActivity.findAll({
+            order: [
+                [sequelize.literal('code IS NULL'), 'ASC'], // Non-null codes first
+                ['code', 'ASC'],
+                ['name', 'ASC'],
+            ],
+        });
     }
 
     async getPredefinedActivityById(id) {
@@ -58,10 +68,81 @@ class PredefinedActivityService {
                     { code: { [Op.like]: `%${q}%` } },
                 ],
             },
-            order: [['name', 'ASC']],
+            order: [
+                [sequelize.literal('code IS NULL'), 'ASC'],
+                ['code', 'ASC'],
+                ['name', 'ASC'],
+            ],
             limit: Math.min(parseInt(limit || 20, 10), 50),
         });
     }
+
+    async mergeActivities(sourceId, targetId) {
+        console.log(`[PredefinedActivityService::mergeActivities] - Merge ${sourceId} -> ${targetId}`);
+        if (!sourceId || !targetId) throw new Error('sourceId and targetId are required');
+        if (Number(sourceId) === Number(targetId)) throw new Error('sourceId and targetId must differ');
+
+        const tx = await sequelize.transaction();
+        try {
+            const source = await PredefinedActivity.findByPk(sourceId, { transaction: tx });
+            const target = await PredefinedActivity.findByPk(targetId, { transaction: tx });
+            if (!source) throw new Error('Source activity not found');
+            if (!target) throw new Error('Target activity not found');
+
+            // Reassign references
+            await DiaryDateActivity.update(
+                { predefinedActivityId: targetId },
+                { where: { predefinedActivityId: sourceId }, transaction: tx }
+            );
+
+            await GroupActivity.update(
+                { customActivity: targetId },
+                { where: { customActivity: sourceId }, transaction: tx }
+            );
+
+            await PredefinedActivityImage.update(
+                { predefinedActivityId: targetId },
+                { where: { predefinedActivityId: sourceId }, transaction: tx }
+            );
+
+            // Finally delete source
+            await source.destroy({ transaction: tx });
+
+            await tx.commit();
+            return { ok: true };
+        } catch (err) {
+            await tx.rollback();
+            console.error('[PredefinedActivityService::mergeActivities] - Error:', err);
+            throw err;
+        }
+    }
+
+    async deduplicateActivities() {
+        console.log('[PredefinedActivityService::deduplicateActivities] - Start');
+        const all = await PredefinedActivity.findAll();
+        const nameToActivities = new Map();
+        for (const activity of all) {
+            const key = (activity.name || '').trim().toLowerCase();
+            if (!key) continue;
+            if (!nameToActivities.has(key)) nameToActivities.set(key, []);
+            nameToActivities.get(key).push(activity);
+        }
+        let mergedCount = 0;
+        let groupCount = 0;
+        for (const list of nameToActivities.values()) {
+            if (!list || list.length <= 1) continue;
+            groupCount++;
+            // Stable target: kleinste ID
+            list.sort((a, b) => a.id - b.id);
+            const target = list[0];
+            for (const src of list.slice(1)) {
+                await this.mergeActivities(src.id, target.id);
+                mergedCount++;
+            }
+        }
+        console.log('[PredefinedActivityService::deduplicateActivities] - Done', { mergedCount, groupCount });
+        return { mergedCount, groupCount };
+    }
 }
 
 export default new PredefinedActivityService();