Update 9206bf87bb8e_add_portainer_stack_fields_to_instances.py

This reverts commit 522ea2d976.

.gitignore

@@ -27,3 +27,6 @@ logs/
 
 # Testing
 coverage/
+
+# Python cache
+__pycache__/ 

Dockerfile

@@ -1,33 +1,38 @@
 FROM python:3.11-slim
 
-WORKDIR /app
-
 # Install system dependencies
 RUN apt-get update && apt-get install -y \
-    gcc \
+    build-essential \
+    libpq-dev \
     postgresql-client \
+    curl \
     netcat-traditional \
+    dos2unix \
     && rm -rf /var/lib/apt/lists/*
 
+# Create a non-root user
+RUN useradd -m -u 1000 celery
+
+# Set working directory
+WORKDIR /app
+
 # Copy requirements first to leverage Docker cache
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy the rest of the application
+# Copy application code
 COPY . .
 
-# Create migrations directory if it doesn't exist
-RUN mkdir -p migrations/versions
+# Convert line endings and set permissions
+RUN dos2unix /app/entrypoint.sh && \
+    chmod +x /app/entrypoint.sh && \
+    mkdir -p /app/uploads/rooms /app/uploads/profile_pics /app/static/uploads && \
+    chown -R celery:celery /app && \
+    chmod -R 755 /app/uploads
 
-# Make entrypoint script executable
-RUN chmod +x entrypoint.sh
+# Switch to non-root user
+USER celery
 
-# Set environment variables
-ENV FLASK_APP=app.py
-ENV FLASK_ENV=production
-
-# Expose the port the app runs on
-EXPOSE 5000
-
-# Use the entrypoint script
-ENTRYPOINT ["./entrypoint.sh"] 
+# Set entrypoint
+ENTRYPOINT ["/app/entrypoint.sh"]
+CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"] 

NGINX_swagger.json

@@ -0,0 +1,274 @@
+{
+	"openapi": "3.1.0",
+	"info": {
+		"title": "Nginx Proxy Manager API",
+		"version": "2.x.x"
+	},
+	"servers": [
+		{
+			"url": "http://127.0.0.1:81/api"
+		}
+	],
+	"components": {
+		"securitySchemes": {
+			"bearerAuth": {
+				"type": "http",
+				"scheme": "bearer",
+				"bearerFormat": "JWT"
+			}
+		}
+	},
+	"paths": {
+		"/": {
+			"get": {
+				"$ref": "./paths/get.json"
+			}
+		},
+		"/audit-log": {
+			"get": {
+				"$ref": "./paths/audit-log/get.json"
+			}
+		},
+		"/nginx/access-lists": {
+			"get": {
+				"$ref": "./paths/nginx/access-lists/get.json"
+			},
+			"post": {
+				"$ref": "./paths/nginx/access-lists/post.json"
+			}
+		},
+		"/nginx/access-lists/{listID}": {
+			"get": {
+				"$ref": "./paths/nginx/access-lists/listID/get.json"
+			},
+			"put": {
+				"$ref": "./paths/nginx/access-lists/listID/put.json"
+			},
+			"delete": {
+				"$ref": "./paths/nginx/access-lists/listID/delete.json"
+			}
+		},
+		"/nginx/certificates": {
+			"get": {
+				"$ref": "./paths/nginx/certificates/get.json"
+			},
+			"post": {
+				"$ref": "./paths/nginx/certificates/post.json"
+			}
+		},
+		"/nginx/certificates/validate": {
+			"post": {
+				"$ref": "./paths/nginx/certificates/validate/post.json"
+			}
+		},
+		"/nginx/certificates/test-http": {
+			"get": {
+				"$ref": "./paths/nginx/certificates/test-http/get.json"
+			}
+		},
+		"/nginx/certificates/{certID}": {
+			"get": {
+				"$ref": "./paths/nginx/certificates/certID/get.json"
+			},
+			"delete": {
+				"$ref": "./paths/nginx/certificates/certID/delete.json"
+			}
+		},
+		"/nginx/certificates/{certID}/download": {
+			"get": {
+				"$ref": "./paths/nginx/certificates/certID/download/get.json"
+			}
+		},
+		"/nginx/certificates/{certID}/renew": {
+			"post": {
+				"$ref": "./paths/nginx/certificates/certID/renew/post.json"
+			}
+		},
+		"/nginx/certificates/{certID}/upload": {
+			"post": {
+				"$ref": "./paths/nginx/certificates/certID/upload/post.json"
+			}
+		},
+		"/nginx/proxy-hosts": {
+			"get": {
+				"$ref": "./paths/nginx/proxy-hosts/get.json"
+			},
+			"post": {
+				"$ref": "./paths/nginx/proxy-hosts/post.json"
+			}
+		},
+		"/nginx/proxy-hosts/{hostID}": {
+			"get": {
+				"$ref": "./paths/nginx/proxy-hosts/hostID/get.json"
+			},
+			"put": {
+				"$ref": "./paths/nginx/proxy-hosts/hostID/put.json"
+			},
+			"delete": {
+				"$ref": "./paths/nginx/proxy-hosts/hostID/delete.json"
+			}
+		},
+		"/nginx/proxy-hosts/{hostID}/enable": {
+			"post": {
+				"$ref": "./paths/nginx/proxy-hosts/hostID/enable/post.json"
+			}
+		},
+		"/nginx/proxy-hosts/{hostID}/disable": {
+			"post": {
+				"$ref": "./paths/nginx/proxy-hosts/hostID/disable/post.json"
+			}
+		},
+		"/nginx/redirection-hosts": {
+			"get": {
+				"$ref": "./paths/nginx/redirection-hosts/get.json"
+			},
+			"post": {
+				"$ref": "./paths/nginx/redirection-hosts/post.json"
+			}
+		},
+		"/nginx/redirection-hosts/{hostID}": {
+			"get": {
+				"$ref": "./paths/nginx/redirection-hosts/hostID/get.json"
+			},
+			"put": {
+				"$ref": "./paths/nginx/redirection-hosts/hostID/put.json"
+			},
+			"delete": {
+				"$ref": "./paths/nginx/redirection-hosts/hostID/delete.json"
+			}
+		},
+		"/nginx/redirection-hosts/{hostID}/enable": {
+			"post": {
+				"$ref": "./paths/nginx/redirection-hosts/hostID/enable/post.json"
+			}
+		},
+		"/nginx/redirection-hosts/{hostID}/disable": {
+			"post": {
+				"$ref": "./paths/nginx/redirection-hosts/hostID/disable/post.json"
+			}
+		},
+		"/nginx/dead-hosts": {
+			"get": {
+				"$ref": "./paths/nginx/dead-hosts/get.json"
+			},
+			"post": {
+				"$ref": "./paths/nginx/dead-hosts/post.json"
+			}
+		},
+		"/nginx/dead-hosts/{hostID}": {
+			"get": {
+				"$ref": "./paths/nginx/dead-hosts/hostID/get.json"
+			},
+			"put": {
+				"$ref": "./paths/nginx/dead-hosts/hostID/put.json"
+			},
+			"delete": {
+				"$ref": "./paths/nginx/dead-hosts/hostID/delete.json"
+			}
+		},
+		"/nginx/dead-hosts/{hostID}/enable": {
+			"post": {
+				"$ref": "./paths/nginx/dead-hosts/hostID/enable/post.json"
+			}
+		},
+		"/nginx/dead-hosts/{hostID}/disable": {
+			"post": {
+				"$ref": "./paths/nginx/dead-hosts/hostID/disable/post.json"
+			}
+		},
+		"/nginx/streams": {
+			"get": {
+				"$ref": "./paths/nginx/streams/get.json"
+			},
+			"post": {
+				"$ref": "./paths/nginx/streams/post.json"
+			}
+		},
+		"/nginx/streams/{streamID}": {
+			"get": {
+				"$ref": "./paths/nginx/streams/streamID/get.json"
+			},
+			"put": {
+				"$ref": "./paths/nginx/streams/streamID/put.json"
+			},
+			"delete": {
+				"$ref": "./paths/nginx/streams/streamID/delete.json"
+			}
+		},
+		"/nginx/streams/{streamID}/enable": {
+			"post": {
+				"$ref": "./paths/nginx/streams/streamID/enable/post.json"
+			}
+		},
+		"/nginx/streams/{streamID}/disable": {
+			"post": {
+				"$ref": "./paths/nginx/streams/streamID/disable/post.json"
+			}
+		},
+		"/reports/hosts": {
+			"get": {
+				"$ref": "./paths/reports/hosts/get.json"
+			}
+		},
+		"/schema": {
+			"get": {
+				"$ref": "./paths/schema/get.json"
+			}
+		},
+		"/settings": {
+			"get": {
+				"$ref": "./paths/settings/get.json"
+			}
+		},
+		"/settings/{settingID}": {
+			"get": {
+				"$ref": "./paths/settings/settingID/get.json"
+			},
+			"put": {
+				"$ref": "./paths/settings/settingID/put.json"
+			}
+		},
+		"/tokens": {
+			"get": {
+				"$ref": "./paths/tokens/get.json"
+			},
+			"post": {
+				"$ref": "./paths/tokens/post.json"
+			}
+		},
+		"/users": {
+			"get": {
+				"$ref": "./paths/users/get.json"
+			},
+			"post": {
+				"$ref": "./paths/users/post.json"
+			}
+		},
+		"/users/{userID}": {
+			"get": {
+				"$ref": "./paths/users/userID/get.json"
+			},
+			"put": {
+				"$ref": "./paths/users/userID/put.json"
+			},
+			"delete": {
+				"$ref": "./paths/users/userID/delete.json"
+			}
+		},
+		"/users/{userID}/auth": {
+			"put": {
+				"$ref": "./paths/users/userID/auth/put.json"
+			}
+		},
+		"/users/{userID}/permissions": {
+			"put": {
+				"$ref": "./paths/users/userID/permissions/put.json"
+			}
+		},
+		"/users/{userID}/login": {
+			"post": {
+				"$ref": "./paths/users/userID/login/post.json"
+			}
+		}
+	}
+}

PRICING_CONFIGURATION.md

@@ -0,0 +1,246 @@
+# Pricing Configuration Feature
+
+This document describes the new configurable pricing feature that allows MASTER instances to manage pricing plans through the admin interface.
+
+## Overview
+
+The pricing configuration feature allows administrators on MASTER instances to:
+- Create, edit, and delete pricing plans
+- Configure plan features, prices, and settings
+- Set resource quotas for rooms, conversations, storage, and users
+- Mark plans as "Most Popular" or "Custom"
+- Control plan visibility and ordering
+- Update pricing without code changes
+
+## Features
+
+### Pricing Plan Management
+- **Plan Name**: Display name for the pricing plan
+- **Description**: Optional description shown below the plan name
+- **Pricing**: Monthly and annual prices (annual prices are typically 20% lower)
+- **Features**: Dynamic list of features with checkmarks
+- **Button Configuration**: Customizable button text and URL
+- **Plan Types**: Regular plans with prices or custom plans
+- **Popular Plans**: Mark one plan as "Most Popular" with special styling
+- **Active/Inactive**: Toggle plan visibility
+- **Ordering**: Control the display order of plans
+
+### Resource Quotas
+- **Room Quota**: Maximum number of rooms allowed (0 = unlimited)
+- **Conversation Quota**: Maximum number of conversations allowed (0 = unlimited)
+- **Storage Quota**: Maximum storage in gigabytes (0 = unlimited)
+- **Manager Quota**: Maximum number of manager users allowed (0 = unlimited)
+- **Admin Quota**: Maximum number of admin users allowed (0 = unlimited)
+
+### Admin Interface
+- **Pricing Tab**: New tab in admin settings (MASTER instances only)
+- **Add/Edit Modals**: User-friendly forms for plan management
+- **Real-time Updates**: Changes are reflected immediately
+- **Feature Management**: Add/remove features dynamically
+- **Quota Configuration**: Set resource limits for each plan
+- **Status Toggles**: Quick switches for plan properties
+
+## Setup Instructions
+
+### 1. Database Migration
+Run the migrations to create the pricing_plans table and add quota fields:
+
+```bash
+# Apply the migrations
+alembic upgrade head
+```
+
+### 2. Initialize Default Plans (Optional)
+Run the initialization script to create default pricing plans:
+
+```bash
+# Set MASTER environment variable
+export MASTER=true
+
+# Run the initialization script
+python init_pricing_plans.py
+```
+
+This will create four default plans with quotas:
+- **Starter**: 5 rooms, 10 conversations, 10GB storage, 10 managers, 1 admin
+- **Professional**: 25 rooms, 50 conversations, 100GB storage, 50 managers, 3 admins
+- **Enterprise**: 100 rooms, 200 conversations, 500GB storage, 200 managers, 10 admins
+- **Custom**: Unlimited everything
+
+### 3. Access Admin Interface
+1. Log in as an admin user on a MASTER instance
+2. Go to Settings
+3. Click on the "Pricing" tab
+4. Configure your pricing plans
+
+## Usage
+
+### Creating a New Plan
+1. Click "Add New Plan" in the pricing tab
+2. Fill in the plan details:
+   - **Name**: Plan display name
+   - **Description**: Optional description
+   - **Monthly Price**: Price per month
+   - **Annual Price**: Price per month when billed annually
+   - **Quotas**: Set resource limits (0 = unlimited)
+   - **Features**: Add features using the "Add Feature" button
+   - **Button Text**: Text for the call-to-action button
+   - **Button URL**: URL the button should link to
+   - **Options**: Check "Most Popular", "Custom Plan", or "Active" as needed
+3. Click "Create Plan"
+
+### Editing a Plan
+1. Click the "Edit" button on any plan card
+2. Modify the plan details in the modal
+3. Click "Update Plan"
+
+### Managing Plan Status
+- **Active/Inactive**: Use the toggle switch in the plan header
+- **Most Popular**: Check the "Most Popular" checkbox (only one plan can be popular)
+- **Custom Plan**: Check "Custom Plan" for plans without fixed pricing
+
+### Deleting a Plan
+1. Click the "Delete" button on a plan card
+2. Confirm the deletion in the modal
+
+## Technical Details
+
+### Database Schema
+The `pricing_plans` table includes:
+- `id`: Primary key
+- `name`: Plan name (required)
+- `description`: Optional description
+- `monthly_price`: Monthly price (float)
+- `annual_price`: Annual price (float)
+- `features`: JSON array of feature strings
+- `button_text`: Button display text
+- `button_url`: Button link URL
+- `is_popular`: Boolean for "Most Popular" styling
+- `is_custom`: Boolean for custom plans
+- `is_active`: Boolean for plan visibility
+- `order_index`: Integer for display ordering
+- `room_quota`: Maximum rooms (0 = unlimited)
+- `conversation_quota`: Maximum conversations (0 = unlimited)
+- `storage_quota_gb`: Maximum storage in GB (0 = unlimited)
+- `manager_quota`: Maximum managers (0 = unlimited)
+- `admin_quota`: Maximum admins (0 = unlimited)
+- `created_by`: Foreign key to user who created the plan
+- `created_at`/`updated_at`: Timestamps
+
+### API Endpoints
+- `POST /api/admin/pricing-plans` - Create new plan
+- `GET /api/admin/pricing-plans/<id>` - Get plan details
+- `PUT /api/admin/pricing-plans/<id>` - Update plan
+- `DELETE /api/admin/pricing-plans/<id>` - Delete plan
+- `PATCH /api/admin/pricing-plans/<id>/status` - Update plan status
+
+### Template Integration
+The pricing page automatically uses configured plans:
+- Falls back to hardcoded plans if no plans are configured
+- Supports dynamic feature lists
+- Handles custom plans without pricing
+- Shows/hides billing toggle based on plan types
+- Displays quota information in plan cards
+
+### Quota Enforcement
+The PricingPlan model includes utility methods for quota checking:
+- `check_quota(quota_type, current_count)`: Returns True if quota allows the operation
+- `get_quota_remaining(quota_type, current_count)`: Returns remaining quota
+- `format_quota_display(quota_type)`: Formats quota for display
+- `get_storage_quota_bytes()`: Converts GB to bytes for storage calculations
+
+Example usage in your application:
+```python
+# Check if user can create a new room
+plan = PricingPlan.query.get(user_plan_id)
+current_rooms = Room.query.filter_by(created_by=user.id).count()
+if plan.check_quota('room_quota', current_rooms):
+    # Allow room creation
+    pass
+else:
+    # Show upgrade message
+    pass
+```
+
+## Security
+
+- Only admin users can access pricing configuration
+- Only MASTER instances can configure pricing
+- All API endpoints require authentication and admin privileges
+- CSRF protection is enabled for all forms
+
+## Customization
+
+### Styling
+The pricing plans use the existing CSS variables:
+- `--primary-color`: Main brand color
+- `--secondary-color`: Secondary brand color
+- `--shadow-color`: Card shadows
+
+### Button URLs
+Configure button URLs to point to:
+- Contact forms
+- Payment processors
+- Sales pages
+- Custom landing pages
+
+### Features
+Features can include:
+- Storage limits
+- User limits
+- Feature availability
+- Support levels
+- Integration options
+
+### Quota Integration
+To integrate quotas into your application:
+
+1. **User Plan Assignment**: Associate users with pricing plans
+2. **Quota Checking**: Use the `check_quota()` method before operations
+3. **Upgrade Prompts**: Show upgrade messages when quotas are exceeded
+4. **Usage Tracking**: Track current usage for quota calculations
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Pricing tab not visible**
+   - Ensure you're on a MASTER instance (`MASTER=true`)
+   - Ensure you're logged in as an admin user
+
+2. **Plans not showing on pricing page**
+   - Check that plans are marked as "Active"
+   - Verify the database migration was applied
+   - Check for JavaScript errors in browser console
+
+3. **Features not saving**
+   - Ensure at least one feature is provided
+   - Check that feature text is not empty
+
+4. **Quota fields not working**
+   - Verify the quota migration was applied
+   - Check that quota values are integers
+   - Ensure quota fields are included in form submissions
+
+5. **API errors**
+   - Verify CSRF token is included in requests
+   - Check that all required fields are provided
+   - Ensure proper JSON formatting for features
+
+### Debugging
+- Check browser console for JavaScript errors
+- Review server logs for API errors
+- Verify database connectivity
+- Test with default plans first
+
+## Future Enhancements
+
+Potential future improvements:
+- Plan categories/tiers
+- Regional pricing
+- Currency support
+- Promotional pricing
+- Plan comparison features
+- Analytics and usage tracking
+- Automatic quota enforcement middleware
+- Usage dashboard for quota monitoring 

README.md

@@ -10,8 +10,9 @@ DocuPulse is a powerful document management system designed to streamline docume
 
 ### Prerequisites
 
-- Node.js (version 18 or higher)
-- npm or yarn
+- Python 3.11 or higher
+- PostgreSQL 13 or higher
+- Docker and Docker Compose (for containerized deployment)
 
 ### Installation
 
@@ -23,18 +24,50 @@ cd docupulse
 
 2. Install dependencies:
 ```bash
-npm install
-# or
-yarn install
+pip install -r requirements.txt
 ```
 
-3. Start the development server:
+3. Set up environment variables:
 ```bash
-npm run dev
-# or
-yarn dev
+# Copy example environment file
+cp .env.example .env
+
+# Set version information for local development
+python set_version.py
 ```
 
+4. Initialize the database:
+```bash
+flask db upgrade
+flask create-admin
+```
+
+5. Start the development server:
+```bash
+python app.py
+```
+
+## Version Tracking
+
+DocuPulse uses a database-only approach for version tracking:
+
+- **Environment Variables**: Version information is passed via environment variables (`APP_VERSION`, `GIT_COMMIT`, `GIT_BRANCH`, `DEPLOYED_AT`)
+- **Database Storage**: Instance version information is stored in the `instances` table
+- **API Endpoint**: Version information is available via `/api/version`
+
+### Setting Version Information
+
+For local development:
+```bash
+python set_version.py
+```
+
+For production deployments, set the following environment variables:
+- `APP_VERSION`: Application version/tag
+- `GIT_COMMIT`: Git commit hash
+- `GIT_BRANCH`: Git branch name
+- `DEPLOYED_AT`: Deployment timestamp
+
 ## Features
 
 - Document upload and management
@@ -42,6 +75,8 @@ yarn dev
 - Secure document storage
 - User authentication and authorization
 - Document version control
+- Multi-tenant instance management
+- RESTful API
 
 ## Contributing
 

app.py

@@ -1,20 +1,29 @@
-from flask import Flask, send_from_directory
+import random
+from flask import Flask, send_from_directory, jsonify
 from flask_migrate import Migrate
 from dotenv import load_dotenv
 import os
-from models import User
+from models import User, SiteSettings
 from flask_wtf.csrf import generate_csrf
 from routes.room_files import room_files_bp
-from routes.user import user_bp
 from routes.room_members import room_members_bp
 from routes.trash import trash_bp
+from routes.admin_api import admin_api
+from routes.launch_api import launch_api
 from tasks import cleanup_trash
 import click
 from utils import timeago
 from extensions import db, login_manager, csrf
+from utils.email_templates import create_default_templates
+from datetime import datetime
+from sqlalchemy import text
+from utils.asset_utils import get_asset_version
 
 # Load environment variables
 load_dotenv()
+print("Environment variables after loading .env:")
+print(f"MASTER: {os.getenv('MASTER')}")
+print(f"ISMASTER: {os.getenv('ISMASTER')}")
 
 def create_app():
     app = Flask(__name__)
@@ -24,7 +33,13 @@ def create_app():
     app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
     app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', 'your-secure-secret-key-here')
     app.config['UPLOAD_FOLDER'] = os.path.join(app.root_path, 'static', 'uploads')
-    app.config['CSS_VERSION'] = os.getenv('CSS_VERSION', '1.0.0')  # Add CSS version for cache busting
+    app.config['CSS_VERSION'] = os.getenv('CSS_VERSION', '1.0.3')  # Add CSS version for cache busting
+    app.config['SERVER_NAME'] = os.getenv('SERVER_NAME', '127.0.0.1:5000')
+    app.config['PREFERRED_URL_SCHEME'] = os.getenv('PREFERRED_URL_SCHEME', 'http')
+    
+    # Configure request timeouts for long-running operations
+    app.config['REQUEST_TIMEOUT'] = int(os.getenv('REQUEST_TIMEOUT', '300'))  # 5 minutes default
+    app.config['STACK_DEPLOYMENT_TIMEOUT'] = int(os.getenv('STACK_DEPLOYMENT_TIMEOUT', '300'))  # 5 minutes for stack deployment
 
     # Initialize extensions
     db.init_app(app)
@@ -39,20 +54,61 @@ def create_app():
 
     @app.context_processor
     def inject_config():
-        return dict(config=app.config)
+        site_settings = SiteSettings.query.first()
+        if not site_settings:
+            site_settings = SiteSettings()
+            db.session.add(site_settings)
+            db.session.commit()
+        return dict(config=app.config, site_settings=site_settings)
+
+    @app.context_processor
+    def inject_unread_notifications():
+        from flask_login import current_user
+        from utils import get_unread_count
+        if current_user.is_authenticated:
+            unread_count = get_unread_count(current_user.id)
+            return {'unread_notifications': unread_count}
+        return {'unread_notifications': 0}
+
+    @app.template_filter('asset_version')
+    def asset_version_filter(filename):
+        """Template filter to get version hash for static assets"""
+        return get_asset_version(filename) or ''
 
     # User loader for Flask-Login
     @login_manager.user_loader
     def load_user(user_id):
         return User.query.get(int(user_id))
 
+    # Health check endpoint
+    @app.route('/health')
+    def health_check():
+        try:
+            # Check database connection with a timeout
+            db.session.execute(text('SELECT 1'))
+            db.session.commit()
+            
+            return jsonify({
+                'status': 'healthy',
+                'database': 'connected',
+                'timestamp': datetime.utcnow().isoformat()
+            }), 200
+        except Exception as e:
+            app.logger.error(f"Health check failed: {str(e)}")
+            return jsonify({
+                'status': 'unhealthy',
+                'error': str(e),
+                'timestamp': datetime.utcnow().isoformat()
+            }), 500
+
     # Initialize routes
     from routes import init_app
     init_app(app)
     app.register_blueprint(room_files_bp, url_prefix='/api/rooms')
     app.register_blueprint(room_members_bp, url_prefix='/api/rooms')
-    app.register_blueprint(trash_bp, url_prefix='/api/rooms')
-    app.register_blueprint(user_bp)
+    app.register_blueprint(trash_bp, url_prefix='/api/trash')
+    app.register_blueprint(admin_api, url_prefix='/api/admin')
+    app.register_blueprint(launch_api, url_prefix='/api/admin')
 
     @app.cli.command("cleanup-trash")
     def cleanup_trash_command():
@@ -60,6 +116,13 @@ def create_app():
         cleanup_trash()
         click.echo("Trash cleanup completed.")
 
+    @app.cli.command("cleanup-tokens")
+    def cleanup_tokens_command():
+        """Clean up expired password reset and setup tokens."""
+        from tasks import cleanup_expired_tokens
+        cleanup_expired_tokens()
+        click.echo("Token cleanup completed.")
+
     @app.cli.command("create-admin")
     def create_admin():
         """Create the default administrator user."""
@@ -71,26 +134,91 @@ def create_app():
         admin = User(
             username='administrator',
             email='administrator@docupulse.com',
-            last_name='None',
-            company='docupulse',
+            last_name='Administrator',
+            company='DocuPulse',
+            position='System Administrator',
             is_admin=True,
-            is_active=True
+            is_active=True,
+            preferred_view='grid'
         )
-        admin.set_password('q]H488h[8?.A')
+        admin.set_password('changeme')
         db.session.add(admin)
         db.session.commit()
         click.echo("Default administrator user created successfully.")
+        click.echo("Admin credentials:")
+        click.echo("Email: administrator@docupulse.com")
+        click.echo("Password: changeme")
 
     # Register custom filters
     app.jinja_env.filters['timeago'] = timeago
 
+    # Create default email templates if they don't exist
+    with app.app_context():
+        try:
+            # Ensure database tables exist
+            db.create_all()
+            
+            # Create admin user first
+            admin = User.query.filter_by(email='administrator@docupulse.com').first()
+            if not admin:
+                admin = User(
+                    username='administrator',
+                    email='administrator@docupulse.com',
+                    last_name='Administrator',
+                    company='DocuPulse',
+                    position='System Administrator',
+                    is_admin=True,
+                    is_active=True,
+                    preferred_view='grid'
+                )
+                admin.set_password('changeme')
+                db.session.add(admin)
+                db.session.commit()
+                print("Default administrator user created successfully.")
+                print("Admin credentials:")
+                print("Email: administrator@docupulse.com")
+                print("Password: changeme")
+            
+            # Then create default templates
+            create_default_templates()
+        except Exception as e:
+            print(f"Warning: Could not create default templates: {e}")
+
     return app
 
 app = create_app()
 
+@app.errorhandler(404)
+def page_not_found(e):
+    from flask import render_template
+    return render_template('common/404.html'), 404
+
+@app.errorhandler(403)
+def forbidden(e):
+    from flask import render_template
+    return render_template('common/403.html'), 403
+
+@app.errorhandler(401)
+def unauthorized(e):
+    from flask import render_template
+    return render_template('common/401.html'), 401
+
+@app.errorhandler(400)
+def bad_request(e):
+    from flask import render_template
+    return render_template('common/400.html'), 400
+
+@app.errorhandler(500)
+def internal_server_error(e):
+    from flask import render_template
+    import traceback
+    error_details = f"{str(e)}\n\n{traceback.format_exc()}"
+    app.logger.error(f"500 error: {error_details}")
+    return render_template('common/500.html', error=error_details), 500
+
 @app.route('/uploads/profile_pics/<filename>')
 def profile_pic(filename):
-    return send_from_directory(os.path.join(os.getcwd(), 'uploads', 'profile_pics'), filename)
+    return send_from_directory('/app/uploads/profile_pics', filename)
 
 if __name__ == '__main__':
     app.run(debug=True) 

docker-compose.yml

@@ -1,40 +1,68 @@
 version: '3.8'
 
+networks:
+  docupulse_network:
+    driver: bridge
+
 services:
   web:
-    build: .
+    build:
+      # context: .
+      # dockerfile: Dockerfile
+      context: https://git.kobeamerijckx.com/Kobe/docupulse.git
+      dockerfile: Dockerfile
     ports:
-      - "10335:5000"
+      - "${PORT:-10335}:5000"
     environment:
       - FLASK_APP=app.py
       - FLASK_ENV=production
-      - DATABASE_URL=postgresql://postgres:postgres@db:5432/docupulse
-      - POSTGRES_USER=postgres
-      - POSTGRES_PASSWORD=postgres
-      - POSTGRES_DB=docupulse
+      - DATABASE_URL=postgresql://docupulse_${PORT:-10335}:docupulse_${PORT:-10335}@db:5432/docupulse_${PORT:-10335}
+      - POSTGRES_USER=docupulse_${PORT:-10335}
+      - POSTGRES_PASSWORD=docupulse_${PORT:-10335}
+      - POSTGRES_DB=docupulse_${PORT:-10335}
+      - MASTER=${ISMASTER:-false}
+      - APP_VERSION=${APP_VERSION:-unknown}
+      - GIT_COMMIT=${GIT_COMMIT:-unknown}
+      - GIT_BRANCH=${GIT_BRANCH:-unknown}
+      - DEPLOYED_AT=${DEPLOYED_AT:-unknown}
     volumes:
-      - uploads:/app/uploads
+      - docupulse_uploads:/app/uploads
     depends_on:
       - db
     restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:5000/health"]
+      interval: 60s
+      timeout: 30s
+      retries: 3
+      start_period: 120s
     deploy:
       resources:
         limits:
           cpus: '1'
           memory: 1G
+    networks:
+      - docupulse_network
 
   db:
     image: postgres:13
     environment:
-      - POSTGRES_USER=postgres
-      - POSTGRES_PASSWORD=postgres
-      - POSTGRES_DB=docupulse
+      - POSTGRES_USER=docupulse_${PORT:-10335}
+      - POSTGRES_PASSWORD=docupulse_${PORT:-10335}
+      - POSTGRES_DB=docupulse_${PORT:-10335}
     volumes:
-      - postgres_data:/var/lib/postgresql/data
+      - docupulse_postgres_data:/var/lib/postgresql/data
     restart: unless-stopped
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U docupulse_${PORT:-10335}"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    networks:
+      - docupulse_network
 
 volumes:
-  postgres_data:
-    name: ${COMPOSE_PROJECT_NAME:-default}_postgres_data
-  uploads:
-    name: ${COMPOSE_PROJECT_NAME:-default}_uploads
+  docupulse_postgres_data:
+    name: docupulse_${PORT:-10335}_postgres_data
+  docupulse_uploads:
+    name: docupulse_${PORT:-10335}_uploads

entrypoint.sh

@@ -7,12 +7,28 @@ echo "POSTGRES_PASSWORD: $POSTGRES_PASSWORD"
 echo "POSTGRES_DB: $POSTGRES_DB"
 echo "DATABASE_URL: $DATABASE_URL"
 
-# Wait for the database to be ready
-echo "Waiting for database to be ready..."
+# Function to wait for database
+wait_for_db() {
+    echo "Waiting for database..."
     while ! nc -z db 5432; do
-  sleep 0.1
+        sleep 1
     done
     echo "Database is ready!"
+}
+
+# Function to create database if it doesn't exist
+create_database() {
+    echo "Creating database if it doesn't exist..."
+    PGPASSWORD=$POSTGRES_PASSWORD psql -h db -U $POSTGRES_USER -tc "SELECT 1 FROM pg_database WHERE datname = '$POSTGRES_DB'" | grep -q 1 || \
+    PGPASSWORD=$POSTGRES_PASSWORD psql -h db -U $POSTGRES_USER -c "CREATE DATABASE $POSTGRES_DB"
+    echo "Database check/creation complete!"
+}
+
+# Wait for database to be ready
+wait_for_db
+
+# Create database if it doesn't exist
+create_database
 
 # Wait for PostgreSQL to be ready to accept connections
 echo "Waiting for PostgreSQL to accept connections..."
@@ -22,46 +38,112 @@ until PGPASSWORD=$POSTGRES_PASSWORD psql -h db -U $POSTGRES_USER -d $POSTGRES_DB
 done
 echo "PostgreSQL is up - executing command"
 
-# Clean up existing migrations and initialize fresh
-echo "Cleaning up and initializing fresh migrations..."
-rm -rf migrations/versions/*
-flask db init
-flask db migrate -m "Initial migration"
-flask db upgrade
-
-# Create events table
-echo "Creating events table..."
+# Run all initialization in a single Python script to avoid multiple Flask instances
+echo "Running initialization..."
 python3 -c "
-from migrations.add_events_table import upgrade
+import sys
 from app import create_app
+from models import SiteSettings, db, User
+from utils.email_templates import create_default_templates
+
+def log_error(message, error=None):
+    print(f'ERROR: {message}', file=sys.stderr)
+    if error:
+        print(f'Error details: {str(error)}', file=sys.stderr)
+
 app = create_app()
 with app.app_context():
     try:
+        # Run migrations
+        print('Running database migrations...')
+        from flask_migrate import upgrade
         upgrade()
-        print('Events table created successfully')
-    except Exception as e:
-        print(f'Error creating events table: {e}')
-"
+        print('Database migrations completed successfully')
         
-# Create default site settings if they don't exist
-echo "Creating default site settings..."
-python3 -c "
-from app import create_app
-from models import SiteSettings, db
-app = create_app()
-with app.app_context():
+        # Create default site settings
+        print('Creating default site settings...')
         try:
             settings = SiteSettings.get_settings()
             print('Default site settings created successfully')
         except Exception as e:
-        print(f'Error creating site settings: {e}')
-"
+            log_error('Error creating site settings', e)
         
-# Initialize admin user
-echo "Initializing admin user..."
-python3 -c "
-from init_admin import init_admin
-init_admin()
+        # Create admin user if it doesn't exist
+        print('Creating admin user...')
+        try:
+            # Check for admin user by both username and email to avoid constraint violations
+            admin_by_username = User.query.filter_by(username='administrator').first()
+            admin_by_email = User.query.filter_by(email='administrator@docupulse.com').first()
+            
+            if admin_by_username and admin_by_email and admin_by_username.id == admin_by_email.id:
+                print('Admin user already exists (found by both username and email).')
+                print('Admin credentials:')
+                print('Email: administrator@docupulse.com')
+                print('Password: changeme')
+            elif admin_by_username or admin_by_email:
+                print('WARNING: Found partial admin user data:')
+                if admin_by_username:
+                    print(f'  - Found user with username "administrator" (ID: {admin_by_username.id})')
+                if admin_by_email:
+                    print(f'  - Found user with email "administrator@docupulse.com" (ID: {admin_by_email.id})')
+                print('Admin credentials:')
+                print('Email: administrator@docupulse.com')
+                print('Password: changeme')
+            else:
+                print('Admin user not found, creating new admin user...')
+                admin = User(
+                    username='administrator',
+                    email='administrator@docupulse.com',
+                    last_name='Administrator',
+                    company='DocuPulse',
+                    position='System Administrator',
+                    is_admin=True,
+                    is_active=True,
+                    preferred_view='grid'
+                )
+                admin.set_password('changeme')
+                print('Admin user object created, attempting to add to database...')
+                db.session.add(admin)
+                try:
+                    db.session.commit()
+                    print('Default administrator user created successfully.')
+                    print('Admin credentials:')
+                    print('Email: administrator@docupulse.com')
+                    print('Password: changeme')
+                except Exception as commit_error:
+                    db.session.rollback()
+                    if 'duplicate key value violates unique constraint' in str(commit_error):
+                        print('WARNING: Admin user creation failed due to duplicate key constraint.')
+                        print('This might indicate a race condition or the user was created by another process.')
+                        print('Checking for existing admin user again...')
+                        # Check again after the failed commit
+                        admin_by_username = User.query.filter_by(username='administrator').first()
+                        admin_by_email = User.query.filter_by(email='administrator@docupulse.com').first()
+                        if admin_by_username or admin_by_email:
+                            print('Admin user now exists (likely created by another process).')
+                            print('Admin credentials:')
+                            print('Email: administrator@docupulse.com')
+                            print('Password: changeme')
+                        else:
+                            log_error('Admin user creation failed and user still not found', commit_error)
+                            raise
+                    else:
+                        log_error('Failed to commit admin user creation', commit_error)
+                        raise
+        except Exception as e:
+            log_error('Error during admin user creation/check', e)
+            raise
+        
+        # Create default templates
+        print('Creating default templates...')
+        try:
+            create_default_templates()
+            print('Default templates created successfully')
+        except Exception as e:
+            log_error('Error creating default templates', e)
+    except Exception as e:
+        log_error('Fatal error during initialization', e)
+        sys.exit(1)
 "
 
 # Start the application

forms.py

@@ -1,5 +1,5 @@
 from flask_wtf import FlaskForm
-from wtforms import StringField, TextAreaField, BooleanField, SubmitField, PasswordField, SelectMultipleField
+from wtforms import StringField, TextAreaField, BooleanField, SubmitField, PasswordField, SelectMultipleField, SelectField
 from wtforms.validators import DataRequired, Email, Length, Optional, ValidationError
 from models import User
 from flask_login import current_user
@@ -13,7 +13,11 @@ class UserForm(FlaskForm):
     company = StringField('Company (Optional)', validators=[Optional(), Length(max=100)])
     position = StringField('Position (Optional)', validators=[Optional(), Length(max=100)])
     notes = TextAreaField('Notes (Optional)', validators=[Optional()])
-    is_admin = BooleanField('Admin Role', default=False)
+    role = SelectField('Role', choices=[
+        ('user', 'Standard User'),
+        ('manager', 'Manager'),
+        ('admin', 'Administrator')
+    ], validators=[DataRequired()])
     new_password = PasswordField('New Password (Optional)')
     confirm_password = PasswordField('Confirm Password (Optional)')
     profile_picture = FileField('Profile Picture (Optional)', validators=[FileAllowed(['jpg', 'jpeg', 'png', 'gif'], 'Images only!')])
@@ -30,6 +34,11 @@ class UserForm(FlaskForm):
                 if total_admins <= 1:
                     raise ValidationError('There must be at least one admin user in the system.')
 
+    def validate_is_manager(self, field):
+        # Prevent setting both admin and manager roles
+        if field.data and self.is_admin.data:
+            raise ValidationError('A user cannot be both an admin and a manager.')
+
     def validate(self, extra_validators=None):
         rv = super().validate(extra_validators=extra_validators)
         if not rv:

init_pricing_plans.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""
+Script to initialize default pricing plans in the database.
+This should be run on a MASTER instance only.
+"""
+
+import os
+import sys
+from app import app, db
+from models import PricingPlan, User
+
+def init_pricing_plans():
+    """Initialize default pricing plans"""
+    
+    # Check if this is a MASTER instance
+    if os.environ.get('MASTER', 'false').lower() != 'true':
+        print("Error: This script should only be run on a MASTER instance.")
+        print("Set MASTER=true environment variable to run this script.")
+        sys.exit(1)
+    
+    with app.app_context():
+        # Check if pricing plans already exist
+        existing_plans = PricingPlan.query.count()
+        if existing_plans > 0:
+            print(f"Found {existing_plans} existing pricing plans. Skipping initialization.")
+            return
+        
+        # Get the first admin user
+        admin_user = User.query.filter_by(is_admin=True).first()
+        if not admin_user:
+            print("Error: No admin user found. Please create an admin user first.")
+            sys.exit(1)
+        
+        # Default pricing plans
+        default_plans = [
+            {
+                'name': 'Starter',
+                'description': 'Perfect for small teams getting started',
+                'monthly_price': 29.0,
+                'annual_price': 23.0,
+                'features': [
+                    'Up to 5 rooms',
+                    'Up to 10 conversations',
+                    '10GB storage',
+                    'Up to 10 managers',
+                    'Email support'
+                ],
+                'button_text': 'Get Started',
+                'button_url': '#',
+                'is_popular': False,
+                'is_custom': False,
+                'is_active': True,
+                'order_index': 1,
+                'room_quota': 5,
+                'conversation_quota': 10,
+                'storage_quota_gb': 10,
+                'manager_quota': 10,
+                'admin_quota': 1
+            },
+            {
+                'name': 'Professional',
+                'description': 'Ideal for growing businesses',
+                'monthly_price': 99.0,
+                'annual_price': 79.0,
+                'features': [
+                    'Up to 25 rooms',
+                    'Up to 50 conversations',
+                    '100GB storage',
+                    'Up to 50 managers',
+                    'Priority support'
+                ],
+                'button_text': 'Get Started',
+                'button_url': '#',
+                'is_popular': True,
+                'is_custom': False,
+                'is_active': True,
+                'order_index': 2,
+                'room_quota': 25,
+                'conversation_quota': 50,
+                'storage_quota_gb': 100,
+                'manager_quota': 50,
+                'admin_quota': 3
+            },
+            {
+                'name': 'Enterprise',
+                'description': 'For large organizations with advanced needs',
+                'monthly_price': 299.0,
+                'annual_price': 239.0,
+                'features': [
+                    'Up to 100 rooms',
+                    'Up to 200 conversations',
+                    '500GB storage',
+                    'Up to 200 managers',
+                    '24/7 dedicated support'
+                ],
+                'button_text': 'Get Started',
+                'button_url': '#',
+                'is_popular': False,
+                'is_custom': False,
+                'is_active': True,
+                'order_index': 3,
+                'room_quota': 100,
+                'conversation_quota': 200,
+                'storage_quota_gb': 500,
+                'manager_quota': 200,
+                'admin_quota': 10
+            },
+            {
+                'name': 'Custom',
+                'description': 'Tailored solutions for enterprise customers',
+                'monthly_price': 0.0,
+                'annual_price': 0.0,
+                'features': [
+                    'Unlimited rooms',
+                    'Unlimited conversations',
+                    'Unlimited storage',
+                    'Unlimited users',
+                    'Custom integrations',
+                    'Dedicated account manager'
+                ],
+                'button_text': 'Contact Sales',
+                'button_url': '#',
+                'is_popular': False,
+                'is_custom': True,
+                'is_active': True,
+                'order_index': 4,
+                'room_quota': 0,
+                'conversation_quota': 0,
+                'storage_quota_gb': 0,
+                'manager_quota': 0,
+                'admin_quota': 0
+            }
+        ]
+        
+        # Create pricing plans
+        for plan_data in default_plans:
+            plan = PricingPlan(
+                name=plan_data['name'],
+                description=plan_data['description'],
+                monthly_price=plan_data['monthly_price'],
+                annual_price=plan_data['annual_price'],
+                features=plan_data['features'],
+                button_text=plan_data['button_text'],
+                button_url=plan_data['button_url'],
+                is_popular=plan_data['is_popular'],
+                is_custom=plan_data['is_custom'],
+                is_active=plan_data['is_active'],
+                order_index=plan_data['order_index'],
+                room_quota=plan_data['room_quota'],
+                conversation_quota=plan_data['conversation_quota'],
+                storage_quota_gb=plan_data['storage_quota_gb'],
+                manager_quota=plan_data['manager_quota'],
+                admin_quota=plan_data['admin_quota'],
+                created_by=admin_user.id
+            )
+            db.session.add(plan)
+        
+        try:
+            db.session.commit()
+            print("Successfully created default pricing plans:")
+            for plan_data in default_plans:
+                print(f"  - {plan_data['name']}: €{plan_data['monthly_price']}/month")
+            print("\nYou can now configure these plans in the admin settings.")
+        except Exception as e:
+            db.session.rollback()
+            print(f"Error creating pricing plans: {e}")
+            sys.exit(1)
+
+if __name__ == '__main__':
+    init_pricing_plans() 

migrations/add_events_table.py

@@ -1,61 +0,0 @@
-import os
-import sys
-from pathlib import Path
-
-# Add the parent directory to Python path so we can import from root
-sys.path.append(str(Path(__file__).parent.parent))
-
-from flask import Flask
-from flask_sqlalchemy import SQLAlchemy
-from extensions import db
-from sqlalchemy import text
-
-def upgrade():
-    # Create events table
-    with db.engine.connect() as conn:
-        conn.execute(text('''
-            CREATE TABLE IF NOT EXISTS events (
-                id SERIAL PRIMARY KEY,
-                event_type VARCHAR(50) NOT NULL,
-                user_id INTEGER NOT NULL REFERENCES "user" (id),
-                timestamp TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-                details JSONB,
-                ip_address VARCHAR(45),
-                user_agent VARCHAR(255)
-            );
-            
-            -- Create index on event_type for faster filtering
-            CREATE INDEX IF NOT EXISTS idx_events_event_type ON events(event_type);
-            
-            -- Create index on timestamp for faster date-based queries
-            CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
-            
-            -- Create index on user_id for faster user-based queries
-            CREATE INDEX IF NOT EXISTS idx_events_user_id ON events(user_id);
-        '''))
-        conn.commit()
-
-def downgrade():
-    # Drop events table and its indexes
-    with db.engine.connect() as conn:
-        conn.execute(text('''
-            DROP INDEX IF EXISTS idx_events_event_type;
-            DROP INDEX IF EXISTS idx_events_timestamp;
-            DROP INDEX IF EXISTS idx_events_user_id;
-            DROP TABLE IF EXISTS events;
-        '''))
-        conn.commit()
-
-if __name__ == '__main__':
-    app = Flask(__name__)
-    
-    # Use the same database configuration as in app.py
-    app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL', 'postgresql://postgres:1253@localhost:5432/docupulse')
-    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
-    
-    print("Connecting to database...")
-    
-    db.init_app(app)
-    
-    with app.app_context():
-        upgrade() 

migrations/add_notifs_table.py

@@ -1,61 +0,0 @@
-import os
-import sys
-from pathlib import Path
-
-# Add the parent directory to Python path so we can import from root
-sys.path.append(str(Path(__file__).parent.parent))
-
-from flask import Flask
-from flask_sqlalchemy import SQLAlchemy
-from extensions import db
-from sqlalchemy import text
-
-def upgrade():
-    # Create notifs table
-    with db.engine.connect() as conn:
-        conn.execute(text('''
-            CREATE TABLE IF NOT EXISTS notifs (
-                id SERIAL PRIMARY KEY,
-                notif_type VARCHAR(50) NOT NULL,
-                user_id INTEGER NOT NULL REFERENCES "user" (id),
-                sender_id INTEGER REFERENCES "user" (id),
-                timestamp TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-                read BOOLEAN NOT NULL DEFAULT FALSE,
-                details JSONB
-            );
-            
-            -- Create indexes for faster queries
-            CREATE INDEX IF NOT EXISTS idx_notifs_notif_type ON notifs(notif_type);
-            CREATE INDEX IF NOT EXISTS idx_notifs_timestamp ON notifs(timestamp);
-            CREATE INDEX IF NOT EXISTS idx_notifs_user_id ON notifs(user_id);
-            CREATE INDEX IF NOT EXISTS idx_notifs_sender_id ON notifs(sender_id);
-            CREATE INDEX IF NOT EXISTS idx_notifs_read ON notifs(read);
-        '''))
-        conn.commit()
-
-def downgrade():
-    # Drop notifs table and its indexes
-    with db.engine.connect() as conn:
-        conn.execute(text('''
-            DROP INDEX IF EXISTS idx_notifs_notif_type;
-            DROP INDEX IF EXISTS idx_notifs_timestamp;
-            DROP INDEX IF EXISTS idx_notifs_user_id;
-            DROP INDEX IF EXISTS idx_notifs_sender_id;
-            DROP INDEX IF EXISTS idx_notifs_read;
-            DROP TABLE IF EXISTS notifs;
-        '''))
-        conn.commit()
-
-if __name__ == '__main__':
-    app = Flask(__name__)
-    
-    # Use the same database configuration as in app.py
-    app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL', 'postgresql://postgres:1253@localhost:5432/docupulse')
-    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
-    
-    print("Connecting to database...")
-    
-    db.init_app(app)
-    
-    with app.app_context():
-        upgrade() 

migrations/versions/0a8006bd1732_add_key_value_settings_table.py

@@ -0,0 +1,41 @@
+"""add key value settings table
+
+Revision ID: 0a8006bd1732
+Revises: 20519a2437c2
+Create Date: 2025-06-02 14:10:54.033943
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy import inspect
+
+
+# revision identifiers, used by Alembic.
+revision = '0a8006bd1732'
+down_revision = '20519a2437c2'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    tables = inspector.get_table_names()
+    
+    if 'key_value_settings' not in tables:
+        op.create_table('key_value_settings',
+            sa.Column('id', sa.Integer(), nullable=False),
+            sa.Column('key', sa.String(length=100), nullable=False),
+            sa.Column('value', sa.Text(), nullable=True),
+            sa.Column('updated_at', sa.DateTime(), nullable=True),
+            sa.PrimaryKeyConstraint('id'),
+            sa.UniqueConstraint('key')
+        )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('key_value_settings')
+    # ### end Alembic commands ### 

migrations/versions/0f48943140fa_add_file_attachment_fields_to_message_.py

@@ -7,6 +7,7 @@ Create Date: 2025-05-26 14:00:05.521776
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 
 
 # revision identifiers, used by Alembic.
@@ -18,11 +19,20 @@ depends_on = None
 
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    columns = [col['name'] for col in inspector.get_columns('message')]
+    
     with op.batch_alter_table('message', schema=None) as batch_op:
+        if 'has_attachment' not in columns:
             batch_op.add_column(sa.Column('has_attachment', sa.Boolean(), nullable=True))
+        if 'attachment_name' not in columns:
             batch_op.add_column(sa.Column('attachment_name', sa.String(length=255), nullable=True))
+        if 'attachment_path' not in columns:
             batch_op.add_column(sa.Column('attachment_path', sa.String(length=512), nullable=True))
+        if 'attachment_type' not in columns:
             batch_op.add_column(sa.Column('attachment_type', sa.String(length=100), nullable=True))
+        if 'attachment_size' not in columns:
             batch_op.add_column(sa.Column('attachment_size', sa.Integer(), nullable=True))
 
     # ### end Alembic commands ###
@@ -30,11 +40,20 @@ def upgrade():
 
 def downgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    columns = [col['name'] for col in inspector.get_columns('message')]
+    
     with op.batch_alter_table('message', schema=None) as batch_op:
+        if 'attachment_size' in columns:
             batch_op.drop_column('attachment_size')
+        if 'attachment_type' in columns:
             batch_op.drop_column('attachment_type')
+        if 'attachment_path' in columns:
             batch_op.drop_column('attachment_path')
+        if 'attachment_name' in columns:
             batch_op.drop_column('attachment_name')
+        if 'has_attachment' in columns:
             batch_op.drop_column('has_attachment')
 
     # ### end Alembic commands ###

migrations/versions/1c297825e3a9_add_user_authentication_fields.py

@@ -2,11 +2,12 @@
 
 Revision ID: 1c297825e3a9
 Revises: 
-Create Date: 2025-05-23 08:39:40.494853
+Create Date: 2025-06-02 13:26:30.353000
 
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 
 
 # revision identifiers, used by Alembic.
@@ -17,7 +18,15 @@ depends_on = None
 
 
 def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
+    # Check if the table exists before creating it
+    conn = op.get_bind()
+    inspector = sa.inspect(conn)
+    if 'user' not in inspector.get_table_names():
+        conn = op.get_bind()
+        inspector = inspect(conn)
+        tables = inspector.get_table_names()
+        
+        if 'user' not in tables:
             op.create_table('user',
                 sa.Column('id', sa.Integer(), nullable=False),
                 sa.Column('username', sa.String(length=150), nullable=False),
@@ -27,7 +36,6 @@ def upgrade():
                 sa.UniqueConstraint('email'),
                 sa.UniqueConstraint('username')
             )
-    # ### end Alembic commands ###
 
 
 def downgrade():

migrations/versions/20519a2437c2_add_mails_table.py

@@ -0,0 +1,47 @@
+"""add_mails_table
+
+Revision ID: 20519a2437c2
+Revises: 444d76da74ba
+Create Date: 2025-06-02 09:04:39.972021
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy import inspect
+
+
+# revision identifiers, used by Alembic.
+revision = '20519a2437c2'
+down_revision = '444d76da74ba'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    tables = inspector.get_table_names()
+    
+    if 'mails' not in tables:
+        op.create_table('mails',
+            sa.Column('id', sa.Integer(), nullable=False),
+            sa.Column('recipient', sa.String(length=150), nullable=False),
+            sa.Column('subject', sa.String(length=200), nullable=False),
+            sa.Column('body', sa.Text(), nullable=False),
+            sa.Column('status', sa.String(length=20), nullable=False),
+            sa.Column('created_at', sa.DateTime(), nullable=True),
+            sa.Column('sent_at', sa.DateTime(), nullable=True),
+            sa.Column('template_id', sa.Integer(), nullable=True),
+            sa.Column('notif_id', sa.Integer(), nullable=True),
+            sa.ForeignKeyConstraint(['notif_id'], ['notifs.id'], ),
+            sa.ForeignKeyConstraint(['template_id'], ['email_templates.id'], ),
+            sa.PrimaryKeyConstraint('id')
+        )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('mails')
+    # ### end Alembic commands ### 

migrations/versions/25da158dd705_add_is_admin_to_contact_model.py

@@ -7,6 +7,7 @@ Create Date: 2025-05-23 16:10:53.731035
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 
 
 # revision identifiers, used by Alembic.
@@ -18,7 +19,12 @@ depends_on = None
 
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    columns = [col['name'] for col in inspector.get_columns('contact')]
+    
     with op.batch_alter_table('contact', schema=None) as batch_op:
+        if 'is_admin' not in columns:
             batch_op.add_column(sa.Column('is_admin', sa.Boolean(), nullable=True))
 
     # ### end Alembic commands ###
@@ -26,7 +32,12 @@ def upgrade():
 
 def downgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    columns = [col['name'] for col in inspector.get_columns('contact')]
+    
     with op.batch_alter_table('contact', schema=None) as batch_op:
+        if 'is_admin' in columns:
             batch_op.drop_column('is_admin')
 
     # ### end Alembic commands ###

migrations/versions/26b0e5357f52_add_room_member_permissions_table.py

@@ -7,6 +7,7 @@ Create Date: 2025-05-23 21:44:58.832286
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 
 
 # revision identifiers, used by Alembic.
@@ -18,6 +19,11 @@ depends_on = None
 
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    tables = inspector.get_table_names()
+    
+    if 'room_member_permissions' not in tables:
         op.create_table('room_member_permissions',
         sa.Column('room_id', sa.Integer(), nullable=False),
         sa.Column('user_id', sa.Integer(), nullable=False),

migrations/versions/2c5f57dddb78_add_room_members_table.py

@@ -7,6 +7,7 @@ Create Date: 2025-05-23 21:27:17.497481
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 
 
 # revision identifiers, used by Alembic.
@@ -18,6 +19,11 @@ depends_on = None
 
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    tables = inspector.get_table_names()
+    
+    if 'room_members' not in tables:
         op.create_table('room_members',
         sa.Column('room_id', sa.Integer(), nullable=False),
         sa.Column('user_id', sa.Integer(), nullable=False),
@@ -25,6 +31,10 @@ def upgrade():
         sa.ForeignKeyConstraint(['user_id'], ['user.id'], ),
         sa.PrimaryKeyConstraint('room_id', 'user_id')
         )
+    
+    # Check if is_private column exists before dropping it
+    columns = [col['name'] for col in inspector.get_columns('room')]
+    if 'is_private' in columns:
         with op.batch_alter_table('room', schema=None) as batch_op:
             batch_op.drop_column('is_private')
 

migrations/versions/3a5b8d8e53cd_add_rooms_table.py

@@ -7,6 +7,7 @@ Create Date: 2025-05-23 21:25:27.880150
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 
 
 # revision identifiers, used by Alembic.
@@ -18,6 +19,11 @@ depends_on = None
 
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    tables = inspector.get_table_names()
+    
+    if 'room' not in tables:
         op.create_table('room',
         sa.Column('id', sa.Integer(), nullable=False),
         sa.Column('name', sa.String(length=100), nullable=False),

migrations/versions/43dfd2543fad_add_contact_fields_to_user_model.py

@@ -7,6 +7,7 @@ Create Date: 2025-05-23 09:24:23.926302
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 
 
 # revision identifiers, used by Alembic.
@@ -18,11 +19,20 @@ depends_on = None
 
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    columns = [col['name'] for col in inspector.get_columns('user')]
+    
     with op.batch_alter_table('user', schema=None) as batch_op:
+        if 'phone' not in columns:
             batch_op.add_column(sa.Column('phone', sa.String(length=20), nullable=True))
+        if 'company' not in columns:
             batch_op.add_column(sa.Column('company', sa.String(length=100), nullable=True))
+        if 'position' not in columns:
             batch_op.add_column(sa.Column('position', sa.String(length=100), nullable=True))
+        if 'notes' not in columns:
             batch_op.add_column(sa.Column('notes', sa.Text(), nullable=True))
+        if 'is_active' not in columns:
             batch_op.add_column(sa.Column('is_active', sa.Boolean(), nullable=True))
 
     # ### end Alembic commands ###

migrations/versions/444d76da74ba_add_notifications_table.py

@@ -0,0 +1,63 @@
+"""add_notifications_table
+
+Revision ID: 444d76da74ba
+Revises: c770e08966b4
+Create Date: 2025-06-02 08:25:48.241102
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy import inspect
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = '444d76da74ba'
+down_revision = 'c770e08966b4'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    tables = inspector.get_table_names()
+    
+    if 'template_variables' in tables:
+        op.drop_table('template_variables')
+    
+    op.create_table('notification',
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('user_id', sa.Integer(), nullable=False),
+        sa.Column('title', sa.String(length=200), nullable=False),
+        sa.Column('message', sa.Text(), nullable=False),
+        sa.Column('type', sa.String(length=50), nullable=False),
+        sa.Column('read', sa.Boolean(), nullable=False, server_default='false'),
+        sa.Column('created_at', sa.DateTime(), nullable=True),
+        sa.Column('updated_at', sa.DateTime(), nullable=True),
+        sa.ForeignKeyConstraint(['user_id'], ['user.id'], ),
+        sa.PrimaryKeyConstraint('id')
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    tables = inspector.get_table_names()
+    
+    if 'notification' in tables:
+        op.drop_table('notification')
+    
+    if 'template_variables' not in tables:
+        op.create_table('template_variables',
+            sa.Column('id', sa.INTEGER(), autoincrement=True, nullable=False),
+            sa.Column('notification_type', sa.VARCHAR(length=50), autoincrement=False, nullable=False),
+            sa.Column('variable_name', sa.VARCHAR(length=50), autoincrement=False, nullable=False),
+            sa.Column('description', sa.VARCHAR(length=200), autoincrement=False, nullable=False),
+            sa.Column('example_value', sa.VARCHAR(length=200), autoincrement=False, nullable=True),
+            sa.Column('created_at', postgresql.TIMESTAMP(), autoincrement=False, nullable=True),
+            sa.PrimaryKeyConstraint('id', name=op.f('template_variables_pkey'))
+        )
+    # ### end Alembic commands ### 

migrations/versions/4ee23cb29001_merge_heads.py

@@ -0,0 +1,24 @@
+"""merge heads
+
+Revision ID: 4ee23cb29001
+Revises: 72ab6c4c6a5f, add_status_details
+Create Date: 2025-06-09 10:04:48.708415
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '4ee23cb29001'
+down_revision = ('72ab6c4c6a5f', 'add_status_details')
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    pass
+
+
+def downgrade():
+    pass

migrations/versions/64b5c28510b0_add_room_file_table_for_file_folder_.py

@@ -7,6 +7,7 @@ Create Date: 2025-05-24 10:07:02.159730
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 
 
 # revision identifiers, used by Alembic.
@@ -18,6 +19,11 @@ depends_on = None
 
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    tables = inspector.get_table_names()
+    
+    if 'room_file' not in tables:
         op.create_table('room_file',
             sa.Column('id', sa.Integer(), nullable=False),
             sa.Column('room_id', sa.Integer(), nullable=False),
@@ -32,6 +38,10 @@ def upgrade():
             sa.ForeignKeyConstraint(['uploaded_by'], ['user.id'], ),
             sa.PrimaryKeyConstraint('id')
         )
+    
+    # Check if preferred_view column exists before trying to drop it
+    columns = [col['name'] for col in inspector.get_columns('room_member_permissions')]
+    if 'preferred_view' in columns:
         with op.batch_alter_table('room_member_permissions', schema=None) as batch_op:
             batch_op.drop_column('preferred_view')
 

migrations/versions/6651332488d9_add_starred_column_to_room_file_table.py

@@ -7,6 +7,7 @@ Create Date: 2025-05-24 18:14:38.320999
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 from sqlalchemy.dialects import postgresql
 
 # revision identifiers, used by Alembic.
@@ -18,19 +19,30 @@ depends_on = None
 
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    columns = [col['name'] for col in inspector.get_columns('room_file')]
+    
     with op.batch_alter_table('room_file', schema=None) as batch_op:
+        if 'starred' not in columns:
             batch_op.add_column(sa.Column('starred', sa.Boolean(), nullable=True))
+        
+        # Only alter columns if they exist
+        if 'path' in columns:
             batch_op.alter_column('path',
                    existing_type=sa.VARCHAR(length=1024),
                    type_=sa.String(length=255),
                    existing_nullable=False)
+        if 'size' in columns:
             batch_op.alter_column('size',
                    existing_type=sa.BIGINT(),
                    type_=sa.Integer(),
                    existing_nullable=True)
+        if 'uploaded_by' in columns:
             batch_op.alter_column('uploaded_by',
                    existing_type=sa.INTEGER(),
                    nullable=True)
+        if 'uploaded_at' in columns:
             batch_op.alter_column('uploaded_at',
                    existing_type=postgresql.TIMESTAMP(),
                    nullable=True)
@@ -40,21 +52,30 @@ def upgrade():
 
 def downgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    columns = [col['name'] for col in inspector.get_columns('room_file')]
+    
     with op.batch_alter_table('room_file', schema=None) as batch_op:
+        if 'uploaded_at' in columns:
             batch_op.alter_column('uploaded_at',
                    existing_type=postgresql.TIMESTAMP(),
                    nullable=False)
+        if 'uploaded_by' in columns:
             batch_op.alter_column('uploaded_by',
                    existing_type=sa.INTEGER(),
                    nullable=False)
+        if 'size' in columns:
             batch_op.alter_column('size',
                    existing_type=sa.Integer(),
                    type_=sa.BIGINT(),
                    existing_nullable=True)
+        if 'path' in columns:
             batch_op.alter_column('path',
                    existing_type=sa.String(length=255),
                    type_=sa.VARCHAR(length=1024),
                    existing_nullable=False)
+        if 'starred' in columns:
             batch_op.drop_column('starred')
 
     # ### end Alembic commands ###

migrations/versions/72ab6c4c6a5f_merge_heads.py

@@ -0,0 +1,32 @@
+"""merge heads
+
+Revision ID: 72ab6c4c6a5f
+Revises: 0a8006bd1732, add_docupulse_settings, add_manager_role, make_events_user_id_nullable
+Create Date: 2025-06-05 14:21:46.046125
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy import inspect
+
+
+# revision identifiers, used by Alembic.
+revision = '72ab6c4c6a5f'
+down_revision = ('0a8006bd1732', 'add_docupulse_settings', 'add_manager_role', 'make_events_user_id_nullable')
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Ensure is_manager column exists
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    columns = [col['name'] for col in inspector.get_columns('user')]
+    
+    with op.batch_alter_table('user', schema=None) as batch_op:
+        if 'is_manager' not in columns:
+            batch_op.add_column(sa.Column('is_manager', sa.Boolean(), nullable=True, server_default='false'))
+
+
+def downgrade():
+    pass

migrations/versions/7554ab70efe7_fix_existing_users.py

@@ -7,6 +7,7 @@ Create Date: 2024-03-19 10:05:00.000000
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 from sqlalchemy.sql import text
 
 

migrations/versions/761908f0cacf_merge_heads.py

@@ -0,0 +1,24 @@
+"""merge heads
+
+Revision ID: 761908f0cacf
+Revises: 4ee23cb29001, add_connection_token
+Create Date: 2025-06-09 13:57:17.650231
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '761908f0cacf'
+down_revision = ('4ee23cb29001', 'add_connection_token')
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    pass
+
+
+def downgrade():
+    pass

migrations/versions/76da0573e84b_merge_heads.py

@@ -7,6 +7,7 @@ Create Date: 2025-05-25 10:03:03.423064
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 
 
 # revision identifiers, used by Alembic.

migrations/versions/787468cfea77_add_company_information_fields_to_.py

@@ -7,6 +7,7 @@ Create Date: 2025-05-26 10:42:17.287566
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 
 
 # revision identifiers, used by Alembic.
@@ -18,16 +19,30 @@ depends_on = None
 
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    columns = [col['name'] for col in inspector.get_columns('site_settings')]
+    
     with op.batch_alter_table('site_settings', schema=None) as batch_op:
+        if 'company_website' not in columns:
             batch_op.add_column(sa.Column('company_website', sa.String(length=200), nullable=True))
+        if 'company_email' not in columns:
             batch_op.add_column(sa.Column('company_email', sa.String(length=100), nullable=True))
+        if 'company_phone' not in columns:
             batch_op.add_column(sa.Column('company_phone', sa.String(length=20), nullable=True))
+        if 'company_address' not in columns:
             batch_op.add_column(sa.Column('company_address', sa.String(length=200), nullable=True))
+        if 'company_city' not in columns:
             batch_op.add_column(sa.Column('company_city', sa.String(length=100), nullable=True))
+        if 'company_state' not in columns:
             batch_op.add_column(sa.Column('company_state', sa.String(length=100), nullable=True))
+        if 'company_zip' not in columns:
             batch_op.add_column(sa.Column('company_zip', sa.String(length=20), nullable=True))
+        if 'company_country' not in columns:
             batch_op.add_column(sa.Column('company_country', sa.String(length=100), nullable=True))
+        if 'company_description' not in columns:
             batch_op.add_column(sa.Column('company_description', sa.Text(), nullable=True))
+        if 'company_industry' not in columns:
             batch_op.add_column(sa.Column('company_industry', sa.String(length=100), nullable=True))
 
     # ### end Alembic commands ###

migrations/versions/7a5747dc773f_update_last_name_field_in_user_model.py

@@ -7,6 +7,7 @@ Create Date: 2024-03-19 10:15:00.000000
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 from sqlalchemy.sql import text
 
 

migrations/versions/9206bf87bb8e_add_portainer_stack_fields_to_instances.py

@@ -0,0 +1,46 @@
+"""add portainer stack fields to instances
+
+Revision ID: 9206bf87bb8e
+Revises: add_quota_fields
+Create Date: 2025-06-24 14:02:17.375785
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy import text
+
+
+# revision identifiers, used by Alembic.
+revision = '9206bf87bb8e'
+down_revision = 'add_quota_fields'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    conn = op.get_bind()
+    
+    # Check if columns already exist
+    result = conn.execute(text("""
+        SELECT column_name 
+        FROM information_schema.columns 
+        WHERE table_name = 'instances' 
+        AND column_name IN ('portainer_stack_id', 'portainer_stack_name')
+    """))
+    existing_columns = [row[0] for row in result.fetchall()]
+    
+    # Add portainer stack columns if they don't exist
+    with op.batch_alter_table('instances', schema=None) as batch_op:
+        if 'portainer_stack_id' not in existing_columns:
+            batch_op.add_column(sa.Column('portainer_stack_id', sa.String(length=100), nullable=True))
+        if 'portainer_stack_name' not in existing_columns:
+            batch_op.add_column(sa.Column('portainer_stack_name', sa.String(length=100), nullable=True))
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('instances', schema=None) as batch_op:
+        batch_op.drop_column('portainer_stack_name')
+        batch_op.drop_column('portainer_stack_id')
+
+    # ### end Alembic commands ###

migrations/versions/9faab7ef6036_add_site_settings_table.py

@@ -7,8 +7,10 @@ Create Date: 2025-05-25 21:16:39.683736
 """
 from alembic import op
 import sqlalchemy as sa
+from sqlalchemy import inspect
 from sqlalchemy.dialects import postgresql
 
+
 # revision identifiers, used by Alembic.
 revision = '9faab7ef6036'
 down_revision = 'ca9026520dad'
@@ -18,6 +20,11 @@ depends_on = None
 
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    tables = inspector.get_table_names()
+    
+    if 'site_settings' not in tables:
         op.create_table('site_settings',
             sa.Column('id', sa.Integer(), nullable=False),
             sa.Column('primary_color', sa.String(length=7), nullable=True),
@@ -31,6 +38,11 @@ def upgrade():
 
 def downgrade():
     # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = inspect(conn)
+    tables = inspector.get_table_names()
+    
+    if 'color_settings' not in tables:
         op.create_table('color_settings',
             sa.Column('id', sa.INTEGER(), autoincrement=True, nullable=False),
             sa.Column('primary_color', sa.VARCHAR(length=7), autoincrement=False, nullable=True),