Merge pull request #131 from the-luap/release-please--branches--beta

chore(beta): release 3.2.5-beta.0
2026-01-18 15:38:03 +01:00 · 2026-01-18 14:35:30 +00:00 · 2026-01-18 15:35:15 +01:00 · 2026-01-18 15:00:38 +01:00 · 2026-01-18 12:55:56 +01:00 · 2026-01-17 15:48:24 +01:00
34 changed files with 1258 additions and 138 deletions
@@ -39,6 +39,11 @@ EMAIL_FROM=noreply@yourdomain.com
 FRONTEND_URL=https://yourdomain.com
 ADMIN_URL=https://yourdomain.com

+# API URL for email assets (logos, images in notification emails)
+# This must be the publicly accessible URL where email recipients can load images.
+# If not set, defaults to http://localhost:3001 which will show broken images in emails.
+API_URL=https://yourdomain.com/api
+
 # Frontend API base
 # For pre-built images and production behind a reverse proxy, keep '/api'.
 # If you rebuild the frontend yourself, you may set a full URL at build time.
@@ -1,3 +1,3 @@
 {
-  ".": "3.0.0-beta.0"
+  ".": "3.2.5-beta.0"
 }
@@ -5,6 +5,97 @@ All notable changes to PicPeak will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

+## [3.2.5-beta.0](https://github.com/the-luap/picpeak/compare/v3.2.4-beta.0...v3.2.5-beta.0) (2026-01-18)
+
+
+### Bug Fixes
+
+* add STORAGE_PATH to production docker-compose ([cdda709](https://github.com/the-luap/picpeak/commit/cdda70988664a177b351abc6a259ec39664d17ff))
+* correct invitation activation validation and add missing translations ([991aa98](https://github.com/the-luap/picpeak/commit/991aa98f98cffd1d7785c272726615325e2c0208)), closes [#129](https://github.com/the-luap/picpeak/issues/129)
+* correct invitation email link URL path ([86fa104](https://github.com/the-luap/picpeak/commit/86fa1046d5439cb451feb164175c919c49ca219a)), closes [#129](https://github.com/the-luap/picpeak/issues/129)
+* resolve admin invitation flow issues and improve STORAGE_PATH documentation ([41bf6ff](https://github.com/the-luap/picpeak/commit/41bf6ff884d5ef3181f95f3aa4a528434c23947a))
+
+
+### Documentation
+
+* emphasize importance of STORAGE_PATH in env example ([3397807](https://github.com/the-luap/picpeak/commit/3397807670784e02cbe34a7a60db43c95d64f19c))
+
+## [3.2.4-beta.0](https://github.com/the-luap/picpeak/compare/v3.2.3-beta.0...v3.2.4-beta.0) (2026-01-17)
+
+
+### Bug Fixes
+
+* correct storage path resolution in multiple files ([#96](https://github.com/the-luap/picpeak/issues/96)) ([0e3674b](https://github.com/the-luap/picpeak/commit/0e3674b2b0325bbcee5aa2c9ff7781da92f612d1))
+* correct storage path resolution in multiple files ([#96](https://github.com/the-luap/picpeak/issues/96)) ([3ccb815](https://github.com/the-luap/picpeak/commit/3ccb8154eb40a432aa467fb06b3f216fd0d2c6b4))
+
+## [3.2.3-beta.0](https://github.com/the-luap/picpeak/compare/v3.2.2-beta.0...v3.2.3-beta.0) (2026-01-16)
+
+
+### Bug Fixes
+
+* add allow_user_uploads to gallery API responses ([691e3ab](https://github.com/the-luap/picpeak/commit/691e3aba09f2148afe902a0bb0139d062634e669))
+* mobile upload button not visible in gallery ([#113](https://github.com/the-luap/picpeak/issues/113)) ([cacaffa](https://github.com/the-luap/picpeak/commit/cacaffa5c39f67105c4cfb092ea62157121fb72e))
+
+## [3.2.2-beta.0](https://github.com/the-luap/picpeak/compare/v3.2.1-beta.0...v3.2.2-beta.0) (2026-01-16)
+
+
+### Bug Fixes
+
+* mobile upload button visibility in gallery ([2a2c23d](https://github.com/the-luap/picpeak/commit/2a2c23d11610e6c81684163eb4ea934a6d6104fb)), closes [#113](https://github.com/the-luap/picpeak/issues/113)
+* mobile upload button visibility in gallery ([#113](https://github.com/the-luap/picpeak/issues/113)) ([05a5307](https://github.com/the-luap/picpeak/commit/05a5307e22dc45be4b75b2996ff9fac65dec399d))
+
+## [3.2.1-beta.0](https://github.com/the-luap/picpeak/compare/v3.2.0-beta.0...v3.2.1-beta.0) (2026-01-16)
+
+
+### Bug Fixes
+
+* mobile upload button visibility in gallery ([df7dbff](https://github.com/the-luap/picpeak/commit/df7dbffbffb180e62af0d2b58326f9de0f515439)), closes [#113](https://github.com/the-luap/picpeak/issues/113)
+* mobile upload button visibility in gallery ([#113](https://github.com/the-luap/picpeak/issues/113)) ([6cb4342](https://github.com/the-luap/picpeak/commit/6cb43428d1e703267edeacda9ede050a8c4f8e0c))
+
+## [3.2.0-beta.0](https://github.com/the-luap/picpeak/compare/v3.1.0-beta.0...v3.2.0-beta.0) (2026-01-16)
+
+
+### Features
+
+* add optional event date and expiration settings ([3079eaa](https://github.com/the-luap/picpeak/commit/3079eaa2e5d1728c2c0f315626cc253e4b08edc2))
+* add optional event date and expiration settings ([2151147](https://github.com/the-luap/picpeak/commit/2151147f2d3134448ff32130da44678e2942d73c)), closes [#118](https://github.com/the-luap/picpeak/issues/118)
+
+
+### Bug Fixes
+
+* checkbox and toggle settings not persisting after page refresh ([808ed1d](https://github.com/the-luap/picpeak/commit/808ed1d2f1164d9fd1114586c68a1f925bf73ddf)), closes [#117](https://github.com/the-luap/picpeak/issues/117)
+
+
+### Documentation
+
+* add API_URL environment variable to .env.example files ([3e69579](https://github.com/the-luap/picpeak/commit/3e69579f5a171b31a253b2a42bb033bf1b97387d))
+
+## [3.1.0-beta.0](https://github.com/the-luap/picpeak/compare/v3.0.1-beta.0...v3.1.0-beta.0) (2026-01-15)
+
+
+### Features
+
+* dynamic website title from branding settings ([d29aab7](https://github.com/the-luap/picpeak/commit/d29aab7c70c5777451666fb7d5c7a9729dab684a))
+* pre-generate watermarks for instant lightbox loading ([1be974a](https://github.com/the-luap/picpeak/commit/1be974afbb0b7a1bdbdd140327771907a5d3c2ae)), closes [#112](https://github.com/the-luap/picpeak/issues/112)
+* pre-generated watermarks and mobile upload button improvements ([c6fdd38](https://github.com/the-luap/picpeak/commit/c6fdd38e842e1a8c0aa9cbab9fc791e6669e402d))
+
+
+### Bug Fixes
+
+* add lightbox loading spinner and watermark cache invalidation ([050ed37](https://github.com/the-luap/picpeak/commit/050ed378199eb3b15c7c7f243792f68f858803f5))
+* lightbox watermark loading, white label translations, and dynamic footer year ([ce8587b](https://github.com/the-luap/picpeak/commit/ce8587b24df3f53a11a74348eff8b5c5b96c5488))
+* prevent database migration restart failures ([83a4344](https://github.com/the-luap/picpeak/commit/83a4344a01de4f65c5024fdf2d177a04457ccd2f)), closes [#107](https://github.com/the-luap/picpeak/issues/107)
+* show upload button in mobile topbar instead of sidebar ([ae181cf](https://github.com/the-luap/picpeak/commit/ae181cf92fc9c1e85cad7a7b843a4d83cec636ac)), closes [#113](https://github.com/the-luap/picpeak/issues/113)
+* watermark thumbnails, custom logo display, and German translations ([ea20446](https://github.com/the-luap/picpeak/commit/ea20446a797a00cf45dbe7bf6f06574a79c4d8a6))
+
+## [3.0.1-beta.0](https://github.com/the-luap/picpeak/compare/v3.0.0-beta.0...v3.0.1-beta.0) (2026-01-15)
+
+
+### Bug Fixes
+
+* CI workflow fixes for protected branches ([cb01218](https://github.com/the-luap/picpeak/commit/cb012186d93403a1ac4e2d2f5283319603b290d6))
+* use Release Please extra-files instead of sync-versions job ([fe7d45d](https://github.com/the-luap/picpeak/commit/fe7d45dd122b2dca1b2a21ba5c86d32b9a193074))
+
 ## [3.0.0-beta.0](https://github.com/the-luap/picpeak/compare/v2.3.0-beta.0...v3.0.0-beta.0) (2026-01-15)


@@ -14,6 +14,11 @@ ADMIN_URL=https://photos.example.com
 FRONTEND_URL=https://photos.example.com
 BACKEND_URL=https://photos.example.com  # Or https://api.photos.example.com if separate

+# API URL for email assets (logos, images in emails)
+# This must be the publicly accessible URL where recipients can load images
+# If not set, defaults to http://localhost:3001 which will break images in production emails
+API_URL=https://photos.example.com/api
+
 # Database Configuration
 DATABASE_CLIENT=pg
 DB_HOST=localhost
@@ -39,6 +44,7 @@ SMTP_PASS=your-sendgrid-api-key
 EMAIL_FROM=noreply@example.com

 # Storage Paths
+# IMPORTANT: STORAGE_PATH must be set to avoid file path resolution issues
 # Docker deployment:
 STORAGE_PATH=/app/storage
 EVENTS_PATH=/app/storage/events
@@ -1,6 +1,6 @@
 # Database Migrations

-This directory contains database migrations for the Wedding Photo Sharing platform.
+This directory contains database migrations for the PicPeak photo sharing platform.

 ## Directory Structure

@@ -9,6 +9,7 @@ Essential migrations that are always run for new deployments. These include:
 - `init.js` - Initial database schema creation
 - Backup service tables (029-035)
 - Gallery feedback tables (033)
+- Pre-generated watermarks (061)

 ### `/legacy`
 Migrations needed only when upgrading from older versions. New deployments can skip these as the core schema already includes all necessary tables and columns.
@@ -0,0 +1,53 @@
+/**
+ * Migration: Add optional event date and expiration settings
+ * These settings control whether event_date and expiration are required
+ * when creating new events, supporting non-event use cases like portraits.
+ */
+
+exports.up = async function(knex) {
+  // Add new settings for optional date and expiration
+  const settings = [
+    { setting_key: 'event_require_event_date', setting_value: JSON.stringify(true), setting_type: 'boolean' },
+    { setting_key: 'event_require_expiration', setting_value: JSON.stringify(true), setting_type: 'boolean' }
+  ];
+
+  for (const setting of settings) {
+    const exists = await knex('app_settings').where('setting_key', setting.setting_key).first();
+    if (!exists) {
+      await knex('app_settings').insert({
+        ...setting,
+        updated_at: knex.fn.now()
+      });
+    }
+  }
+
+  // Make event_date and expires_at columns nullable
+  // PostgreSQL supports ALTER COLUMN ... DROP NOT NULL
+  // SQLite requires table recreation (handled differently)
+  const client = knex.client.config.client;
+
+  if (client === 'pg' || client === 'postgresql') {
+    // PostgreSQL: directly alter columns
+    await knex.raw('ALTER TABLE events ALTER COLUMN event_date DROP NOT NULL');
+    await knex.raw('ALTER TABLE events ALTER COLUMN expires_at DROP NOT NULL');
+  } else if (client === 'sqlite3' || client === 'better-sqlite3') {
+    // SQLite: columns are already effectively nullable in most cases
+    // SQLite doesn't enforce NOT NULL as strictly, and altering requires table recreation
+    // For safety, we'll skip the schema change for SQLite as it's complex
+    // The application logic will handle null values appropriately
+    console.log('SQLite detected - skipping schema alteration (columns will accept NULL values)');
+  }
+};
+
+exports.down = async function(knex) {
+  // Remove the settings
+  await knex('app_settings')
+    .whereIn('setting_key', [
+      'event_require_event_date',
+      'event_require_expiration'
+    ])
+    .del();
+
+  // Note: We don't restore NOT NULL constraints as that could fail
+  // if there are existing NULL values in the database
+};
@@ -0,0 +1,28 @@
+/**
+ * Migration 061: Add pre-generated watermark path to photos table
+ * - photos.watermark_path: path to pre-generated watermarked image
+ * - photos.watermark_generated_at: timestamp of watermark generation
+ */
+
+const { addColumnIfNotExists } = require('../helpers');
+
+exports.up = async function(knex) {
+  console.log('Running migration: 061_add_watermark_path');
+
+  // photos.watermark_path (nullable - path to pre-generated watermarked image)
+  await addColumnIfNotExists(knex, 'photos', 'watermark_path', (table) => {
+    table.string('watermark_path', 512);
+  });
+
+  // photos.watermark_generated_at (nullable - when watermark was last generated)
+  await addColumnIfNotExists(knex, 'photos', 'watermark_generated_at', (table) => {
+    table.timestamp('watermark_generated_at');
+  });
+
+  console.log('Migration 061_add_watermark_path completed');
+};
+
+exports.down = async function(knex) {
+  console.log('Rollback: 061_add_watermark_path');
+  // Keep columns (safe rollback not removing data). Intentionally no-op.
+};
@@ -1,6 +1,6 @@
 {
  "name": "picpeak-backend",
-  "version": "2.3.0",
+  "version": "3.2.5-beta.0",
  "description": "Backend for PicPeak event photo sharing platform",
  "main": "server.js",
  "scripts": {
@@ -8,6 +8,7 @@
    "dev": "nodemon server.js",
    "migrate": "node migrations/run-migrations.js",
    "migrate:safe": "node migrations/run-migrations-safe.js",
+    "generate:watermarks": "node scripts/generate-watermarks.js",
    "test": "jest",
    "lint": "eslint src/"
  },
@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+/**
+ * Script to generate pre-watermarked versions for existing photos
+ * This is a one-time migration script to populate watermarks for photos
+ * that existed before the pre-generation feature was implemented.
+ *
+ * Usage: node scripts/generate-watermarks.js [eventId]
+ *
+ * Options:
+ *   eventId - Optional: Only generate watermarks for a specific event
+ *
+ * Examples:
+ *   node scripts/generate-watermarks.js          # Generate for all photos
+ *   node scripts/generate-watermarks.js 5        # Generate for event ID 5
+ */
+
+const path = require('path');
+const { db } = require('../src/database/db');
+const watermarkService = require('../src/services/watermarkService');
+const watermarkGeneratorService = require('../src/services/watermarkGeneratorService');
+
+async function generateWatermarks(eventId = null) {
+  try {
+    console.log('='.repeat(60));
+    console.log('PicPeak Watermark Generation Script');
+    console.log('='.repeat(60));
+
+    // Check if watermarking is enabled
+    const settings = await watermarkService.getWatermarkSettings();
+
+    if (!settings || !settings.enabled) {
+      console.log('\nWatermarking is currently DISABLED in settings.');
+      console.log('Enable watermarking in Admin > Branding settings first.');
+      console.log('Exiting without generating watermarks.');
+      process.exit(0);
+    }
+
+    console.log('\nWatermark Settings:');
+    console.log(`  Enabled: ${settings.enabled}`);
+    console.log(`  Position: ${settings.position}`);
+    console.log(`  Opacity: ${settings.opacity}%`);
+    console.log(`  Size: ${settings.size}%`);
+    console.log(`  Logo: ${settings.logoPath || '(using text fallback)'}`);
+
+    // Build query
+    let query = db('photos')
+      .join('events', 'photos.event_id', 'events.id')
+      .whereNull('photos.watermark_path')
+      .whereNot(function() {
+        this.where('photos.media_type', 'video')
+          .orWhere('photos.mime_type', 'like', 'video/%');
+      })
+      .select(
+        'photos.id',
+        'photos.filename',
+        'photos.event_id',
+        'events.event_name'
+      );
+
+    if (eventId) {
+      query = query.where('photos.event_id', eventId);
+      console.log(`\nFiltering to event ID: ${eventId}`);
+    }
+
+    const photos = await query;
+
+    if (photos.length === 0) {
+      console.log('\nNo photos found without watermarks.');
+      if (eventId) {
+        console.log(`(Checked event ID: ${eventId})`);
+      }
+      console.log('All photos already have pre-generated watermarks or watermarking is disabled.');
+      process.exit(0);
+    }
+
+    console.log(`\nFound ${photos.length} photos without watermarks.`);
+
+    // Group by event for display
+    const eventCounts = {};
+    photos.forEach(p => {
+      eventCounts[p.event_name] = (eventCounts[p.event_name] || 0) + 1;
+    });
+
+    console.log('\nPhotos by event:');
+    Object.entries(eventCounts).forEach(([name, count]) => {
+      console.log(`  ${name}: ${count} photos`);
+    });
+
+    console.log('\nStarting watermark generation...\n');
+
+    let successCount = 0;
+    let failCount = 0;
+    const startTime = Date.now();
+
+    // Process photos with progress display
+    for (let i = 0; i < photos.length; i++) {
+      const photo = photos[i];
+      const progress = Math.round(((i + 1) / photos.length) * 100);
+
+      process.stdout.write(`\r[${progress}%] Processing photo ${i + 1}/${photos.length}: ${photo.filename.substring(0, 30)}...`);
+
+      try {
+        const result = await watermarkGeneratorService.generateForPhoto(photo.id);
+
+        if (result.success) {
+          successCount++;
+        } else {
+          failCount++;
+          console.log(`\n  Failed: ${photo.filename} - ${result.error}`);
+        }
+      } catch (error) {
+        failCount++;
+        console.log(`\n  Error: ${photo.filename} - ${error.message}`);
+      }
+    }
+
+    const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+
+    console.log('\n');
+    console.log('='.repeat(60));
+    console.log('Watermark Generation Complete');
+    console.log('='.repeat(60));
+    console.log(`  Total processed: ${photos.length}`);
+    console.log(`  Successful: ${successCount}`);
+    console.log(`  Failed: ${failCount}`);
+    console.log(`  Duration: ${duration} seconds`);
+    console.log(`  Average: ${(photos.length / parseFloat(duration)).toFixed(1)} photos/second`);
+
+    if (failCount > 0) {
+      console.log('\nSome watermarks failed to generate. Check the errors above.');
+      console.log('You can re-run this script to retry failed photos.');
+    }
+
+    process.exit(failCount > 0 ? 1 : 0);
+  } catch (error) {
+    console.error('\nFatal error:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const eventId = args[0] ? parseInt(args[0], 10) : null;
+
+if (args[0] && isNaN(eventId)) {
+  console.error('Error: eventId must be a number');
+  console.log('Usage: node scripts/generate-watermarks.js [eventId]');
+  process.exit(1);
+}
+
+// Run the script
+generateWatermarks(eventId)
+  .then(() => {
+    process.exit(0);
+  })
+  .catch(error => {
+    console.error('Unhandled error:', error);
+    process.exit(1);
+  });
@@ -168,9 +168,10 @@ async function galleryAuth(req, res, next) {
      return res.status(404).json({ error: 'Gallery not found or expired' });
    }
    
-    // Check if gallery has expired
-    if (new Date(event.expires_at) < new Date()) {
-      return res.status(410).json({ 
+    // Check if gallery has expired (only if expires_at is set)
+    // Galleries with null expires_at never expire
+    if (event.expires_at && new Date(event.expires_at) < new Date()) {
+      return res.status(410).json({
        error: 'Gallery has expired',
        code: 'GALLERY_EXPIRED'
      });
@@ -25,14 +25,18 @@ const getEventFieldRequirements = async () => {
      .whereIn('setting_key', [
        'event_require_customer_name',
        'event_require_customer_email',
-        'event_require_admin_email'
+        'event_require_admin_email',
+        'event_require_event_date',
+        'event_require_expiration'
      ])
      .select('setting_key', 'setting_value');

    const requirements = {
      require_customer_name: true,
      require_customer_email: true,
-      require_admin_email: true
+      require_admin_email: true,
+      require_event_date: true,
+      require_expiration: true
    };

    settings.forEach(s => {
@@ -47,6 +51,8 @@ const getEventFieldRequirements = async () => {
      if (s.setting_key === 'event_require_customer_name') requirements.require_customer_name = value;
      if (s.setting_key === 'event_require_customer_email') requirements.require_customer_email = value;
      if (s.setting_key === 'event_require_admin_email') requirements.require_admin_email = value;
+      if (s.setting_key === 'event_require_event_date') requirements.require_event_date = value;
+      if (s.setting_key === 'event_require_expiration') requirements.require_expiration = value;
    });

    return requirements;
@@ -55,7 +61,9 @@ const getEventFieldRequirements = async () => {
    return {
      require_customer_name: true,
      require_customer_email: true,
-      require_admin_email: true
+      require_admin_email: true,
+      require_event_date: true,
+      require_expiration: true
    };
  }
 };
@@ -106,7 +114,7 @@ const hasCustomerContactColumns = async () => {
 router.post('/', adminAuth, requirePermission('events.create'), [
  body('event_type').isIn(['wedding', 'birthday', 'corporate', 'other']),
  body('event_name').notEmpty().trim(),
-  body('event_date').isDate(),
+  body('event_date').optional().isDate(),
  body('customer_name').optional().trim(),
  body('customer_email').optional().isEmail().normalizeEmail(),
  body('admin_email').optional().isEmail().normalizeEmail(),
@@ -201,6 +209,9 @@ router.post('/', adminAuth, requirePermission('events.create'), [
    if (fieldRequirements.require_admin_email && !admin_email) {
      validationErrors.push({ path: 'admin_email', msg: 'Admin email is required' });
    }
+    if (fieldRequirements.require_event_date && !event_date) {
+      validationErrors.push({ path: 'event_date', msg: 'Event date is required' });
+    }

    if (validationErrors.length > 0) {
      return res.status(400).json({ errors: validationErrors });
@@ -245,10 +256,13 @@ router.post('/', adminAuth, requirePermission('events.create'), [
      .replace(/[^a-z0-9]/g, '-') // Replace non-alphanumeric with dash
      .replace(/-+/g, '-')         // Replace multiple dashes with single dash
      .replace(/^-|-$/g, '');      // Remove leading/trailing dashes
-    const baseSlug = `${event_type}-${processedEventName}-${event_date}`;
+
+    // Use event_date in slug if provided, otherwise use random suffix
+    const slugSuffix = event_date || crypto.randomBytes(3).toString('hex');
+    const baseSlug = `${event_type}-${processedEventName}-${slugSuffix}`;
    let slug = baseSlug;
    let counter = 1;
-    
+
    while (await db('events').where({ slug }).first()) {
      slug = `${baseSlug}-${counter}`;
      counter++;
@@ -264,15 +278,20 @@ router.post('/', adminAuth, requirePermission('events.create'), [
      : await bcrypt.hash(crypto.randomBytes(32).toString('hex'), getBcryptRounds());
    
    // Calculate expiration date (days after event date)
-    // Parse YYYY-MM-DD format as local date to avoid timezone issues
-    let expires_at;
-    if (event_date.match(/^\d{4}-\d{2}-\d{2}$/)) {
-      const [year, month, day] = event_date.split('-').map(num => parseInt(num, 10));
-      expires_at = new Date(year, month - 1, day);
-    } else {
-      expires_at = new Date(event_date);
+    // If expiration is not required, expires_at will be null (never expires)
+    // If event_date is not provided, use current date as base for expiration
+    let expires_at = null;
+    if (fieldRequirements.require_expiration) {
+      const baseDate = event_date || new Date().toISOString().split('T')[0];
+      // Parse YYYY-MM-DD format as local date to avoid timezone issues
+      if (baseDate.match(/^\d{4}-\d{2}-\d{2}$/)) {
+        const [year, month, day] = baseDate.split('-').map(num => parseInt(num, 10));
+        expires_at = new Date(year, month - 1, day);
+      } else {
+        expires_at = new Date(baseDate);
+      }
+      expires_at.setDate(expires_at.getDate() + parseInt(expiration_days, 10));
    }
-    expires_at.setDate(expires_at.getDate() + parseInt(expiration_days, 10));
    
    // Create folder structure
    const storagePath = process.env.STORAGE_PATH || path.join(__dirname, '../../../storage');
@@ -285,7 +304,7 @@ router.post('/', adminAuth, requirePermission('events.create'), [
      slug,
      event_type,
      event_name,
-      event_date,
+      event_date: event_date || null,
      ...(customerColumnsAvailable ? { customer_name: customerName, customer_email: customerEmail } : {}),
      host_name: customerName,
      host_email: customerEmail,
@@ -295,7 +314,7 @@ router.post('/', adminAuth, requirePermission('events.create'), [
      color_theme,
      share_link: shareLinkToStore,
      share_token: shareToken,
-      expires_at: expires_at.toISOString(),
+      expires_at: expires_at ? expires_at.toISOString() : null,
      created_at: new Date().toISOString(),
      created_by: req.admin.id,
      allow_user_uploads,
@@ -350,7 +369,7 @@ router.post('/', adminAuth, requirePermission('events.create'), [
        event_date: event_date,  // Pass raw date - will be formatted by email processor
        gallery_link: shareUrl,
        gallery_password: requirePassword ? password : 'No password required',
-        expiry_date: expires_at.toISOString(),  // Pass ISO string - will be formatted by email processor
+        expiry_date: expires_at ? expires_at.toISOString() : null,  // Pass ISO string - will be formatted by email processor
        welcome_message: welcome_message || ''
      }),
      status: 'pending',
@@ -367,7 +386,7 @@ router.post('/', adminAuth, requirePermission('events.create'), [
      customer_email: customerEmail,
      require_password: requirePassword,
      share_link: shareUrl,
-      expires_at: expires_at.toISOString(),
+      expires_at: expires_at ? expires_at.toISOString() : null,
      created_at: new Date().toISOString()
    });
  } catch (error) {
@@ -12,6 +12,7 @@ const { validateUploadedFiles } = require('../middleware/uploadValidation');
 const { getMaxFilesPerUpload } = require('../services/uploadSettings');
 const { processUploadedPhotos } = require('../services/photoProcessor');
 const chunkedUpload = require('../services/chunkedUploadService');
+const watermarkGeneratorService = require('../services/watermarkGeneratorService');
 const router = express.Router();

 // Get storage path from environment or default
@@ -308,7 +309,7 @@ router.post('/:eventId/upload', adminAuth, requirePermission('photos.upload'), u
              let thumbnailPath = null;
              try {
                thumbnailPath = await generateThumbnail(operation.finalPath);
-                
+
                // Update the database with thumbnail path
                if (thumbnailPath && insertedIds[idx]) {
                  const photoId = insertedIds[idx]?.id || insertedIds[idx];
@@ -319,6 +320,14 @@ router.post('/:eventId/upload', adminAuth, requirePermission('photos.upload'), u
              } catch (thumbError) {
                console.error(`Thumbnail generation failed for ${operation.filename}:`, thumbError.message);
              }
+
+              // Queue watermark generation in background (non-blocking)
+              // This pre-generates watermarked versions for fast serving in lightbox
+              if (insertedIds[idx]) {
+                const photoId = insertedIds[idx]?.id || insertedIds[idx];
+                watermarkGeneratorService.generateForPhoto(photoId)
+                  .catch(err => console.warn(`Watermark generation queued failed for photo ${photoId}:`, err.message));
+              }
              
              // Add to successful uploads
              uploadedPhotos.push({
@@ -461,7 +470,12 @@ router.delete('/:eventId/photos/:photoId', adminAuth, requirePermission('photos.
        }
      }
    }
-    
+
+    // Delete pre-generated watermark if exists
+    if (photo.watermark_path) {
+      await watermarkGeneratorService.deleteForPhoto(photo.id);
+    }
+
    // Remove from database
    await db('photos').where({ id: photoId }).delete();
    
@@ -582,8 +596,13 @@ router.post('/:eventId/photos/bulk-delete', adminAuth, requirePermission('photos
          }
        }
      }
+
+      // Delete pre-generated watermark
+      if (photo.watermark_path) {
+        await watermarkGeneratorService.deleteForPhoto(photo.id);
+      }
    }
-    
+
    // Delete from database
    await db('photos')
      .whereIn('id', photoIds)
@@ -23,6 +23,8 @@ const { clearShareLinkSettingsCache } = require('../services/shareLinkService');
 const { resetSecurityConfigCache } = require('../utils/authSecurity');
 const router = express.Router();
 const { clearMaxFilesPerUploadCache, MAX_ALLOWED_FILES_PER_UPLOAD } = require('../services/uploadSettings');
+const watermarkService = require('../services/watermarkService');
+const watermarkGeneratorService = require('../services/watermarkGeneratorService');

 const getStoragePath = () => process.env.STORAGE_PATH || path.join(__dirname, '../../../storage');

@@ -100,13 +102,20 @@ router.get('/', adminAuth, requirePermission('settings.view'), async (req, res)
    // Convert to object format
    const settingsObject = {};
    settings.forEach(setting => {
-      if (setting.setting_value) {
-        try {
-          // Try to parse as JSON first
-          settingsObject[setting.setting_key] = JSON.parse(setting.setting_value);
-        } catch (e) {
-          // If it's not valid JSON, use the raw value
+      // Check for null/undefined explicitly to handle boolean false and 0 values
+      // PostgreSQL json column returns parsed values (false as boolean, not string)
+      if (setting.setting_value !== null && setting.setting_value !== undefined) {
+        // If the value is already parsed (from json column), use it directly
+        if (typeof setting.setting_value !== 'string') {
          settingsObject[setting.setting_key] = setting.setting_value;
+        } else {
+          try {
+            // Try to parse as JSON first
+            settingsObject[setting.setting_key] = JSON.parse(setting.setting_value);
+          } catch (e) {
+            // If it's not valid JSON, use the raw value
+            settingsObject[setting.setting_key] = setting.setting_value;
+          }
        }
      } else {
        settingsObject[setting.setting_key] = null;
@@ -127,17 +136,24 @@ router.get('/:type', adminAuth, requirePermission('settings.view'), async (req,
    const settings = await db('app_settings')
      .where('setting_type', type)
      .select('*');
-    
+
    // Convert to object format
    const settingsObject = {};
    settings.forEach(setting => {
-      if (setting.setting_value) {
-        try {
-          // Try to parse as JSON first
-          settingsObject[setting.setting_key] = JSON.parse(setting.setting_value);
-        } catch (e) {
-          // If it's not valid JSON, use the raw value
+      // Check for null/undefined explicitly to handle boolean false and 0 values
+      // PostgreSQL json column returns parsed values (false as boolean, not string)
+      if (setting.setting_value !== null && setting.setting_value !== undefined) {
+        // If the value is already parsed (from json column), use it directly
+        if (typeof setting.setting_value !== 'string') {
          settingsObject[setting.setting_key] = setting.setting_value;
+        } else {
+          try {
+            // Try to parse as JSON first
+            settingsObject[setting.setting_key] = JSON.parse(setting.setting_value);
+          } catch (e) {
+            // If it's not valid JSON, use the raw value
+            settingsObject[setting.setting_key] = setting.setting_value;
+          }
        }
      } else {
        settingsObject[setting.setting_key] = null;
@@ -196,6 +212,9 @@ router.put('/branding', adminAuth, requirePermission('settings.edit'), async (re
      hide_powered_by
    } = req.body;

+    // Get current watermark settings hash for change detection
+    const oldSettingsHash = await watermarkService.getSettingsHash();
+
    const brandingSettings = {
      company_name,
      company_tagline,
@@ -306,7 +325,40 @@ router.put('/branding', adminAuth, requirePermission('settings.edit'), async (re

    clearPublicSiteCache();

-    res.json({ message: 'Branding settings updated successfully' });
+    // Check if watermark settings changed and trigger regeneration
+    const newSettingsHash = await watermarkService.getSettingsHash();
+    let watermarkRegenerationStarted = false;
+
+    if (oldSettingsHash !== newSettingsHash) {
+      // Clear watermark cache
+      watermarkService.clearCache();
+
+      // Check if watermarking is now enabled or settings changed
+      const currentSettings = await watermarkService.getWatermarkSettings();
+
+      if (currentSettings && currentSettings.enabled) {
+        // Start background regeneration of all watermarks
+        console.log('Watermark settings changed, starting background regeneration');
+        watermarkGeneratorService.regenerateAll()
+          .then(result => {
+            console.log(`Watermark regeneration completed: ${result.success}/${result.total} successful`);
+          })
+          .catch(err => {
+            console.error('Watermark regeneration failed:', err);
+          });
+        watermarkRegenerationStarted = true;
+      } else {
+        // Watermarking was disabled, clear all pre-generated watermarks
+        console.log('Watermarking disabled, clearing pre-generated watermarks');
+        watermarkGeneratorService.clearAllWatermarks()
+          .catch(err => console.error('Failed to clear watermarks:', err));
+      }
+    }
+
+    res.json({
+      message: 'Branding settings updated successfully',
+      watermarkRegenerationStarted
+    });
  } catch (error) {
    console.error('Branding update error:', error);
    res.status(500).json({ error: 'Failed to update branding settings' });
@@ -441,9 +493,27 @@ router.post('/branding/watermark-logo', adminAuth, requirePermission('settings.e
        updated_at: new Date()
      });

-    res.json({ 
+    // Trigger watermark regeneration since the logo changed
+    watermarkService.clearCache();
+    const currentSettings = await watermarkService.getWatermarkSettings();
+    let watermarkRegenerationStarted = false;
+
+    if (currentSettings && currentSettings.enabled) {
+      console.log('Watermark logo changed, starting background regeneration');
+      watermarkGeneratorService.regenerateAll()
+        .then(result => {
+          console.log(`Watermark regeneration completed: ${result.success}/${result.total} successful`);
+        })
+        .catch(err => {
+          console.error('Watermark regeneration failed:', err);
+        });
+      watermarkRegenerationStarted = true;
+    }
+
+    res.json({
      message: 'Watermark logo uploaded successfully',
-      watermarkLogoUrl: publicPath
+      watermarkLogoUrl: publicPath,
+      watermarkRegenerationStarted
    });
  } catch (error) {
    console.error('Watermark logo upload error:', error);
@@ -5,6 +5,7 @@ const archiver = require('archiver');
 const path = require('path');
 const router = express.Router();
 const watermarkService = require('../services/watermarkService');
+const watermarkGeneratorService = require('../services/watermarkGeneratorService');
 const { verifyGalleryAccess } = require('../middleware/gallery');
 const secureImageService = require('../services/secureImageService');
 const logger = require('../utils/logger');
@@ -15,7 +16,7 @@ const { NotFoundError } = require('../utils/errors');
 const { ensureThumbnail } = require('../services/imageProcessor');

 // Get storage path from environment or default
-const getStoragePath = () => process.env.STORAGE_PATH || path.join(__dirname, '../../storage');
+const getStoragePath = () => process.env.STORAGE_PATH || path.join(__dirname, '../../../storage');

 // Check for slug redirect (for renamed events)
 async function checkSlugRedirect(slug) {
@@ -107,6 +108,7 @@ router.get('/:slug/info', async (req, res) => {
        'share_link',
        'share_token',
        'allow_downloads',
+        'allow_user_uploads',
        'disable_right_click',
        'watermark_downloads',
        'watermark_text',
@@ -151,10 +153,11 @@ router.get('/:slug/info', async (req, res) => {
      event_date: event.event_date,
      expires_at: event.expires_at,
      is_active: event.is_active,
-      is_expired: !event.is_active || new Date(event.expires_at) < new Date(),
+      is_expired: !event.is_active || (event.expires_at && new Date(event.expires_at) < new Date()),
      requires_password: requiresPassword,
      color_theme: event.color_theme,
      allow_downloads: !(event.allow_downloads === false || event.allow_downloads === 0 || event.allow_downloads === '0'),
+      allow_user_uploads: event.allow_user_uploads === true || event.allow_user_uploads === 1 || event.allow_user_uploads === '1',
      disable_right_click: event.disable_right_click === true || event.disable_right_click === 1 || event.disable_right_click === '1',
      watermark_downloads: event.watermark_downloads === true || event.watermark_downloads === 1 || event.watermark_downloads === '1',
      watermark_text: event.watermark_text,
@@ -323,6 +326,7 @@ router.get('/:slug/photos', verifyGalleryAccess, async (req, res) => {
        expires_at: req.event.expires_at,
        hero_photo_id: req.event.hero_photo_id,
        allow_downloads: req.event.allow_downloads !== false,
+        allow_user_uploads: req.event.allow_user_uploads === true,
        disable_right_click: req.event.disable_right_click === true,
        watermark_downloads: req.event.watermark_downloads === true,
        watermark_text: req.event.watermark_text,
@@ -777,9 +781,35 @@ router.get('/:slug/photo/:photoId',
      }

      if (watermarkSettings && watermarkSettings.enabled) {
-        // Apply watermark and send
+        // Try to serve pre-generated watermarked file for instant loading
+        if (photo.watermark_path) {
+          const watermarkFilePath = path.join(getStoragePath(), photo.watermark_path);
+          try {
+            const fs = require('fs');
+            // Check if pre-generated watermark file exists
+            if (fs.existsSync(watermarkFilePath)) {
+              res.set({
+                'Content-Type': photo.mime_type || 'image/jpeg',
+                'Cache-Control': 'private, max-age=1800',
+                'ETag': etag,
+                'X-Protection-Level': 'basic'
+              });
+              return res.sendFile(watermarkFilePath);
+            }
+          } catch (err) {
+            // File doesn't exist or error, fall through to on-the-fly generation
+            logger.warn(`Pre-generated watermark not found for photo ${photoId}, falling back to on-the-fly`);
+          }
+        }
+
+        // Fallback: Apply watermark on-the-fly (slower, but ensures image is served)
+        // Also queue regeneration for next time
        const watermarkedBuffer = await watermarkService.applyWatermark(filePath, watermarkSettings);

+        // Queue watermark generation in background for next request
+        watermarkGeneratorService.generateForPhoto(photo.id)
+          .catch(err => logger.warn(`Background watermark generation failed for photo ${photo.id}:`, err.message));
+
        res.set({
          'Content-Type': photo.mime_type || 'image/jpeg',
          'Cache-Control': 'private, max-age=1800', // Cache for 30 minutes
@@ -74,7 +74,9 @@ router.get('/', async (req, res) => {
      // Event field requirements
      event_require_customer_name: settingsObject.event_require_customer_name !== false,
      event_require_customer_email: settingsObject.event_require_customer_email !== false,
-      event_require_admin_email: settingsObject.event_require_admin_email !== false
+      event_require_admin_email: settingsObject.event_require_admin_email !== false,
+      event_require_event_date: settingsObject.event_require_event_date !== false,
+      event_require_expiration: settingsObject.event_require_expiration !== false
    };

    res.json(publicSettings);
@@ -15,7 +15,7 @@ const { validatePasswordInContext, getBcryptRounds } = require('../utils/passwor
 const { buildShareLinkVariants } = require('./shareLinkService');
 const { parseBooleanInput, parseStringInput } = require('../utils/parsers');

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

 // Cache for schema detection
 let customerColumnCache = null;
@@ -21,9 +21,11 @@ async function checkExpirations() {
    const warningDate = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000); // 7 days from now
    
    // Check for events needing warning emails
+    // Skip events with null expires_at (they never expire)
    const eventsNeedingWarning = await db('events')
      .where('is_active', formatBoolean(true))
      .where('is_archived', formatBoolean(false))
+      .whereNotNull('expires_at')
      .where('expires_at', '<=', warningDate)
      .where('expires_at', '>', now);
    
@@ -40,9 +42,11 @@ async function checkExpirations() {
    }
    
    // Check for expired events
+    // Skip events with null expires_at (they never expire)
    const expiredEvents = await db('events')
      .where('is_active', formatBoolean(true))
      .where('is_archived', formatBoolean(false))
+      .whereNotNull('expires_at')
      .where('expires_at', '<=', now);
    
    for (const event of expiredEvents) {
@@ -10,7 +10,7 @@ const fs = require('fs').promises;
 const { db } = require('../database/db');
 const { formatBoolean } = require('../utils/dbCompat');

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

 /**
 * Get photos for an event with optional filtering
@@ -60,7 +60,7 @@ async function createInvitation({ email, roleId, invitedById }) {
  // Queue invitation email
  const frontendUrl = process.env.FRONTEND_URL || process.env.ADMIN_URL || 'http://localhost:3005';
  await queueEmail(null, email, 'admin_invitation', {
-    invite_link: `${frontendUrl}/admin/accept-invite/${token}`,
+    invite_link: `${frontendUrl}/invite/${token}`,
    role_name: role.display_name,
    expires_at: expiresAt.toISOString()
  });
@@ -0,0 +1,433 @@
+/**
+ * WatermarkGeneratorService
+ *
+ * Handles batch generation of pre-watermarked images for fast serving.
+ * This service is responsible for:
+ * - Generating watermarks for newly uploaded photos
+ * - Regenerating all watermarks when settings change
+ * - Tracking regeneration progress
+ */
+
+const path = require('path');
+const { db } = require('../database/db');
+const watermarkService = require('./watermarkService');
+const { getStoragePath } = require('../config/storage');
+
+class WatermarkGeneratorService {
+  constructor() {
+    // Track active regeneration jobs
+    this.activeJobs = new Map();
+    // Batch size for processing (to manage memory)
+    this.batchSize = 10;
+    // Concurrent processing limit
+    this.concurrentLimit = 2;
+  }
+
+  /**
+   * Generate watermark for a single photo
+   * @param {number} photoId - The photo ID
+   * @returns {Object} Result with success status and watermark path
+   */
+  async generateForPhoto(photoId) {
+    try {
+      // Get photo with event info
+      const photo = await db('photos')
+        .join('events', 'photos.event_id', 'events.id')
+        .where('photos.id', photoId)
+        .select(
+          'photos.*',
+          'events.slug',
+          'events.source_mode',
+          'events.external_path'
+        )
+        .first();
+
+      if (!photo) {
+        return { success: false, error: 'Photo not found' };
+      }
+
+      // Skip video files
+      if (photo.media_type === 'video' || (photo.mime_type && photo.mime_type.startsWith('video/'))) {
+        return { success: false, error: 'Videos do not support watermarks' };
+      }
+
+      // Get watermark settings
+      const settings = await watermarkService.getWatermarkSettings();
+      if (!settings || !settings.enabled) {
+        return { success: false, error: 'Watermarking is disabled' };
+      }
+
+      // Resolve the original file path
+      const originalPath = this.resolvePhotoPath(photo);
+      if (!originalPath) {
+        return { success: false, error: 'Could not resolve photo path' };
+      }
+
+      // Generate and save watermark
+      const result = await watermarkService.generateAndSaveWatermark(photo, originalPath, settings);
+
+      if (result.success) {
+        // Update database with watermark path
+        await db('photos')
+          .where({ id: photoId })
+          .update({
+            watermark_path: result.watermarkPath,
+            watermark_generated_at: db.fn.now()
+          });
+      }
+
+      return result;
+    } catch (error) {
+      console.error(`Error generating watermark for photo ${photoId}:`, error);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Resolve the full file path for a photo
+   */
+  resolvePhotoPath(photo) {
+    const storagePath = getStoragePath();
+
+    // Handle external/reference mode
+    if (photo.source_mode === 'reference' && photo.external_relpath) {
+      const externalRoot = process.env.EXTERNAL_MEDIA_PATH || path.join(storagePath, 'external');
+      return path.join(externalRoot, photo.external_path || '', photo.external_relpath);
+    }
+
+    // Standard managed mode
+    if (photo.file_path) {
+      // file_path might be absolute or relative
+      if (path.isAbsolute(photo.file_path)) {
+        return photo.file_path;
+      }
+      return path.join(storagePath, photo.file_path);
+    }
+
+    // Fallback to constructing path from slug and filename
+    return path.join(storagePath, 'events', 'active', photo.slug, photo.filename);
+  }
+
+  /**
+   * Generate watermarks for all photos in an event
+   * @param {number} eventId - The event ID
+   * @param {Function} onProgress - Optional callback for progress updates
+   * @returns {Object} Result with success count and errors
+   */
+  async generateForEvent(eventId, onProgress = null) {
+    const results = { total: 0, success: 0, failed: 0, errors: [] };
+
+    try {
+      // Get all photos for the event (excluding videos)
+      const photos = await db('photos')
+        .join('events', 'photos.event_id', 'events.id')
+        .where('photos.event_id', eventId)
+        .whereNot(function() {
+          this.where('photos.media_type', 'video')
+            .orWhere('photos.mime_type', 'like', 'video/%');
+        })
+        .select(
+          'photos.*',
+          'events.slug',
+          'events.source_mode',
+          'events.external_path'
+        );
+
+      results.total = photos.length;
+
+      if (photos.length === 0) {
+        return results;
+      }
+
+      // Get watermark settings once
+      const settings = await watermarkService.getWatermarkSettings();
+      if (!settings || !settings.enabled) {
+        return { ...results, errors: ['Watermarking is disabled'] };
+      }
+
+      // Process in batches
+      for (let i = 0; i < photos.length; i += this.batchSize) {
+        const batch = photos.slice(i, i + this.batchSize);
+
+        // Process batch with limited concurrency
+        const batchResults = await Promise.all(
+          batch.map(photo => this.processPhotoWatermark(photo, settings))
+        );
+
+        // Collect results
+        for (const result of batchResults) {
+          if (result.success) {
+            results.success++;
+          } else {
+            results.failed++;
+            if (result.error) {
+              results.errors.push(`Photo ${result.photoId}: ${result.error}`);
+            }
+          }
+        }
+
+        // Progress callback
+        if (onProgress) {
+          onProgress({
+            total: results.total,
+            processed: results.success + results.failed,
+            success: results.success,
+            failed: results.failed
+          });
+        }
+      }
+
+      return results;
+    } catch (error) {
+      console.error(`Error generating watermarks for event ${eventId}:`, error);
+      return { ...results, errors: [...results.errors, error.message] };
+    }
+  }
+
+  /**
+   * Process watermark for a single photo (internal helper)
+   */
+  async processPhotoWatermark(photo, settings) {
+    try {
+      const originalPath = this.resolvePhotoPath(photo);
+      if (!originalPath) {
+        return { success: false, photoId: photo.id, error: 'Could not resolve path' };
+      }
+
+      const result = await watermarkService.generateAndSaveWatermark(photo, originalPath, settings);
+
+      if (result.success) {
+        await db('photos')
+          .where({ id: photo.id })
+          .update({
+            watermark_path: result.watermarkPath,
+            watermark_generated_at: db.fn.now()
+          });
+      }
+
+      return { ...result, photoId: photo.id };
+    } catch (error) {
+      return { success: false, photoId: photo.id, error: error.message };
+    }
+  }
+
+  /**
+   * Regenerate watermarks for all photos in the system
+   * @param {Function} onProgress - Optional callback for progress updates
+   * @returns {Object} Result with success count and errors
+   */
+  async regenerateAll(onProgress = null) {
+    const jobId = Date.now().toString();
+    const results = { jobId, total: 0, success: 0, failed: 0, errors: [], status: 'running' };
+
+    try {
+      this.activeJobs.set(jobId, results);
+
+      // Get watermark settings
+      const settings = await watermarkService.getWatermarkSettings();
+      if (!settings || !settings.enabled) {
+        results.status = 'completed';
+        results.errors.push('Watermarking is disabled');
+        return results;
+      }
+
+      // First, clear existing watermarks from DB (the files will be overwritten)
+      // This ensures stale paths don't persist if regeneration fails
+
+      // Get all image photos (exclude videos)
+      const photos = await db('photos')
+        .join('events', 'photos.event_id', 'events.id')
+        .whereNot(function() {
+          this.where('photos.media_type', 'video')
+            .orWhere('photos.mime_type', 'like', 'video/%');
+        })
+        .select(
+          'photos.*',
+          'events.slug',
+          'events.source_mode',
+          'events.external_path'
+        );
+
+      results.total = photos.length;
+
+      if (photos.length === 0) {
+        results.status = 'completed';
+        return results;
+      }
+
+      console.log(`Starting watermark regeneration for ${photos.length} photos`);
+
+      // Process in batches
+      for (let i = 0; i < photos.length; i += this.batchSize) {
+        // Check if job was cancelled
+        if (!this.activeJobs.has(jobId)) {
+          results.status = 'cancelled';
+          return results;
+        }
+
+        const batch = photos.slice(i, i + this.batchSize);
+
+        // Process batch with limited concurrency
+        const batchResults = await Promise.all(
+          batch.map(photo => this.processPhotoWatermark(photo, settings))
+        );
+
+        // Collect results
+        for (const result of batchResults) {
+          if (result.success) {
+            results.success++;
+          } else {
+            results.failed++;
+            if (result.error && results.errors.length < 50) {
+              results.errors.push(`Photo ${result.photoId}: ${result.error}`);
+            }
+          }
+        }
+
+        // Update job status
+        this.activeJobs.set(jobId, { ...results });
+
+        // Progress callback
+        if (onProgress) {
+          onProgress({
+            jobId,
+            total: results.total,
+            processed: results.success + results.failed,
+            success: results.success,
+            failed: results.failed,
+            percentComplete: Math.round(((results.success + results.failed) / results.total) * 100)
+          });
+        }
+
+        // Small delay between batches to prevent CPU saturation
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+
+      results.status = 'completed';
+      console.log(`Watermark regeneration completed: ${results.success}/${results.total} successful`);
+
+      return results;
+    } catch (error) {
+      console.error('Error during watermark regeneration:', error);
+      results.status = 'failed';
+      results.errors.push(error.message);
+      return results;
+    } finally {
+      // Clean up job tracking after a delay
+      setTimeout(() => {
+        this.activeJobs.delete(jobId);
+      }, 60000); // Keep for 1 minute for status queries
+    }
+  }
+
+  /**
+   * Clear all watermarks (when watermarking is disabled)
+   */
+  async clearAllWatermarks() {
+    try {
+      // Get all photos with watermarks
+      const photos = await db('photos')
+        .whereNotNull('watermark_path')
+        .select('id', 'watermark_path');
+
+      // Delete watermark files
+      for (const photo of photos) {
+        await watermarkService.deleteWatermarkFile(photo.watermark_path);
+      }
+
+      // Clear database paths
+      await db('photos')
+        .whereNotNull('watermark_path')
+        .update({
+          watermark_path: null,
+          watermark_generated_at: null
+        });
+
+      console.log(`Cleared ${photos.length} watermarks`);
+      return { success: true, cleared: photos.length };
+    } catch (error) {
+      console.error('Error clearing watermarks:', error);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Delete watermark for a specific photo
+   */
+  async deleteForPhoto(photoId) {
+    try {
+      const photo = await db('photos')
+        .where({ id: photoId })
+        .select('watermark_path')
+        .first();
+
+      if (photo && photo.watermark_path) {
+        await watermarkService.deleteWatermarkFile(photo.watermark_path);
+        await db('photos')
+          .where({ id: photoId })
+          .update({
+            watermark_path: null,
+            watermark_generated_at: null
+          });
+      }
+
+      return { success: true };
+    } catch (error) {
+      console.error(`Error deleting watermark for photo ${photoId}:`, error);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Get status of an active regeneration job
+   */
+  getJobStatus(jobId) {
+    return this.activeJobs.get(jobId) || null;
+  }
+
+  /**
+   * Cancel an active regeneration job
+   */
+  cancelJob(jobId) {
+    if (this.activeJobs.has(jobId)) {
+      this.activeJobs.delete(jobId);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Check if there's an active regeneration job
+   */
+  hasActiveJob() {
+    for (const [, job] of this.activeJobs) {
+      if (job.status === 'running') {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Get count of photos needing watermark generation
+   */
+  async getPendingCount() {
+    const settings = await watermarkService.getWatermarkSettings();
+    if (!settings || !settings.enabled) {
+      return 0;
+    }
+
+    const result = await db('photos')
+      .whereNull('watermark_path')
+      .whereNot(function() {
+        this.where('media_type', 'video')
+          .orWhere('mime_type', 'like', 'video/%');
+      })
+      .count('id as count')
+      .first();
+
+    return parseInt(result.count) || 0;
+  }
+}
+
+module.exports = new WatermarkGeneratorService();
@@ -2,6 +2,7 @@ const sharp = require('sharp');
 const path = require('path');
 const fs = require('fs').promises;
 const { db } = require('../database/db');
+const { getStoragePath } = require('../config/storage');

 class WatermarkService {
  constructor() {
@@ -232,6 +233,125 @@ class WatermarkService {
  clearCache() {
    this.cache.clear();
  }
+
+  /**
+   * Get the watermarks directory path, creating it if needed
+   */
+  async getWatermarksDir() {
+    const watermarksDir = path.join(getStoragePath(), 'watermarks');
+    try {
+      await fs.access(watermarksDir);
+    } catch {
+      await fs.mkdir(watermarksDir, { recursive: true });
+    }
+    return watermarksDir;
+  }
+
+  /**
+   * Get the file extension from a filename
+   */
+  getFileExtension(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    // Map common extensions
+    if (ext === '.jpeg') return '.jpg';
+    return ext || '.jpg';
+  }
+
+  /**
+   * Generate watermarked version of a photo and save to disk
+   * @param {Object} photo - Photo object with id, filename, and path info
+   * @param {string} originalPath - Full path to the original image file
+   * @param {Object} settings - Watermark settings (optional, will fetch if not provided)
+   * @returns {Object} { success, watermarkPath, error }
+   */
+  async generateAndSaveWatermark(photo, originalPath, settings = null) {
+    try {
+      // Get settings if not provided
+      if (!settings) {
+        settings = await this.getWatermarkSettings();
+      }
+
+      // If watermarking is disabled, return early
+      if (!settings || !settings.enabled) {
+        return { success: false, watermarkPath: null, error: 'Watermarking is disabled' };
+      }
+
+      // Verify original file exists
+      try {
+        await fs.access(originalPath);
+      } catch {
+        return { success: false, watermarkPath: null, error: 'Original file not found' };
+      }
+
+      // Generate watermarked buffer using existing method
+      const watermarkedBuffer = await this.applyWatermark(originalPath, settings);
+
+      // Determine output path
+      const watermarksDir = await this.getWatermarksDir();
+      const ext = this.getFileExtension(photo.filename);
+      const outputFilename = `${photo.id}_watermarked${ext}`;
+      const outputPath = path.join(watermarksDir, outputFilename);
+
+      // Write the watermarked image to disk
+      await fs.writeFile(outputPath, watermarkedBuffer);
+
+      // Return relative path for database storage
+      const relativePath = `watermarks/${outputFilename}`;
+
+      return {
+        success: true,
+        watermarkPath: relativePath,
+        error: null
+      };
+    } catch (error) {
+      console.error(`Error generating watermark for photo ${photo.id}:`, error);
+      return {
+        success: false,
+        watermarkPath: null,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Delete a pre-generated watermark file
+   * @param {string} watermarkPath - Relative path to the watermark file
+   * @returns {boolean} - True if deleted successfully
+   */
+  async deleteWatermarkFile(watermarkPath) {
+    if (!watermarkPath) return false;
+
+    try {
+      const fullPath = path.join(getStoragePath(), watermarkPath);
+      await fs.unlink(fullPath);
+      return true;
+    } catch (error) {
+      // File might not exist, which is fine
+      if (error.code !== 'ENOENT') {
+        console.error('Error deleting watermark file:', error);
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Create a hash of current watermark settings for change detection
+   * @returns {string} - Hash string of settings
+   */
+  async getSettingsHash() {
+    const settings = await this.getWatermarkSettings();
+    if (!settings) return '';
+
+    const hashData = `${settings.enabled}-${settings.logoPath || ''}-${settings.position}-${settings.opacity}-${settings.size}`;
+    // Simple hash for change detection (not cryptographic)
+    let hash = 0;
+    for (let i = 0; i < hashData.length; i++) {
+      const char = hashData.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash; // Convert to 32bit integer
+    }
+    return hash.toString(16);
+  }
 }

 module.exports = new WatermarkService();
@@ -46,6 +46,7 @@ services:
      - NODE_ENV=production
      - DB_HOST=${DB_HOST:-postgres}
      - REDIS_HOST=redis
+      - STORAGE_PATH=/app/storage
      - PHOTOS_DIR=/app/storage/events
      - PICPEAK_RELEASE_CHANNEL=${PICPEAK_CHANNEL:-stable}
    volumes:
@@ -1,7 +1,7 @@
 {
  "name": "picpeak-frontend",
  "private": true,
-  "version": "2.3.0",
+  "version": "3.2.5-beta.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
@@ -240,11 +240,7 @@ export const GalleryLayout: React.FC<GalleryLayoutProps> = ({
              {/* Right side - Action buttons */}
              <div className="flex items-center gap-2 sm:gap-3 flex-shrink-0">
                {/* Extra header items (upload button, etc.) */}
-                {headerExtra && (
-                  <div className="hidden sm:block">
-                    {headerExtra}
-                  </div>
-                )}
+                {headerExtra}
                
                {/* Download all button - hidden on mobile when sidebar is shown */}
                {showDownloadAll && onDownloadAll && (
@@ -1,5 +1,5 @@
 import React, { useEffect, useRef } from 'react';
-import { X, Download, Filter, SortAsc, Search, Calendar, Type, HardDrive, Check, Upload, Star } from 'lucide-react';
+import { X, Download, Filter, SortAsc, Search, Calendar, Type, HardDrive, Check, Star, Upload } from 'lucide-react';
 import { Button } from '../common';
 import { PhotoCategory } from '../../types';
 import { useTranslation } from 'react-i18next';
@@ -139,18 +139,18 @@ export const GallerySidebar: React.FC<GallerySidebarProps> = ({

        {/* Content */}
        <div className="gallery-sidebar-content flex-1 overflow-y-auto">
-          {/* Upload Section - Only show on mobile when uploads are allowed */}
-          {isMobile && allowUploads && onUploadClick && (
-            <div className="p-4 border-b border-neutral-200">
+          {/* Upload Section - Show prominently at top for mobile users */}
+          {allowUploads && onUploadClick && (
+            <div className="gallery-sidebar-section gallery-sidebar-upload p-4 border-b border-neutral-200">
              <Button
                variant="outline"
                size="sm"
                leftIcon={<Upload className="w-4 h-4" />}
                onClick={() => {
                  onUploadClick();
-                  onClose();
+                  if (isMobile) onClose();
                }}
-                className="w-full"
+                className="gallery-btn w-full"
              >
                {t('upload.uploadPhotos')}
              </Button>
@@ -608,9 +608,9 @@ export const GalleryView: React.FC<GalleryViewProps> = ({ slug, event }) => {
            );
          }
          
-          // Upload button only on desktop when sidebar is shown
+          // Upload button - always show when uploads are allowed (regardless of layout/theme loading state)
          const allowUploads = data?.event?.allow_user_uploads || event?.allow_user_uploads;
-          if (allowUploads && showSidebar && !isMobile) {
+          if (allowUploads) {
            items.push(
              <Button
                key="upload-button"
@@ -618,22 +618,7 @@ export const GalleryView: React.FC<GalleryViewProps> = ({ slug, event }) => {
                size="sm"
                leftIcon={<Upload className="w-4 h-4" />}
                onClick={() => setShowUploadModal(true)}
-              >
-                {t('upload.uploadPhotos')}
-              </Button>
-            );
-          }
-          
-          // Upload button for non-sidebar layouts
-          if (allowUploads && !showSidebar) {
-            items.push(
-              <Button
-                key="upload-button"
-                variant="outline"
-                size="sm"
-                leftIcon={<Upload className="w-4 h-4" />}
-                onClick={() => setShowUploadModal(true)}
-                className="flex-1 sm:flex-initial"
+                className={!showSidebar ? 'flex-1 sm:flex-initial' : ''}
              >
                <span className="hidden sm:inline">{t('upload.uploadPhotos')}</span>
                <span className="sm:hidden">{t('common.upload')}</span>
@@ -49,6 +49,8 @@ export interface EventSettings {
  event_require_customer_name: boolean;
  event_require_customer_email: boolean;
  event_require_admin_email: boolean;
+  event_require_event_date: boolean;
+  event_require_expiration: boolean;
 }

 export function useSettingsState() {
@@ -109,7 +111,9 @@ export function useSettingsState() {
  const [eventSettings, setEventSettings] = useState<EventSettings>({
    event_require_customer_name: true,
    event_require_customer_email: true,
-    event_require_admin_email: true
+    event_require_admin_email: true,
+    event_require_event_date: true,
+    event_require_expiration: true
  });

  // Account form state
@@ -178,7 +182,9 @@ export function useSettingsState() {
      setEventSettings({
        event_require_customer_name: toBoolean(settings.event_require_customer_name, true),
        event_require_customer_email: toBoolean(settings.event_require_customer_email, true),
-        event_require_admin_email: toBoolean(settings.event_require_admin_email, true)
+        event_require_admin_email: toBoolean(settings.event_require_admin_email, true),
+        event_require_event_date: toBoolean(settings.event_require_event_date, true),
+        event_require_expiration: toBoolean(settings.event_require_expiration, true)
      });
    }
  }, [settings, i18n]);
@@ -99,6 +99,56 @@ export const EventsTab: React.FC<EventsTabProps> = ({
              </div>
            </label>
          </div>
+
+          <div>
+            <label className="flex items-start gap-3">
+              <input
+                type="checkbox"
+                checked={eventSettings.event_require_event_date}
+                onChange={(e) => setEventSettings(prev => ({ ...prev, event_require_event_date: e.target.checked }))}
+                className="mt-1 w-4 h-4 text-primary-600 rounded focus:ring-primary-500"
+              />
+              <div>
+                <span className="text-sm font-medium text-neutral-700">
+                  {t('settings.events.requireEventDate', 'Require event date')}
+                </span>
+                <p className="text-xs text-neutral-500 mt-1">
+                  {t('settings.events.requireEventDateHelp', 'Event date must be provided when creating events')}
+                </p>
+                {!eventSettings.event_require_event_date && (
+                  <p className="text-xs text-amber-600 mt-1 flex items-center gap-1">
+                    <AlertCircle className="w-3 h-3" />
+                    {t('settings.events.eventDateWarning', 'Gallery URLs will use random identifiers instead of dates')}
+                  </p>
+                )}
+              </div>
+            </label>
+          </div>
+
+          <div>
+            <label className="flex items-start gap-3">
+              <input
+                type="checkbox"
+                checked={eventSettings.event_require_expiration}
+                onChange={(e) => setEventSettings(prev => ({ ...prev, event_require_expiration: e.target.checked }))}
+                className="mt-1 w-4 h-4 text-primary-600 rounded focus:ring-primary-500"
+              />
+              <div>
+                <span className="text-sm font-medium text-neutral-700">
+                  {t('settings.events.requireExpiration', 'Require expiration date')}
+                </span>
+                <p className="text-xs text-neutral-500 mt-1">
+                  {t('settings.events.requireExpirationHelp', 'Galleries must have an expiration date')}
+                </p>
+                {!eventSettings.event_require_expiration && (
+                  <p className="text-xs text-amber-600 mt-1 flex items-center gap-1">
+                    <AlertCircle className="w-3 h-3" />
+                    {t('settings.events.expirationWarning', 'Galleries without expiration will remain active until manually archived')}
+                  </p>
+                )}
+              </div>
+            </label>
+          </div>
        </div>

        <div className="mt-6">
@@ -759,6 +759,8 @@
    "themeAndStyle": "Design & Stil",
    "galleryWillExpireOn": "Galerie läuft ab am {{date}}",
    "expirationWarning": "Gäste erhalten 7 Tage vor Ablauf eine Warn-E-Mail.",
+    "noExpiration": "Kein Ablaufdatum",
+    "noExpirationHelp": "Diese Galerie bleibt aktiv, bis sie manuell archiviert wird.",
    "userUploads": "Benutzer-Upload-Einstellungen",
    "allowUserUploads": "Gästen erlauben, Fotos hochzuladen",
    "allowUserUploadsHelp": "Ermöglichen Sie Gästen, ihre eigenen Fotos in diese Galerie hochzuladen",
@@ -1048,6 +1050,12 @@
      "requireAdminEmail": "Admin-E-Mail erforderlich",
      "requireAdminEmailHelp": "Admin-E-Mail muss für neue Veranstaltungen angegeben werden",
      "adminEmailWarning": "Erforderlich für den Erhalt von Veranstaltungsbenachrichtigungen",
+      "requireEventDate": "Veranstaltungsdatum erforderlich",
+      "requireEventDateHelp": "Veranstaltungsdatum muss beim Erstellen angegeben werden",
+      "eventDateWarning": "Galerie-URLs verwenden zufällige Kennungen anstelle von Daten",
+      "requireExpiration": "Ablaufdatum erforderlich",
+      "requireExpirationHelp": "Galerien müssen ein Ablaufdatum haben",
+      "expirationWarning": "Galerien ohne Ablaufdatum bleiben aktiv, bis sie manuell archiviert werden",
      "saveSettings": "Veranstaltungseinstellungen speichern",
      "noteTitle": "Hinweis",
      "noteText": "Diese Einstellungen betreffen nur die Erstellung neuer Veranstaltungen. Bestehende Veranstaltungen sind nicht betroffen. Standardmäßig sind alle Felder erforderlich."
@@ -1515,6 +1523,10 @@
    "successMessage": "Ihr Konto wurde erfolgreich erstellt. Sie können sich jetzt mit Ihren Zugangsdaten anmelden.",
    "redirecting": "Weiterleitung zur Anmeldung in {{seconds}}...",
    "goToLogin": "Zur Anmeldung",
+    "contactAdminMessage": "Bitte kontaktieren Sie Ihren Administrator, um eine neue Einladung anzufordern.",
+    "passwordsMatch": "Passwörter stimmen überein",
+    "alreadyHaveAccount": "Bereits ein Konto?",
+    "signIn": "Anmelden",
    "errors": {
      "usernameRequired": "Benutzername ist erforderlich",
      "usernameTooShort": "Benutzername muss mindestens 3 Zeichen lang sein",
@@ -433,6 +433,8 @@
    "expiresOn": "Expires on",
    "galleryWillExpireOn": "Gallery will expire on {{date}}",
    "expirationWarning": "Guests will receive a warning email 7 days before expiration.",
+    "noExpiration": "No Expiration",
+    "noExpirationHelp": "This gallery will remain active until manually archived.",
    "userUploads": "User Upload Settings",
    "allowUserUploads": "Allow guests to upload photos",
    "allowUserUploadsHelp": "Enable guests to upload their own photos to this gallery",
@@ -753,6 +755,12 @@
      "requireAdminEmail": "Require admin email",
      "requireAdminEmailHelp": "Admin email must be provided for new events",
      "adminEmailWarning": "Required for receiving event notifications",
+      "requireEventDate": "Require event date",
+      "requireEventDateHelp": "Event date must be provided when creating events",
+      "eventDateWarning": "Gallery URLs will use random identifiers instead of dates",
+      "requireExpiration": "Require expiration date",
+      "requireExpirationHelp": "Galleries must have an expiration date",
+      "expirationWarning": "Galleries without expiration will remain active until manually archived",
      "saveSettings": "Save Event Settings",
      "noteTitle": "Note",
      "noteText": "These settings only affect new event creation. Existing events are not affected. Default behavior requires all fields."
@@ -1276,6 +1284,10 @@
    "successMessage": "Your account has been created successfully. You can now log in with your credentials.",
    "redirecting": "Redirecting to login in {{seconds}}...",
    "goToLogin": "Go to Login",
+    "contactAdminMessage": "Please contact your administrator to request a new invitation.",
+    "passwordsMatch": "Passwords match",
+    "alreadyHaveAccount": "Already have an account?",
+    "signIn": "Sign in",
    "errors": {
      "usernameRequired": "Username is required",
      "usernameTooShort": "Username must be at least 3 characters",
@@ -148,6 +148,8 @@ export const CreateEventPage: React.FC = () => {
  const requireCustomerName = publicSettings?.event_require_customer_name !== false;
  const requireCustomerEmail = publicSettings?.event_require_customer_email !== false;
  const requireAdminEmail = publicSettings?.event_require_admin_email !== false;
+  const requireEventDate = publicSettings?.event_require_event_date !== false;
+  const requireExpiration = publicSettings?.event_require_expiration !== false;

  // Update default expiration days when settings are loaded
  useEffect(() => {
@@ -201,7 +203,7 @@ export const CreateEventPage: React.FC = () => {
      newErrors.event_name = t('validation.eventNameRequired');
    }

-    if (!formData.event_date) {
+    if (requireEventDate && !formData.event_date) {
      newErrors.event_date = t('validation.eventDateRequired');
    }

@@ -247,7 +249,7 @@ export const CreateEventPage: React.FC = () => {
      }
    }

-    if (formData.expires_in_days < 1 || formData.expires_in_days > 365) {
+    if (requireExpiration && (formData.expires_in_days < 1 || formData.expires_in_days > 365)) {
      newErrors.expires_in_days = t('validation.expirationRange');
    }

@@ -267,7 +269,7 @@ export const CreateEventPage: React.FC = () => {
    const payload = {
      event_type: formData.event_type,
      event_name: formData.event_name,
-      event_date: formData.event_date,
+      event_date: formData.event_date || undefined,
      customer_name: formData.customer_name,
      customer_email: formData.customer_email,
      admin_email: formData.admin_email,
@@ -275,7 +277,7 @@ export const CreateEventPage: React.FC = () => {
      password: formData.require_password ? formData.password : undefined,
      welcome_message: formData.welcome_message || '',
      color_theme: JSON.stringify(formData.theme_config),
-      expiration_days: formData.expires_in_days,
+      expiration_days: requireExpiration ? formData.expires_in_days : undefined,
      allow_user_uploads: formData.allow_user_uploads,
      upload_category_id: formData.upload_category_id,
      css_template_id: formData.css_template_id,
@@ -394,7 +396,7 @@ export const CreateEventPage: React.FC = () => {

              <Input
                type="date"
-                label={t('events.eventDate')}
+                label={requireEventDate ? t('events.eventDate') : `${t('events.eventDate')} (${t('common.optional')})`}
                value={formData.event_date}
                onChange={handleInputChange('event_date')}
                error={errors.event_date}
@@ -666,30 +668,42 @@ export const CreateEventPage: React.FC = () => {
              </div>
            )}

-            <div>
-              <label className="block text-sm font-medium text-neutral-700 mb-2">
-                {t('events.galleryExpiration')}
-              </label>
-              <div className="flex items-center gap-2">
-                <div className="w-32">
-                  <Input
-                    type="number"
-                    value={formData.expires_in_days}
-                    onChange={handleInputChange('expires_in_days')}
-                    error={errors.expires_in_days}
-                    min={1}
-                    max={365}
-                    leftIcon={<Clock className="w-5 h-5" />}
-                  />
+            {requireExpiration ? (
+              <div>
+                <label className="block text-sm font-medium text-neutral-700 mb-2">
+                  {t('events.galleryExpiration')}
+                </label>
+                <div className="flex items-center gap-2">
+                  <div className="w-32">
+                    <Input
+                      type="number"
+                      value={formData.expires_in_days}
+                      onChange={handleInputChange('expires_in_days')}
+                      error={errors.expires_in_days}
+                      min={1}
+                      max={365}
+                      leftIcon={<Clock className="w-5 h-5" />}
+                    />
+                  </div>
+                  <span className="text-sm text-neutral-600">{t('events.daysAfterEvent')}</span>
                </div>
-                <span className="text-sm text-neutral-600">{t('events.daysAfterEvent')}</span>
+                {formData.event_date && (
+                  <p className="mt-2 text-sm text-neutral-500">
+                    {t('events.expiresOn')}: {format(addDays(new Date(formData.event_date), formData.expires_in_days))}
+                  </p>
+                )}
              </div>
-              {formData.event_date && (
-                <p className="mt-2 text-sm text-neutral-500">
-                  {t('events.expiresOn')}: {format(addDays(new Date(formData.event_date), formData.expires_in_days))}
+            ) : (
+              <div className="rounded-md border border-blue-200 bg-blue-50 p-3">
+                <div className="flex items-center gap-2 text-blue-800">
+                  <Clock className="w-4 h-4" />
+                  <span className="text-sm font-medium">{t('events.noExpiration', 'No Expiration')}</span>
+                </div>
+                <p className="mt-1 text-xs text-blue-700">
+                  {t('events.noExpirationHelp', 'This gallery will remain active until manually archived.')}
                </p>
-              )}
-            </div>
+              </div>
+            )}

            {/* User Upload Settings */}
            <div className="pt-4 border-t border-neutral-200">
@@ -94,16 +94,16 @@ export const AcceptInvitePage: React.FC = () => {
          });
          setErrors(validationErrors);
        } else {
-          toast.error(errorMessage || t('acceptInvitation.validationError'));
+          toast.error(errorMessage || t('acceptInvitation.errors.genericError'));
        }
      } else if (error.response?.status === 422) {
-        toast.error(errorMessage || t('acceptInvitation.validationError'));
+        toast.error(errorMessage || t('acceptInvitation.errors.genericError'));
      } else if (error.response?.status === 404) {
-        toast.error(t('acceptInvitation.invalidOrExpired'));
+        toast.error(t('acceptInvitation.invalidTokenMessage'));
      } else if (error.response?.status === 409) {
-        toast.error(errorMessage || t('acceptInvitation.alreadyUsed'));
+        toast.error(errorMessage || t('acceptInvitation.alreadyUsedMessage'));
      } else {
-        toast.error(t('acceptInvitation.generalError'));
+        toast.error(t('acceptInvitation.errors.genericError'));
      }
    },
  });
@@ -113,7 +113,7 @@ export const AcceptInvitePage: React.FC = () => {
    {
      label: t('acceptInvitation.requirements.minLength'),
      met: false,
-      test: (pwd: string) => pwd.length >= 8,
+      test: (pwd: string) => pwd.length >= 12,
    },
    {
      label: t('acceptInvitation.requirements.uppercase'),
@@ -166,16 +166,16 @@ export const AcceptInvitePage: React.FC = () => {
  // Validate username
  const validateUsername = (username: string): string | null => {
    if (!username) {
-      return t('acceptInvitation.usernameRequired');
+      return t('acceptInvitation.errors.usernameRequired');
    }
    if (username.length < 3) {
-      return t('acceptInvitation.usernameTooShort');
+      return t('acceptInvitation.errors.usernameTooShort');
    }
    if (username.length > 50) {
-      return t('acceptInvitation.usernameTooLong');
+      return t('acceptInvitation.errors.usernameTooLong');
    }
    if (!/^[a-zA-Z0-9_-]+$/.test(username)) {
-      return t('acceptInvitation.usernameInvalid');
+      return t('acceptInvitation.errors.usernameInvalid');
    }
    return null;
  };
@@ -190,18 +190,18 @@ export const AcceptInvitePage: React.FC = () => {
    }

    if (!formData.password) {
-      newErrors.password = t('acceptInvitation.passwordRequired');
+      newErrors.password = t('acceptInvitation.errors.passwordRequired');
    } else {
      const allRequirementsMet = passwordRequirements.every(req => req.test(formData.password));
      if (!allRequirementsMet) {
-        newErrors.password = t('acceptInvitation.passwordRequirements');
+        newErrors.password = t('acceptInvitation.errors.passwordTooShort');
      }
    }

    if (!formData.confirmPassword) {
-      newErrors.confirmPassword = t('acceptInvitation.confirmPasswordRequired');
+      newErrors.confirmPassword = t('acceptInvitation.errors.confirmPasswordRequired');
    } else if (formData.password !== formData.confirmPassword) {
-      newErrors.confirmPassword = t('acceptInvitation.passwordsDoNotMatch');
+      newErrors.confirmPassword = t('acceptInvitation.errors.passwordsDoNotMatch');
    }

    setErrors(newErrors);
@@ -269,7 +269,7 @@ export const AcceptInvitePage: React.FC = () => {

  // Error state - invalid or expired token
  if (isError || !invitation?.valid) {
-    const errorMessage = (validationError as any)?.response?.data?.error || t('acceptInvitation.invalidOrExpired');
+    const errorMessage = (validationError as any)?.response?.data?.error || t('acceptInvitation.invalidTokenMessage');

    return (
      <div className="min-h-screen flex items-center justify-center p-4" style={{ backgroundColor: 'var(--color-background, #fafafa)' }}>
@@ -280,13 +280,13 @@ export const AcceptInvitePage: React.FC = () => {
                <XCircle className="w-8 h-8 text-red-600" />
              </div>
              <h1 className="text-2xl font-bold text-neutral-900 mb-2">
-                {t('acceptInvitation.invalidTitle')}
+                {t('acceptInvitation.invalidToken')}
              </h1>
              <p className="text-neutral-600 mb-6">
                {errorMessage}
              </p>
              <p className="text-sm text-neutral-500 mb-6">
-                {t('acceptInvitation.contactAdmin')}
+                {t('acceptInvitation.contactAdminMessage')}
              </p>
              <Button
                variant="primary"
@@ -312,7 +312,7 @@ export const AcceptInvitePage: React.FC = () => {
                <CheckCircle className="w-8 h-8 text-green-600" />
              </div>
              <h1 className="text-2xl font-bold text-neutral-900 mb-2">
-                {t('acceptInvitation.successTitle')}
+                {t('acceptInvitation.success')}
              </h1>
              <p className="text-neutral-600 mb-6">
                {t('acceptInvitation.successMessage')}
@@ -324,7 +324,7 @@ export const AcceptInvitePage: React.FC = () => {
                variant="primary"
                onClick={() => navigate('/admin/login')}
              >
-                {t('acceptInvitation.goToLoginNow')}
+                {t('acceptInvitation.goToLogin')}
              </Button>
            </div>
          </Card>
@@ -466,7 +466,7 @@ export const AcceptInvitePage: React.FC = () => {

              {/* Password Requirements */}
              <div className="mt-3 space-y-1.5">
-                <p className="text-xs font-medium text-neutral-600">{t('acceptInvitation.requirementsTitle')}</p>
+                <p className="text-xs font-medium text-neutral-600">{t('acceptInvitation.requirements.title')}</p>
                {passwordRequirements.map((req, index) => {
                  const isMet = req.test(formData.password);
                  return (
@@ -20,15 +20,15 @@ const normalizeEvent = (event: Event): Event => {
 interface CreateEventData {
  event_type: string;
  event_name: string;
-  event_date: string;
+  event_date?: string;
  customer_name?: string;
-  customer_email: string;
-  admin_email: string;
+  customer_email?: string;
+  admin_email?: string;
  require_password?: boolean;
  password?: string;
  welcome_message?: string;
  color_theme?: string;
-  expiration_days: number;
+  expiration_days?: number;
  allow_user_uploads?: boolean;
  upload_category_id?: number | null;
  feedback_enabled?: boolean;
@@ -4,7 +4,7 @@ export interface Event {
  slug: string;
  event_type: string;
  event_name: string;
-  event_date: string;
+  event_date: string | null;
  customer_name?: string;
  customer_email: string;
  admin_email: string;
@@ -12,7 +12,7 @@ export interface Event {
  color_theme?: string;
  share_link: string;
  created_at: string;
-  expires_at: string;
+  expires_at: string | null;
  is_active: boolean;
  is_archived: boolean;
  archive_path?: string;
@@ -46,8 +46,8 @@ export interface Event {
 export interface GalleryInfo {
  event_name: string;
  event_type: string;
-  event_date: string;
-  expires_at: string;
+  event_date: string | null;
+  expires_at: string | null;
  is_active: boolean;
  is_expired: boolean;
  requires_password?: boolean;
@@ -97,10 +97,10 @@ export interface GalleryData {
    id: number;
    event_name: string;
    event_type: string;
-    event_date: string;
+    event_date: string | null;
    welcome_message?: string;
    color_theme?: string;
-    expires_at: string;
+    expires_at: string | null;
    allow_user_uploads?: boolean;
    upload_category_id?: number | null;
    hero_photo_id?: number | null;
Author	SHA1	Message	Date
Paul Nothaft	d0880ccb03	Merge pull request #131 from the-luap/release-please--branches--beta Build and Push Docker Images / build-backend (push) Failing after 3m31s Details Build and Push Docker Images / build-frontend (push) Failing after 3m30s Details Build and Push Docker Images / summary (push) Successful in 2s Details chore(beta): release 3.2.5-beta.0	2026-01-18 15:38:03 +01:00
github-actions[bot]	237eeea5a6	chore(beta): release 3.2.5-beta.0	2026-01-18 14:35:30 +00:00
Paul Nothaft	41bf6ff884	Merge pull request #130 from the-luap/feat/optional-event-date-expiration-beta fix: resolve admin invitation flow issues and improve STORAGE_PATH documentation	2026-01-18 15:35:15 +01:00
Paul Nothaft	991aa98f98	fix: correct invitation activation validation and add missing translations - Fix password minimum length validation: frontend now correctly requires 12 characters to match backend validation (was incorrectly checking for 8) - Fix translation key references in AcceptInvitePage to use correct paths (e.g., acceptInvitation.errors.* instead of acceptInvitation.*) - Add missing translations for both EN and DE: - contactAdminMessage - passwordsMatch - alreadyHaveAccount - signIn Fixes #129	2026-01-18 15:00:38 +01:00
Paul Nothaft	86fa1046d5	fix: correct invitation email link URL path The invitation email was generating links to /admin/accept-invite/{token} but the frontend route is configured at /invite/{token}. This caused invited users to see a blank page when clicking the email link. Fixes #129	2026-01-18 12:55:56 +01:00
Paul Nothaft	3397807670	docs: emphasize importance of STORAGE_PATH in env example	2026-01-17 15:48:24 +01:00
Paul Nothaft	cdda709886	fix: add STORAGE_PATH to production docker-compose Ensures STORAGE_PATH environment variable is explicitly set in production deployments to prevent path resolution issues when serving thumbnails and other storage-related operations.	2026-01-17 15:48:15 +01:00
Paul Nothaft	023bb97e66	Merge pull request #128 from the-luap/release-please--branches--beta Build and Push Docker Images / build-frontend (push) Failing after 3m18s Details Build and Push Docker Images / build-backend (push) Failing after 3m19s Details Build and Push Docker Images / summary (push) Successful in 2s Details chore(beta): release 3.2.4-beta.0	2026-01-17 15:08:48 +01:00
github-actions[bot]	cf38305f28	chore(beta): release 3.2.4-beta.0	2026-01-17 14:08:09 +00:00
Paul Nothaft	0e3674b2b0	Merge pull request #127 from the-luap/feat/optional-event-date-expiration-beta fix: correct storage path resolution in multiple files (#96)	2026-01-17 15:07:56 +01:00
Paul Nothaft	3ccb8154eb	fix: correct storage path resolution in multiple files (#96 ) Fixed inconsistent storage path fallbacks that caused 500 errors when serving thumbnails. The paths were using '../../storage' (2 levels up) instead of '../../../storage' (3 levels up) when STORAGE_PATH env var is not set. Affected files: - backend/src/routes/gallery.js - backend/src/services/photoService.js - backend/src/services/eventService.js	2026-01-17 14:01:29 +01:00
Paul Nothaft	b5ac18121d	Merge pull request #126 from the-luap/release-please--branches--beta Build and Push Docker Images / build-backend (push) Failing after 3m36s Details Build and Push Docker Images / build-frontend (push) Failing after 3m36s Details Build and Push Docker Images / summary (push) Successful in 2s Details chore(beta): release 3.2.3-beta.0	2026-01-16 15:23:29 +01:00
github-actions[bot]	b613f8fbc7	chore(beta): release 3.2.3-beta.0	2026-01-16 14:19:26 +00:00
Paul Nothaft	cacaffa5c3	Merge pull request #125 from the-luap/feat/optional-event-date-expiration-beta fix: mobile upload button not visible in gallery (#113)	2026-01-16 15:19:09 +01:00
Paul Nothaft	691e3aba09	fix: add allow_user_uploads to gallery API responses The gallery /photos and /info endpoints were not returning the allow_user_uploads field, causing the upload button to never show in the frontend since the value was always undefined/false.	2026-01-16 15:15:09 +01:00
Paul Nothaft	70a0caa11f	Merge pull request #124 from the-luap/release-please--branches--beta Build and Push Docker Images / build-frontend (push) Failing after 3m26s Details Build and Push Docker Images / build-backend (push) Failing after 3m27s Details Build and Push Docker Images / summary (push) Successful in 2s Details chore(beta): release 3.2.2-beta.0	2026-01-16 14:53:44 +01:00
github-actions[bot]	e808e529cd	chore(beta): release 3.2.2-beta.0	2026-01-16 13:53:31 +00:00
Paul Nothaft	05a5307e22	Merge pull request #123 from the-luap/feat/optional-event-date-expiration-beta fix: mobile upload button visibility in gallery (#113)	2026-01-16 14:53:17 +01:00
Paul Nothaft	2a2c23d116	fix: mobile upload button visibility in gallery - Remove hidden sm:block wrapper hiding upload button on mobile for Grid layout - Add upload button to GallerySidebar using existing allowUploads/onUploadClick props - Ensures upload button is visible in both header and sidebar on all devices Closes #113	2026-01-16 14:49:37 +01:00
Paul Nothaft	a092d98523	Merge pull request #122 from the-luap/release-please--branches--beta Build and Push Docker Images / build-frontend (push) Failing after 3m34s Details Build and Push Docker Images / build-backend (push) Failing after 3m35s Details Build and Push Docker Images / summary (push) Successful in 3s Details chore(beta): release 3.2.1-beta.0	2026-01-16 14:38:39 +01:00
github-actions[bot]	b5f06af126	chore(beta): release 3.2.1-beta.0	2026-01-16 13:35:53 +00:00
Paul Nothaft	6cb43428d1	Merge pull request #121 from the-luap/feat/optional-event-date-expiration-beta fix: mobile upload button visibility in gallery (#113)	2026-01-16 14:35:36 +01:00
Paul Nothaft	df7dbffbff	fix: mobile upload button visibility in gallery - Remove hidden sm:block wrapper hiding upload button on mobile for Grid layout - Add upload button to GallerySidebar using existing allowUploads/onUploadClick props - Ensures upload button is visible in both header and sidebar on all devices Closes #113	2026-01-16 14:29:49 +01:00
Paul Nothaft	94421a6b12	Merge pull request #120 from the-luap/release-please--branches--beta Build and Push Docker Images / build-frontend (push) Failing after 3m51s Details Build and Push Docker Images / build-backend (push) Failing after 3m53s Details Build and Push Docker Images / summary (push) Successful in 2s Details chore(beta): release 3.2.0-beta.0	2026-01-16 09:43:51 +01:00
github-actions[bot]	7805e89bfe	chore(beta): release 3.2.0-beta.0	2026-01-16 08:43:36 +00:00
Paul Nothaft	3079eaa2e5	Merge pull request #119 from the-luap/feat/optional-event-date-expiration-beta feat: add optional event date and expiration settings	2026-01-16 09:43:23 +01:00
Paul Nothaft	2151147f2d	feat: add optional event date and expiration settings Add global settings to make event_date and expiration optional when creating galleries. This supports non-event use cases like portraits, corporate shoots, etc. New features: - Settings toggles in Settings → Event Creation tab - "Require event date" checkbox with warning about random URL identifiers - "Require expiration date" checkbox with warning about manual archiving - Galleries without date use random hex suffix in slug (e.g. portrait-smith-a1b2c3) - Galleries without expiration never expire (stay active until archived) Backend changes: - New migration for settings and nullable columns - Conditional validation based on settings - Updated slug generation with random suffix fallback - Updated expiration checker to skip null expires_at - Updated gallery access control for null expiration Frontend changes: - New checkboxes in EventsTab with warnings - Conditional event date field (shows optional label) - No Expiration message when expiration disabled - Updated types for nullable event_date and expires_at Closes #118	2026-01-16 09:39:32 +01:00
Paul Nothaft	3e69579f5a	docs: add API_URL environment variable to .env.example files Document the API_URL environment variable that is used for constructing URLs for assets (logos, images) in email notifications. Without this setting, the system defaults to http://localhost:3001 which causes broken images in production emails. Added to both root and backend .env.example files with clear documentation about its purpose and importance.	2026-01-16 09:39:32 +01:00
Paul Nothaft	808ed1d2f1	fix: checkbox and toggle settings not persisting after page refresh PostgreSQL's json column type returns parsed values directly (boolean false instead of string "false"). The backend code used a truthy check which failed for boolean false values, causing null to be returned instead of the actual false value. Changed condition from `if (setting.setting_value)` to explicit null check `if (setting.setting_value !== null && setting.setting_value !== undefined)` and added handling for already-parsed json column values. Fixes #117	2026-01-16 09:39:32 +01:00
Paul Nothaft	b40e085d28	Merge pull request #116 from the-luap/release-please--branches--beta Build and Push Docker Images / build-backend (push) Failing after 3m18s Details Build and Push Docker Images / build-frontend (push) Failing after 3m15s Details Build and Push Docker Images / summary (push) Successful in 3s Details chore(beta): release 3.1.0-beta.0	2026-01-15 15:04:17 -05:00
github-actions[bot]	d603567e21	chore(beta): release 3.1.0-beta.0	2026-01-15 20:03:57 +00:00
Paul Nothaft	c6fdd38e84	Merge pull request #115 from the-luap/fix/codeql-v4-upgrade feat: pre-generated watermarks and mobile upload button improvements	2026-01-15 15:03:25 -05:00
Paul Nothaft	ae181cf92f	fix: show upload button in mobile topbar instead of sidebar The upload button was hidden in the sidebar on mobile devices, requiring users to open the menu to find it. Now it appears directly in the topbar for easy access on all screen sizes. - Remove !isMobile condition from header upload button - Add responsive text (short on mobile, full on desktop) - Remove duplicate upload button from sidebar Fixes #113	2026-01-15 21:00:17 +01:00
Paul Nothaft	1be974afbb	feat: pre-generate watermarks for instant lightbox loading Previously watermarks were applied on-the-fly when viewing photos in the lightbox, causing 1+ minute load times for high-resolution images. This change pre-generates watermarked versions during upload and when watermark settings change, enabling instant image loading (~50-100ms). - Add database migration for watermark_path tracking (061) - Add watermarkGeneratorService for batch operations - Extend watermarkService with save-to-disk capability - Modify gallery endpoint to serve pre-generated files - Add background regeneration when branding settings change - Add npm script for migrating existing photos Closes #112	2026-01-15 21:00:10 +01:00
Paul Nothaft	1c8f686c19	Merge pull request #102 from the-luap/release-please--branches--beta Build and Push Docker Images / build-backend (push) Failing after 3m23s Details Build and Push Docker Images / build-frontend (push) Failing after 3m8s Details Build and Push Docker Images / summary (push) Successful in 2s Details chore(beta): release 3.0.1-beta.0	2026-01-15 06:36:13 -05:00
github-actions[bot]	a0f38053d3	chore(beta): release 3.0.1-beta.0	2026-01-15 11:35:58 +00:00
Paul Nothaft	cb012186d9	Merge pull request #101 from the-luap/fix/codeql-v4-upgrade fix: CI workflow fixes for protected branches	2026-01-15 06:35:46 -05:00