Fix language setting not being saved to database on admin settings page

- Added default_language field to general settings state in SettingsPage - Replaced LanguageSelector component with simple select dropdown on settings page - Fixed public settings endpoint to read general_default_language from database - Language setting now properly saved when clicking Save Settings button - Setting is correctly used by gallery login page and legal pages 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
2025-07-08 09:49:45 +02:00
parent cfa0b0da69
commit 2012b0bab9
91 changed files with 6183 additions and 577 deletions
@@ -60,12 +60,15 @@ async function processNewPhoto(filePath) {
  // Generate thumbnail
  const thumbnailPath = await generateThumbnail(filePath);
  
+  // Calculate relative thumbnail path
+  const relativeThumbPath = thumbnailPath; // thumbnailPath is already relative to storage root
+  
  // Add to database
  await db('photos').insert({
    event_id: event.id,
    filename: path.basename(filePath),
    path: relativePath,
-    thumbnail_path: thumbnailPath,
+    thumbnail_path: relativeThumbPath,
    type: photoType,
    size_bytes: stats.size
  });
@@ -3,15 +3,17 @@ const path = require('path');
 const fs = require('fs').promises;

 const THUMBNAIL_WIDTH = 300;
-const THUMBNAIL_PATH = path.join(__dirname, '../../../storage/thumbnails');
+const getStoragePath = () => process.env.STORAGE_PATH || path.join(__dirname, '../../../storage');
+const getThumbnailPath = () => path.join(getStoragePath(), 'thumbnails');

 async function generateThumbnail(imagePath) {
  const filename = path.basename(imagePath);
  const thumbnailFilename = `thumb_${filename}`;
-  const thumbnailPath = path.join(THUMBNAIL_PATH, thumbnailFilename);
+  const thumbnailDir = getThumbnailPath();
+  const thumbnailPath = path.join(thumbnailDir, thumbnailFilename);
  
  // Ensure thumbnail directory exists
-  await fs.mkdir(THUMBNAIL_PATH, { recursive: true });
+  await fs.mkdir(thumbnailDir, { recursive: true });
  
  // Generate thumbnail
  await sharp(imagePath)
@@ -22,7 +24,7 @@ async function generateThumbnail(imagePath) {
    .jpeg({ quality: 80 })
    .toFile(thumbnailPath);
  
-  return path.relative(path.join(__dirname, '../../../storage'), thumbnailPath);
+  return path.relative(getStoragePath(), thumbnailPath);
 }

 module.exports = { generateThumbnail };
@@ -0,0 +1,226 @@
+const sharp = require('sharp');
+const path = require('path');
+const fs = require('fs').promises;
+const { db } = require('../database/db');
+
+class WatermarkService {
+  constructor() {
+    this.cache = new Map();
+    this.cacheMaxAge = 3600000; // 1 hour in milliseconds
+  }
+
+  /**
+   * Get watermark settings from database
+   */
+  async getWatermarkSettings() {
+    try {
+      const settings = await db('app_settings')
+        .whereIn('setting_key', [
+          'branding_watermark_enabled',
+          'branding_watermark_logo_path',
+          'branding_watermark_position',
+          'branding_watermark_opacity',
+          'branding_watermark_size',
+          'branding_company_name'
+        ])
+        .select('setting_key', 'setting_value');
+
+      const settingsObj = {};
+      settings.forEach(setting => {
+        try {
+          settingsObj[setting.setting_key] = JSON.parse(setting.setting_value);
+        } catch (e) {
+          settingsObj[setting.setting_key] = setting.setting_value;
+        }
+      });
+
+      return {
+        enabled: settingsObj.branding_watermark_enabled || false,
+        logoPath: settingsObj.branding_watermark_logo_path || null,
+        position: settingsObj.branding_watermark_position || 'bottom-right',
+        opacity: parseInt(settingsObj.branding_watermark_opacity || 50),
+        size: parseInt(settingsObj.branding_watermark_size || 15),
+        companyName: settingsObj.branding_company_name || 'Photo Gallery'
+      };
+    } catch (error) {
+      console.error('Error fetching watermark settings:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Calculate position coordinates based on position string
+   */
+  getPositionCoordinates(imageWidth, imageHeight, watermarkWidth, watermarkHeight, position) {
+    const padding = 20;
+    let left, top;
+
+    switch (position) {
+      case 'top-left':
+        left = padding;
+        top = padding;
+        break;
+      case 'top-right':
+        left = imageWidth - watermarkWidth - padding;
+        top = padding;
+        break;
+      case 'bottom-left':
+        left = padding;
+        top = imageHeight - watermarkHeight - padding;
+        break;
+      case 'bottom-right':
+        left = imageWidth - watermarkWidth - padding;
+        top = imageHeight - watermarkHeight - padding;
+        break;
+      case 'center':
+        left = Math.floor((imageWidth - watermarkWidth) / 2);
+        top = Math.floor((imageHeight - watermarkHeight) / 2);
+        break;
+      default:
+        // Default to bottom-right
+        left = imageWidth - watermarkWidth - padding;
+        top = imageHeight - watermarkHeight - padding;
+    }
+
+    return { left: Math.max(0, left), top: Math.max(0, top) };
+  }
+
+  /**
+   * Apply watermark to an image
+   */
+  async applyWatermark(imagePath, settings) {
+    try {
+      if (!settings || !settings.enabled) {
+        // Return original image if watermarking is disabled
+        return await fs.readFile(imagePath);
+      }
+
+      // Check cache first
+      const cacheKey = `${imagePath}_${JSON.stringify(settings)}`;
+      const cached = this.cache.get(cacheKey);
+      if (cached && Date.now() - cached.timestamp < this.cacheMaxAge) {
+        return cached.buffer;
+      }
+
+      // Load the main image
+      const image = sharp(imagePath);
+      const metadata = await image.metadata();
+
+      let watermarkBuffer;
+      let watermarkMetadata;
+
+      // Try to use logo watermark first
+      if (settings.logoPath) {
+        try {
+          const watermarkImage = sharp(settings.logoPath);
+          watermarkMetadata = await watermarkImage.metadata();
+          
+          // Calculate watermark size based on percentage of main image
+          const scaleFactor = settings.size / 100;
+          const targetWidth = Math.floor(metadata.width * scaleFactor);
+          const targetHeight = Math.floor(watermarkMetadata.height * (targetWidth / watermarkMetadata.width));
+
+          // Resize watermark and apply opacity
+          watermarkBuffer = await watermarkImage
+            .resize(targetWidth, targetHeight, { fit: 'inside' })
+            .composite([{
+              input: Buffer.from([255, 255, 255, Math.floor(255 * (settings.opacity / 100))]),
+              raw: {
+                width: 1,
+                height: 1,
+                channels: 4
+              },
+              tile: true,
+              blend: 'dest-in'
+            }])
+            .toBuffer();
+
+          watermarkMetadata = { width: targetWidth, height: targetHeight };
+        } catch (error) {
+          console.error('Error processing watermark logo:', error);
+          watermarkBuffer = null;
+        }
+      }
+
+      // If no logo or logo failed, create text watermark
+      if (!watermarkBuffer) {
+        const fontSize = Math.max(16, Math.floor(metadata.width * 0.03));
+        const padding = 10;
+        
+        // Create SVG text watermark
+        const svg = `
+          <svg width="${settings.companyName.length * fontSize * 0.6 + padding * 2}" height="${fontSize + padding * 2}">
+            <rect x="0" y="0" width="100%" height="100%" fill="black" opacity="0.5" rx="5"/>
+            <text x="${padding}" y="${fontSize + padding/2}" 
+              font-family="Arial, sans-serif" 
+              font-size="${fontSize}" 
+              fill="white" 
+              opacity="${settings.opacity / 100}">
+              ${settings.companyName}
+            </text>
+          </svg>
+        `;
+        
+        watermarkBuffer = Buffer.from(svg);
+        watermarkMetadata = {
+          width: settings.companyName.length * fontSize * 0.6 + padding * 2,
+          height: fontSize + padding * 2
+        };
+      }
+
+      // Calculate position
+      const position = this.getPositionCoordinates(
+        metadata.width,
+        metadata.height,
+        watermarkMetadata.width,
+        watermarkMetadata.height,
+        settings.position
+      );
+
+      // Apply watermark
+      const watermarkedBuffer = await image
+        .composite([{
+          input: watermarkBuffer,
+          top: position.top,
+          left: position.left
+        }])
+        .toBuffer();
+
+      // Cache the result
+      this.cache.set(cacheKey, {
+        buffer: watermarkedBuffer,
+        timestamp: Date.now()
+      });
+
+      // Clean old cache entries
+      this.cleanCache();
+
+      return watermarkedBuffer;
+    } catch (error) {
+      console.error('Error applying watermark:', error);
+      // Return original image on error
+      return await fs.readFile(imagePath);
+    }
+  }
+
+  /**
+   * Clean old cache entries
+   */
+  cleanCache() {
+    const now = Date.now();
+    for (const [key, value] of this.cache.entries()) {
+      if (now - value.timestamp > this.cacheMaxAge) {
+        this.cache.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Clear entire cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+}
+
+module.exports = new WatermarkService();