First commit.

.gitignore

@@ -0,0 +1,35 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+ENV/
+*.egg-info/
+dist/
+build/
+
+# Flask
+instance/
+.webassets-cache
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Environment
+.env
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db

Dockerfile

@@ -0,0 +1,38 @@
+# Hugging Face Spaces Dockerfile
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create instance directory for database
+RUN mkdir -p instance
+
+# Hugging Face Spaces uses port 7860
+EXPOSE 7860
+
+# Set environment variables
+ENV FLASK_ENV=production
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+  CMD curl -f http://localhost:7860/login || exit 1
+
+# Run the application
+CMD ["python", "app_hf.py"]

README.md

@@ -1,12 +1,56 @@
 ---
-title: Participatory Planner
-emoji: 📈
-colorFrom: yellow
-colorTo: gray
+title: Participatory Planning Application
+emoji: 🏙️
+colorFrom: blue
+colorTo: purple
 sdk: docker
 pinned: false
 license: mit
-short_description: Planner Helper APP
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Participatory Planning Application
+
+An AI-powered collaborative urban planning platform for multi-stakeholder engagement sessions.
+
+## Features
+
+- 🎯 **Token-based access** - Self-service registration for participants
+- 🤖 **AI categorization** - Automatic classification using Hugging Face models (free & offline)
+- 🗺️ **Geographic mapping** - Interactive visualization of geotagged contributions
+- 📊 **Analytics dashboard** - Real-time charts and category breakdowns
+- 💾 **Session management** - Export/import for pause/resume workflows
+- 👥 **Multi-stakeholder** - Government, Community, Industry, NGO, Academic, Other
+
+## Quick Start
+
+1. Access the application
+2. Login with admin token: `ADMIN123`
+3. Go to **Registration** to get the participant signup link
+4. Share the link with stakeholders
+5. Collect submissions and analyze with AI
+
+## Default Login
+
+- **Admin Token**: `ADMIN123`
+- **Admin Access**: Full dashboard, analytics, moderation
+
+## Tech Stack
+
+- Flask (Python web framework)
+- SQLite (database)
+- Hugging Face Transformers (AI classification)
+- Leaflet.js (maps)
+- Chart.js (analytics)
+- Bootstrap 5 (UI)
+
+## Demo Data
+
+The app starts empty. You can:
+1. Generate tokens for test users
+2. Submit sample contributions
+3. Run AI analysis
+4. View analytics dashboard
+
+## License
+
+MIT

app/__init__.py

@@ -0,0 +1,42 @@
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+from dotenv import load_dotenv
+import os
+
+db = SQLAlchemy()
+
+def create_app():
+    load_dotenv()
+
+    app = Flask(__name__)
+    app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'dev-secret-key-change-in-production')
+    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///participatory_planner.db'
+    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+
+    db.init_app(app)
+
+    # Import models
+    from app.models import models
+
+    # Import and register blueprints
+    from app.routes import auth, submissions, admin
+
+    app.register_blueprint(auth.bp)
+    app.register_blueprint(submissions.bp)
+    app.register_blueprint(admin.bp)
+
+    # Create tables
+    with app.app_context():
+        db.create_all()
+        # Initialize with admin token if not exists
+        from app.models.models import Token
+        if not Token.query.filter_by(token='ADMIN123').first():
+            admin_token = Token(
+                token='ADMIN123',
+                type='admin',
+                name='Administrator'
+            )
+            db.session.add(admin_token)
+            db.session.commit()
+
+    return app

app/analyzer.py

@@ -0,0 +1,109 @@
+"""
+AI-powered submission analyzer using Hugging Face zero-shot classification.
+This module provides free, offline classification without requiring API keys.
+"""
+
+from transformers import pipeline
+import logging
+
+logger = logging.getLogger(__name__)
+
+class SubmissionAnalyzer:
+    def __init__(self):
+        """Initialize the zero-shot classification model."""
+        self.classifier = None
+        self.categories = [
+            'Vision',
+            'Problem',
+            'Objectives',
+            'Directives',
+            'Values',
+            'Actions'
+        ]
+
+        # Category descriptions for better classification
+        self.category_descriptions = {
+            'Vision': 'future aspirations, desired outcomes, what success looks like',
+            'Problem': 'current issues, frustrations, causes of problems',
+            'Objectives': 'specific goals to achieve',
+            'Directives': 'restrictions or requirements for solution design',
+            'Values': 'principles or restrictions for setting objectives',
+            'Actions': 'concrete steps, interventions, or activities to implement'
+        }
+
+    def _load_model(self):
+        """Lazy load the model only when needed."""
+        if self.classifier is None:
+            try:
+                logger.info("Loading zero-shot classification model...")
+                # Using facebook/bart-large-mnli - good balance of speed and accuracy
+                self.classifier = pipeline(
+                    "zero-shot-classification",
+                    model="facebook/bart-large-mnli",
+                    device=-1  # Use CPU (-1), change to 0 for GPU
+                )
+                logger.info("Model loaded successfully!")
+            except Exception as e:
+                logger.error(f"Error loading model: {e}")
+                raise
+
+    def analyze(self, message):
+        """
+        Classify a submission message into one of the predefined categories.
+
+        Args:
+            message (str): The submission message to classify
+
+        Returns:
+            str: The predicted category
+        """
+        self._load_model()
+
+        try:
+            # Use category descriptions as labels for better accuracy
+            candidate_labels = [
+                f"{cat}: {self.category_descriptions[cat]}"
+                for cat in self.categories
+            ]
+
+            # Run classification
+            result = self.classifier(
+                message,
+                candidate_labels,
+                multi_label=False
+            )
+
+            # Extract the category name from the label
+            top_label = result['labels'][0]
+            category = top_label.split(':')[0]
+
+            logger.info(f"Classified message as: {category} (confidence: {result['scores'][0]:.2f})")
+
+            return category
+
+        except Exception as e:
+            logger.error(f"Error analyzing message: {e}")
+            # Fallback to Problem category if analysis fails
+            return 'Problem'
+
+    def analyze_batch(self, messages):
+        """
+        Classify multiple messages at once.
+
+        Args:
+            messages (list): List of submission messages
+
+        Returns:
+            list: List of predicted categories
+        """
+        return [self.analyze(msg) for msg in messages]
+
+# Global analyzer instance
+_analyzer = None
+
+def get_analyzer():
+    """Get or create the global analyzer instance."""
+    global _analyzer
+    if _analyzer is None:
+        _analyzer = SubmissionAnalyzer()
+    return _analyzer

app/models/models.py

@@ -0,0 +1,68 @@
+from app import db
+from datetime import datetime
+
+class Token(db.Model):
+    __tablename__ = 'tokens'
+
+    id = db.Column(db.Integer, primary_key=True)
+    token = db.Column(db.String(50), unique=True, nullable=False)
+    type = db.Column(db.String(20), nullable=False)  # admin, government, community, industry, ngo, academic, other
+    name = db.Column(db.String(100), nullable=False)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'token': self.token,
+            'type': self.type,
+            'name': self.name,
+            'created_at': self.created_at.isoformat() if self.created_at else None
+        }
+
+class Submission(db.Model):
+    __tablename__ = 'submissions'
+
+    id = db.Column(db.Integer, primary_key=True)
+    message = db.Column(db.Text, nullable=False)
+    contributor_type = db.Column(db.String(20), nullable=False)
+    latitude = db.Column(db.Float, nullable=True)
+    longitude = db.Column(db.Float, nullable=True)
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
+    category = db.Column(db.String(50), nullable=True)  # Vision, Problem, Objectives, Directives, Values, Actions
+    flagged_as_offensive = db.Column(db.Boolean, default=False)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'message': self.message,
+            'contributorType': self.contributor_type,
+            'location': {
+                'lat': self.latitude,
+                'lng': self.longitude
+            } if self.latitude and self.longitude else None,
+            'timestamp': self.timestamp.isoformat() if self.timestamp else None,
+            'category': self.category,
+            'flaggedAsOffensive': self.flagged_as_offensive
+        }
+
+class Settings(db.Model):
+    __tablename__ = 'settings'
+
+    id = db.Column(db.Integer, primary_key=True)
+    key = db.Column(db.String(50), unique=True, nullable=False)
+    value = db.Column(db.String(10), nullable=False)  # 'true' or 'false'
+
+    @staticmethod
+    def get_setting(key, default='true'):
+        setting = Settings.query.filter_by(key=key).first()
+        return setting.value if setting else default
+
+    @staticmethod
+    def set_setting(key, value):
+        setting = Settings.query.filter_by(key=key).first()
+        if setting:
+            setting.value = value
+        else:
+            setting = Settings(key=key, value=value)
+            db.session.add(setting)
+        db.session.commit()

app/routes/admin.py

@@ -0,0 +1,398 @@
+from flask import Blueprint, render_template, request, redirect, url_for, session, flash, jsonify, send_file
+from app.models.models import Token, Submission, Settings
+from app import db
+from app.analyzer import get_analyzer
+from functools import wraps
+import json
+import csv
+import io
+from datetime import datetime
+import os
+
+bp = Blueprint('admin', __name__, url_prefix='/admin')
+
+CONTRIBUTOR_TYPES = [
+    {'value': 'government', 'label': 'Government Officer', 'description': 'Public sector representatives'},
+    {'value': 'community', 'label': 'Community Member', 'description': 'Local residents and community leaders'},
+    {'value': 'industry', 'label': 'Industry Representative', 'description': 'Business and industry stakeholders'},
+    {'value': 'ngo', 'label': 'NGO/Non-Profit', 'description': 'Civil society organizations'},
+    {'value': 'academic', 'label': 'Academic/Researcher', 'description': 'Universities and research institutions'},
+    {'value': 'other', 'label': 'Other Stakeholder', 'description': 'Other interested parties'}
+]
+
+CATEGORIES = ['Vision', 'Problem', 'Objectives', 'Directives', 'Values', 'Actions']
+
+def admin_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'token' not in session or session.get('type') != 'admin':
+            return redirect(url_for('auth.login'))
+        return f(*args, **kwargs)
+    return decorated_function
+
+@bp.route('/overview')
+@admin_required
+def overview():
+    total_submissions = Submission.query.count()
+    total_tokens = Token.query.filter(Token.type != 'admin').count()
+    flagged_count = Submission.query.filter_by(flagged_as_offensive=True).count()
+    unanalyzed_count = Submission.query.filter_by(category=None).count()
+
+    submission_open = Settings.get_setting('submission_open', 'true') == 'true'
+    token_generation_enabled = Settings.get_setting('token_generation_enabled', 'true') == 'true'
+
+    analyzed = Submission.query.filter(Submission.category != None).count() > 0
+
+    return render_template('admin/overview.html',
+                         total_submissions=total_submissions,
+                         total_tokens=total_tokens,
+                         flagged_count=flagged_count,
+                         unanalyzed_count=unanalyzed_count,
+                         submission_open=submission_open,
+                         token_generation_enabled=token_generation_enabled,
+                         analyzed=analyzed)
+
+@bp.route('/registration')
+@admin_required
+def registration():
+    token_generation_enabled = Settings.get_setting('token_generation_enabled', 'true') == 'true'
+    recent_tokens = Token.query.filter(Token.type != 'admin').order_by(Token.created_at.desc()).limit(10).all()
+
+    registration_url = request.host_url.rstrip('/') + url_for('auth.generate')
+
+    return render_template('admin/registration.html',
+                         token_generation_enabled=token_generation_enabled,
+                         recent_tokens=recent_tokens,
+                         registration_url=registration_url)
+
+@bp.route('/tokens')
+@admin_required
+def tokens():
+    all_tokens = Token.query.all()
+    return render_template('admin/tokens.html',
+                         tokens=all_tokens,
+                         contributor_types=CONTRIBUTOR_TYPES)
+
+@bp.route('/submissions')
+@admin_required
+def submissions():
+    category_filter = request.args.get('category', 'all')
+    flagged_only = request.args.get('flagged', 'false') == 'true'
+
+    query = Submission.query
+
+    if category_filter != 'all':
+        query = query.filter_by(category=category_filter)
+
+    if flagged_only:
+        query = query.filter_by(flagged_as_offensive=True)
+
+    all_submissions = query.order_by(Submission.timestamp.desc()).all()
+    flagged_count = Submission.query.filter_by(flagged_as_offensive=True).count()
+
+    analyzed = Submission.query.filter(Submission.category != None).count() > 0
+
+    return render_template('admin/submissions.html',
+                         submissions=all_submissions,
+                         categories=CATEGORIES,
+                         category_filter=category_filter,
+                         flagged_only=flagged_only,
+                         flagged_count=flagged_count,
+                         analyzed=analyzed)
+
+@bp.route('/dashboard')
+@admin_required
+def dashboard():
+    # Check if analyzed
+    analyzed = Submission.query.filter(Submission.category != None).count() > 0
+
+    if not analyzed:
+        flash('Please analyze submissions first', 'warning')
+        return redirect(url_for('admin.overview'))
+
+    submissions = Submission.query.filter(Submission.category != None).all()
+
+    # Contributor stats
+    contributor_stats = db.session.query(
+        Submission.contributor_type,
+        db.func.count(Submission.id)
+    ).group_by(Submission.contributor_type).all()
+
+    # Category stats
+    category_stats = db.session.query(
+        Submission.category,
+        db.func.count(Submission.id)
+    ).filter(Submission.category != None).group_by(Submission.category).all()
+
+    # Geotagged submissions
+    geotagged_submissions = Submission.query.filter(
+        Submission.latitude != None,
+        Submission.longitude != None,
+        Submission.category != None
+    ).all()
+
+    # Category breakdown by contributor type
+    breakdown = {}
+    for cat in CATEGORIES:
+        breakdown[cat] = {}
+        for ctype in CONTRIBUTOR_TYPES:
+            count = Submission.query.filter_by(
+                category=cat,
+                contributor_type=ctype['value']
+            ).count()
+            breakdown[cat][ctype['value']] = count
+
+    return render_template('admin/dashboard.html',
+                         submissions=submissions,
+                         contributor_stats=contributor_stats,
+                         category_stats=category_stats,
+                         geotagged_submissions=geotagged_submissions,
+                         categories=CATEGORIES,
+                         contributor_types=CONTRIBUTOR_TYPES,
+                         breakdown=breakdown)
+
+# API Endpoints
+
+@bp.route('/api/toggle-submissions', methods=['POST'])
+@admin_required
+def toggle_submissions():
+    current = Settings.get_setting('submission_open', 'true')
+    new_value = 'false' if current == 'true' else 'true'
+    Settings.set_setting('submission_open', new_value)
+    return jsonify({'success': True, 'submission_open': new_value == 'true'})
+
+@bp.route('/api/toggle-token-generation', methods=['POST'])
+@admin_required
+def toggle_token_generation():
+    current = Settings.get_setting('token_generation_enabled', 'true')
+    new_value = 'false' if current == 'true' else 'true'
+    Settings.set_setting('token_generation_enabled', new_value)
+    return jsonify({'success': True, 'token_generation_enabled': new_value == 'true'})
+
+@bp.route('/api/create-token', methods=['POST'])
+@admin_required
+def create_token():
+    data = request.json
+    contributor_type = data.get('type')
+    name = data.get('name', '').strip()
+
+    if not contributor_type or contributor_type not in [t['value'] for t in CONTRIBUTOR_TYPES]:
+        return jsonify({'success': False, 'error': 'Invalid contributor type'}), 400
+
+    import random
+    import string
+
+    prefix = contributor_type[:3].upper()
+    random_part = ''.join(random.choices(string.ascii_uppercase + string.digits, k=6))
+    timestamp_part = str(int(datetime.now().timestamp()))[-4:]
+    token_str = f"{prefix}-{random_part}{timestamp_part}"
+
+    final_name = name if name else f"{contributor_type.capitalize()} User"
+
+    new_token = Token(
+        token=token_str,
+        type=contributor_type,
+        name=final_name
+    )
+
+    db.session.add(new_token)
+    db.session.commit()
+
+    return jsonify({'success': True, 'token': new_token.to_dict()})
+
+@bp.route('/api/delete-token/<int:token_id>', methods=['DELETE'])
+@admin_required
+def delete_token(token_id):
+    token = Token.query.get_or_404(token_id)
+
+    if token.token == 'ADMIN123':
+        return jsonify({'success': False, 'error': 'Cannot delete admin token'}), 400
+
+    db.session.delete(token)
+    db.session.commit()
+
+    return jsonify({'success': True})
+
+@bp.route('/api/update-category/<int:submission_id>', methods=['POST'])
+@admin_required
+def update_category(submission_id):
+    submission = Submission.query.get_or_404(submission_id)
+    data = request.json
+    category = data.get('category')
+
+    # Validate category
+    if category and category not in CATEGORIES:
+        return jsonify({'success': False, 'error': 'Invalid category'}), 400
+
+    submission.category = category
+    db.session.commit()
+    return jsonify({'success': True, 'category': category})
+
+@bp.route('/api/toggle-flag/<int:submission_id>', methods=['POST'])
+@admin_required
+def toggle_flag(submission_id):
+    submission = Submission.query.get_or_404(submission_id)
+    submission.flagged_as_offensive = not submission.flagged_as_offensive
+    db.session.commit()
+    return jsonify({'success': True, 'flagged': submission.flagged_as_offensive})
+
+@bp.route('/api/delete-submission/<int:submission_id>', methods=['DELETE'])
+@admin_required
+def delete_submission(submission_id):
+    submission = Submission.query.get_or_404(submission_id)
+    db.session.delete(submission)
+    db.session.commit()
+    return jsonify({'success': True})
+
+@bp.route('/api/analyze', methods=['POST'])
+@admin_required
+def analyze_submissions():
+    data = request.json
+    analyze_all = data.get('analyze_all', False)
+
+    # Get submissions to analyze
+    if analyze_all:
+        to_analyze = Submission.query.all()
+    else:
+        to_analyze = Submission.query.filter_by(category=None).all()
+
+    if not to_analyze:
+        return jsonify({'success': False, 'error': 'No submissions to analyze'}), 400
+
+    # Get the analyzer instance
+    analyzer = get_analyzer()
+
+    success_count = 0
+    error_count = 0
+
+    for submission in to_analyze:
+        try:
+            # Use the free Hugging Face model for classification
+            category = analyzer.analyze(submission.message)
+            submission.category = category
+            success_count += 1
+
+        except Exception as e:
+            print(f"Error analyzing submission {submission.id}: {e}")
+            error_count += 1
+            continue
+
+    db.session.commit()
+
+    return jsonify({
+        'success': True,
+        'analyzed': success_count,
+        'errors': error_count
+    })
+
+@bp.route('/export/json')
+@admin_required
+def export_json():
+    data = {
+        'tokens': [t.to_dict() for t in Token.query.all()],
+        'submissions': [s.to_dict() for s in Submission.query.all()],
+        'submissionOpen': Settings.get_setting('submission_open', 'true') == 'true',
+        'tokenGenerationEnabled': Settings.get_setting('token_generation_enabled', 'true') == 'true',
+        'exportDate': datetime.utcnow().isoformat()
+    }
+
+    json_str = json.dumps(data, indent=2)
+
+    buffer = io.BytesIO()
+    buffer.write(json_str.encode('utf-8'))
+    buffer.seek(0)
+
+    return send_file(
+        buffer,
+        mimetype='application/json',
+        as_attachment=True,
+        download_name=f'participatory-planning-{datetime.now().strftime("%Y-%m-%d")}.json'
+    )
+
+@bp.route('/export/csv')
+@admin_required
+def export_csv():
+    submissions = Submission.query.all()
+
+    output = io.StringIO()
+    writer = csv.writer(output)
+
+    # Header
+    writer.writerow(['Timestamp', 'Contributor Type', 'Category', 'Message', 'Latitude', 'Longitude', 'Flagged'])
+
+    # Rows
+    for s in submissions:
+        writer.writerow([
+            s.timestamp.isoformat() if s.timestamp else '',
+            s.contributor_type,
+            s.category or 'Not analyzed',
+            s.message,
+            s.latitude or '',
+            s.longitude or '',
+            'Yes' if s.flagged_as_offensive else 'No'
+        ])
+
+    buffer = io.BytesIO()
+    buffer.write(output.getvalue().encode('utf-8'))
+    buffer.seek(0)
+
+    return send_file(
+        buffer,
+        mimetype='text/csv',
+        as_attachment=True,
+        download_name=f'contributions-{datetime.now().strftime("%Y-%m-%d")}.csv'
+    )
+
+@bp.route('/import', methods=['POST'])
+@admin_required
+def import_data():
+    if 'file' not in request.files:
+        return jsonify({'success': False, 'error': 'No file uploaded'}), 400
+
+    file = request.files['file']
+
+    if file.filename == '':
+        return jsonify({'success': False, 'error': 'No file selected'}), 400
+
+    try:
+        data = json.load(file)
+
+        # Clear existing data (except admin token)
+        Submission.query.delete()
+        Token.query.filter(Token.token != 'ADMIN123').delete()
+
+        # Import tokens
+        for token_data in data.get('tokens', []):
+            if token_data['token'] != 'ADMIN123':  # Skip admin token as it already exists
+                token = Token(
+                    token=token_data['token'],
+                    type=token_data['type'],
+                    name=token_data['name']
+                )
+                db.session.add(token)
+
+        # Import submissions
+        for sub_data in data.get('submissions', []):
+            location = sub_data.get('location')
+            submission = Submission(
+                message=sub_data['message'],
+                contributor_type=sub_data['contributorType'],
+                latitude=location['lat'] if location else None,
+                longitude=location['lng'] if location else None,
+                timestamp=datetime.fromisoformat(sub_data['timestamp']) if sub_data.get('timestamp') else datetime.utcnow(),
+                category=sub_data.get('category'),
+                flagged_as_offensive=sub_data.get('flaggedAsOffensive', False)
+            )
+            db.session.add(submission)
+
+        # Import settings
+        Settings.set_setting('submission_open', 'true' if data.get('submissionOpen', True) else 'false')
+        Settings.set_setting('token_generation_enabled', 'true' if data.get('tokenGenerationEnabled', True) else 'false')
+
+        db.session.commit()
+
+        return jsonify({'success': True})
+
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'success': False, 'error': str(e)}), 500

app/routes/auth.py

@@ -0,0 +1,90 @@
+from flask import Blueprint, render_template, request, redirect, url_for, session, flash
+from app.models.models import Token, Settings
+from app import db
+import random
+import string
+from datetime import datetime
+
+bp = Blueprint('auth', __name__)
+
+CONTRIBUTOR_TYPES = [
+    {'value': 'government', 'label': 'Government Officer', 'description': 'Public sector representatives'},
+    {'value': 'community', 'label': 'Community Member', 'description': 'Local residents and community leaders'},
+    {'value': 'industry', 'label': 'Industry Representative', 'description': 'Business and industry stakeholders'},
+    {'value': 'ngo', 'label': 'NGO/Non-Profit', 'description': 'Civil society organizations'},
+    {'value': 'academic', 'label': 'Academic/Researcher', 'description': 'Universities and research institutions'},
+    {'value': 'other', 'label': 'Other Stakeholder', 'description': 'Other interested parties'}
+]
+
+def generate_token(contributor_type):
+    prefix = contributor_type[:3].upper()
+    random_part = ''.join(random.choices(string.ascii_uppercase + string.digits, k=6))
+    timestamp_part = str(int(datetime.now().timestamp()))[-4:]
+    return f"{prefix}-{random_part}{timestamp_part}"
+
+@bp.route('/')
+def index():
+    return redirect(url_for('auth.login'))
+
+@bp.route('/login', methods=['GET', 'POST'])
+def login():
+    if request.method == 'POST':
+        token_str = request.form.get('token')
+        token = Token.query.filter_by(token=token_str).first()
+
+        if token:
+            session['token'] = token.token
+            session['type'] = token.type
+
+            if token.type == 'admin':
+                return redirect(url_for('admin.overview'))
+            else:
+                return redirect(url_for('submissions.submit'))
+        else:
+            flash('Invalid token', 'error')
+
+    return render_template('login.html')
+
+@bp.route('/generate', methods=['GET', 'POST'])
+def generate():
+    token_generation_enabled = Settings.get_setting('token_generation_enabled', 'true') == 'true'
+
+    if request.method == 'POST':
+        if not token_generation_enabled:
+            flash('Token generation is currently disabled', 'error')
+            return redirect(url_for('auth.generate'))
+
+        contributor_type = request.form.get('type')
+        user_name = request.form.get('name', '').strip()
+
+        if not contributor_type or contributor_type not in [t['value'] for t in CONTRIBUTOR_TYPES]:
+            flash('Please select a valid role', 'error')
+            return redirect(url_for('auth.generate'))
+
+        # Generate token
+        from datetime import datetime
+        token_str = generate_token(contributor_type)
+        name = user_name if user_name else f"{contributor_type.capitalize()} User"
+
+        new_token = Token(
+            token=token_str,
+            type=contributor_type,
+            name=name
+        )
+
+        db.session.add(new_token)
+        db.session.commit()
+
+        return render_template('generate.html',
+                             contributor_types=CONTRIBUTOR_TYPES,
+                             token_generation_enabled=token_generation_enabled,
+                             generated_token=token_str)
+
+    return render_template('generate.html',
+                         contributor_types=CONTRIBUTOR_TYPES,
+                         token_generation_enabled=token_generation_enabled)
+
+@bp.route('/logout')
+def logout():
+    session.clear()
+    return redirect(url_for('auth.login'))

app/routes/submissions.py

@@ -0,0 +1,63 @@
+from flask import Blueprint, render_template, request, redirect, url_for, session, flash, jsonify
+from app.models.models import Submission, Settings
+from app import db
+from functools import wraps
+
+bp = Blueprint('submissions', __name__)
+
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'token' not in session:
+            return redirect(url_for('auth.login'))
+        return f(*args, **kwargs)
+    return decorated_function
+
+def contributor_only(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'token' not in session or session.get('type') == 'admin':
+            return redirect(url_for('auth.login'))
+        return f(*args, **kwargs)
+    return decorated_function
+
+@bp.route('/submit', methods=['GET', 'POST'])
+@login_required
+@contributor_only
+def submit():
+    submission_open = Settings.get_setting('submission_open', 'true') == 'true'
+    contributor_type = session.get('type')
+
+    if request.method == 'POST':
+        if not submission_open:
+            flash('Submission period is currently closed.', 'error')
+            return redirect(url_for('submissions.submit'))
+
+        message = request.form.get('message', '').strip()
+        latitude = request.form.get('latitude')
+        longitude = request.form.get('longitude')
+
+        if not message:
+            flash('Please enter a message', 'error')
+            return redirect(url_for('submissions.submit'))
+
+        new_submission = Submission(
+            message=message,
+            contributor_type=contributor_type,
+            latitude=float(latitude) if latitude else None,
+            longitude=float(longitude) if longitude else None
+        )
+
+        db.session.add(new_submission)
+        db.session.commit()
+
+        flash('Contribution submitted successfully!', 'success')
+        return redirect(url_for('submissions.submit'))
+
+    # Get submission count for this user
+    submission_count = Submission.query.filter_by(contributor_type=contributor_type).count()
+
+    return render_template('submit.html',
+                         submission_open=submission_open,
+                         contributor_type=contributor_type,
+                         submission_count=submission_count)

app/templates/admin/base.html

@@ -0,0 +1,60 @@
+{% extends "base.html" %}
+
+{% block content %}
+<div class="min-vh-100 bg-light">
+    <nav class="navbar navbar-expand-lg navbar-dark bg-dark shadow-sm">
+        <div class="container-fluid">
+            <a class="navbar-brand" href="{{ url_for('admin.overview') }}">
+                <i class="bi bi-speedometer2"></i> Admin Dashboard
+            </a>
+            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav">
+                <span class="navbar-toggler-icon"></span>
+            </button>
+            <div class="collapse navbar-collapse" id="navbarNav">
+                <ul class="navbar-nav me-auto">
+                    <li class="nav-item">
+                        <a class="nav-link {% if request.endpoint == 'admin.overview' %}active{% endif %}"
+                           href="{{ url_for('admin.overview') }}">
+                            <i class="bi bi-bar-chart-fill"></i> Overview
+                        </a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link {% if request.endpoint == 'admin.registration' %}active{% endif %}"
+                           href="{{ url_for('admin.registration') }}">
+                            <i class="bi bi-key-fill"></i> Registration
+                        </a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link {% if request.endpoint == 'admin.tokens' %}active{% endif %}"
+                           href="{{ url_for('admin.tokens') }}">
+                            <i class="bi bi-people-fill"></i> Tokens ({{ token_count if token_count is defined else '...' }})
+                        </a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link {% if request.endpoint == 'admin.submissions' %}active{% endif %}"
+                           href="{{ url_for('admin.submissions') }}">
+                            <i class="bi bi-chat-square-text-fill"></i> Submissions
+                        </a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link {% if request.endpoint == 'admin.dashboard' %}active{% endif %}"
+                           href="{{ url_for('admin.dashboard') }}">
+                            <i class="bi bi-graph-up"></i> Analytics
+                        </a>
+                    </li>
+                </ul>
+                <div class="d-flex gap-2">
+                    <a href="{{ url_for('admin.export_json') }}" class="btn btn-success btn-sm">
+                        <i class="bi bi-download"></i> Save Session
+                    </a>
+                    <a href="{{ url_for('auth.logout') }}" class="btn btn-outline-light btn-sm">Logout</a>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <div class="container-fluid py-4">
+        {% block admin_content %}{% endblock %}
+    </div>
+</div>
+{% endblock %}

app/templates/admin/dashboard.html

@@ -0,0 +1,223 @@
+{% extends "admin/base.html" %}
+
+{% block title %}Analytics Dashboard{% endblock %}
+
+{% set get_category_color = {
+    'Vision': '#3b82f6',
+    'Problem': '#ef4444',
+    'Objectives': '#10b981',
+    'Directives': '#f59e0b',
+    'Values': '#8b5cf6',
+    'Actions': '#ec4899'
+}.get %}
+
+{% block admin_content %}
+<h2 class="mb-4">Analytics Dashboard</h2>
+
+<div class="row g-4 mb-4">
+    <div class="col-lg-6">
+        <div class="card shadow-sm h-100">
+            <div class="card-body">
+                <h5 class="card-title">By Contributor Type</h5>
+                <canvas id="contributorChart"></canvas>
+            </div>
+        </div>
+    </div>
+
+    <div class="col-lg-6">
+        <div class="card shadow-sm h-100">
+            <div class="card-body">
+                <h5 class="card-title">By Category</h5>
+                <canvas id="categoryChart"></canvas>
+            </div>
+        </div>
+    </div>
+</div>
+
+{% if geotagged_submissions %}
+<div class="card shadow-sm mb-4">
+    <div class="card-body">
+        <h5 class="card-title mb-3">
+            Geographic Distribution ({{ geotagged_submissions|length }} geotagged)
+        </h5>
+        <div id="dashboardMap" class="dashboard-map-container border rounded"></div>
+    </div>
+</div>
+{% endif %}
+
+<div class="card shadow-sm mb-4">
+    <div class="card-body">
+        <h5 class="card-title mb-4">Contributions by Category</h5>
+        {% for category in categories %}
+            {% set category_submissions = submissions|selectattr('category', 'equalto', category)|list %}
+            {% if category_submissions %}
+            <div class="mb-4">
+                <h6 class="border-bottom pb-2" style="border-color: {{ get_category_color(category) }}!important; border-width: 2px!important;">
+                    <span class="badge" style="background-color: {{ get_category_color(category) }};">{{ category }}</span>
+                    <small class="text-muted">({{ category_submissions|length }} contribution{{ 's' if category_submissions|length != 1 else '' }})</small>
+                </h6>
+                {% for sub in category_submissions %}
+                <div class="border-start border-3 ps-3 mb-3" style="border-color: {{ get_category_color(category) }}!important;">
+                    <div class="d-flex justify-content-between align-items-start mb-1">
+                        <small class="text-muted text-capitalize">{{ sub.contributor_type }}</small>
+                        <small class="text-muted">{{ sub.timestamp.strftime('%Y-%m-%d') if sub.timestamp else '' }}</small>
+                    </div>
+                    <p class="mb-0">{{ sub.message }}</p>
+                    {% if sub.latitude and sub.longitude %}
+                    <p class="text-muted small mb-0 mt-1">
+                        <i class="bi bi-geo-alt-fill"></i> {{ sub.latitude|round(4) }}, {{ sub.longitude|round(4) }}
+                    </p>
+                    {% endif %}
+                </div>
+                {% endfor %}
+            </div>
+            {% endif %}
+        {% endfor %}
+    </div>
+</div>
+
+<div class="card shadow-sm">
+    <div class="card-body">
+        <h5 class="card-title mb-3">Category Breakdown by Contributor Type</h5>
+        <div class="table-responsive">
+            <table class="table table-bordered">
+                <thead>
+                    <tr>
+                        <th>Category</th>
+                        {% for type in contributor_types %}
+                        <th class="text-center">{{ type.label }}</th>
+                        {% endfor %}
+                    </tr>
+                </thead>
+                <tbody>
+                    {% for category in categories %}
+                    <tr>
+                        <td class="fw-bold">{{ category }}</td>
+                        {% for type in contributor_types %}
+                        <td class="text-center">
+                            {% set count = breakdown[category][type.value] %}
+                            {{ count if count > 0 else '-' }}
+                        </td>
+                        {% endfor %}
+                    </tr>
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+    </div>
+</div>
+
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    // Category colors
+    const categoryColors = {
+        'Vision': '#3b82f6',
+        'Problem': '#ef4444',
+        'Objectives': '#10b981',
+        'Directives': '#f59e0b',
+        'Values': '#8b5cf6',
+        'Actions': '#ec4899'
+    };
+
+    // Contributor Chart
+    const contributorData = {
+        labels: [{% for stat in contributor_stats %}'{{ stat[0] }}'{% if not loop.last %}, {% endif %}{% endfor %}],
+        datasets: [{
+            data: [{% for stat in contributor_stats %}{{ stat[1] }}{% if not loop.last %}, {% endif %}{% endfor %}],
+            backgroundColor: ['#3b82f6', '#10b981', '#f59e0b', '#ef4444', '#8b5cf6', '#ec4899']
+        }]
+    };
+
+    new Chart(document.getElementById('contributorChart'), {
+        type: 'pie',
+        data: contributorData,
+        options: {
+            responsive: true,
+            plugins: {
+                legend: {
+                    position: 'bottom'
+                }
+            }
+        }
+    });
+
+    // Category Chart
+    const categoryData = {
+        labels: [{% for stat in category_stats %}'{{ stat[0] }}'{% if not loop.last %}, {% endif %}{% endfor %}],
+        datasets: [{
+            label: 'Submissions',
+            data: [{% for stat in category_stats %}{{ stat[1] }}{% if not loop.last %}, {% endif %}{% endfor %}],
+            backgroundColor: [{% for stat in category_stats %}categoryColors['{{ stat[0] }}']{% if not loop.last %}, {% endif %}{% endfor %}]
+        }]
+    };
+
+    new Chart(document.getElementById('categoryChart'), {
+        type: 'bar',
+        data: categoryData,
+        options: {
+            responsive: true,
+            plugins: {
+                legend: {
+                    display: false
+                }
+            },
+            scales: {
+                y: {
+                    beginAtZero: true,
+                    ticks: {
+                        stepSize: 1
+                    }
+                }
+            }
+        }
+    });
+
+    {% if geotagged_submissions %}
+    // Dashboard Map
+    const dashMap = L.map('dashboardMap').setView([0, 0], 2);
+
+    L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+        attribution: '© OpenStreetMap'
+    }).addTo(dashMap);
+
+    const bounds = [];
+
+    {% for sub in geotagged_submissions %}
+    {
+        const color = categoryColors['{{ sub.category }}'] || '#6b7280';
+        const customIcon = L.divIcon({
+            className: 'custom-marker',
+            html: `<div style="background-color: ${color}; width: 20px; height: 20px; border-radius: 50%; border: 2px solid white;"></div>`,
+            iconSize: [20, 20]
+        });
+
+        const marker = L.marker([{{ sub.latitude }}, {{ sub.longitude }}], { icon: customIcon })
+            .addTo(dashMap)
+            .bindPopup(`
+                <div>
+                    <div style="color: ${color}; font-weight: bold;">{{ sub.category }}</div>
+                    <div class="text-muted small text-capitalize">{{ sub.contributor_type }}</div>
+                    <div class="mt-1">{{ sub.message[:100] }}{{ '...' if sub.message|length > 100 else '' }}</div>
+                </div>
+            `);
+
+        bounds.push([{{ sub.latitude }}, {{ sub.longitude }}]);
+    }
+    {% endfor %}
+
+    if (bounds.length > 0) {
+        dashMap.fitBounds(bounds, { padding: [50, 50] });
+    }
+
+    setTimeout(() => dashMap.invalidateSize(), 100);
+    {% endif %}
+});
+</script>
+
+<style>
+.custom-marker {
+    background: none;
+    border: none;
+}
+</style>
+{% endblock %}

app/templates/admin/overview.html

@@ -0,0 +1,197 @@
+{% extends "admin/base.html" %}
+
+{% block title %}Overview - Admin Dashboard{% endblock %}
+
+{% block admin_content %}
+<h2 class="mb-4">Overview</h2>
+
+<div class="row g-4 mb-4">
+    <div class="col-md-4">
+        <div class="card shadow-sm card-hover h-100">
+            <div class="card-body">
+                <div class="d-flex justify-content-between align-items-center">
+                    <div>
+                        <h6 class="text-muted mb-1">Total Submissions</h6>
+                        <h2 class="mb-0">{{ total_submissions }}</h2>
+                        {% if flagged_count > 0 %}
+                        <small class="text-danger">{{ flagged_count }} flagged</small>
+                        {% endif %}
+                        {% if unanalyzed_count > 0 %}
+                        <small class="text-warning d-block">{{ unanalyzed_count }} unanalyzed</small>
+                        {% endif %}
+                    </div>
+                    <i class="bi bi-chat-square-text-fill text-primary" style="font-size: 3rem;"></i>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div class="col-md-4">
+        <div class="card shadow-sm card-hover h-100">
+            <div class="card-body">
+                <div class="d-flex justify-content-between align-items-center">
+                    <div>
+                        <h6 class="text-muted mb-1">Registered Users</h6>
+                        <h2 class="mb-0">{{ total_tokens }}</h2>
+                    </div>
+                    <i class="bi bi-people-fill text-success" style="font-size: 3rem;"></i>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div class="col-md-4">
+        <div class="card shadow-sm card-hover h-100">
+            <div class="card-body">
+                <div class="d-flex justify-content-between align-items-center">
+                    <div>
+                        <h6 class="text-muted mb-1">Analysis Status</h6>
+                        <h2 class="mb-0">{{ 'Complete' if analyzed and unanalyzed_count == 0 else 'Partial' if analyzed else 'Pending' }}</h2>
+                        {% if analyzed and unanalyzed_count > 0 %}
+                        <small class="text-warning">{{ unanalyzed_count }} new</small>
+                        {% endif %}
+                    </div>
+                    <i class="bi bi-gear-fill text-info" style="font-size: 3rem;"></i>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<div class="card shadow-sm mb-4">
+    <div class="card-body">
+        <h5 class="card-title mb-3">Controls</h5>
+        <div class="d-flex gap-2 flex-wrap">
+            <button class="btn btn-{{ 'danger' if submission_open else 'success' }}" onclick="toggleSubmissions()">
+                {{ 'Close Submissions' if submission_open else 'Open Submissions' }}
+            </button>
+
+            <button class="btn btn-{{ 'warning' if token_generation_enabled else 'success' }}" onclick="toggleTokenGeneration()">
+                {{ 'Disable Token Generation' if token_generation_enabled else 'Enable Token Generation' }}
+            </button>
+
+            {% if total_submissions > 0 and unanalyzed_count > 0 %}
+            <button class="btn btn-primary" onclick="analyzeSubmissions(false)">
+                <i class="bi bi-cpu-fill"></i> Analyze {{ unanalyzed_count }} {{ 'Submission' if unanalyzed_count == 1 else 'Submissions' }}
+            </button>
+            {% endif %}
+
+            {% if analyzed and total_submissions > 0 and unanalyzed_count == 0 %}
+            <button class="btn btn-secondary" onclick="analyzeSubmissions(true)">
+                <i class="bi bi-arrow-clockwise"></i> Re-analyze All
+            </button>
+            {% endif %}
+
+            {% if analyzed %}
+            <a href="{{ url_for('admin.export_csv') }}" class="btn btn-info">
+                <i class="bi bi-file-earmark-spreadsheet"></i> Export CSV
+            </a>
+            {% endif %}
+
+            <button class="btn btn-warning" onclick="document.getElementById('importFile').click()">
+                <i class="bi bi-upload"></i> Import Session
+            </button>
+            <input type="file" id="importFile" accept=".json" style="display: none;" onchange="importData(this)">
+        </div>
+
+        {% if total_submissions > 0 and unanalyzed_count > 0 %}
+        <div class="alert alert-info mt-3 mb-0">
+            <i class="bi bi-info-circle-fill"></i>
+            <strong>Note:</strong> {{ unanalyzed_count }} submission{{ 's' if unanalyzed_count != 1 else '' }}
+            {{ 'are' if unanalyzed_count != 1 else 'is' }} waiting to be analyzed.
+            {% if analyzed %} Click "Analyze Submissions" to analyze only the unanalyzed submissions.{% endif %}
+        </div>
+        {% endif %}
+    </div>
+</div>
+
+<script>
+function toggleSubmissions() {
+    fetch('{{ url_for("admin.toggle_submissions") }}', {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'}
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            location.reload();
+        }
+    });
+}
+
+function toggleTokenGeneration() {
+    fetch('{{ url_for("admin.toggle_token_generation") }}', {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'}
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            location.reload();
+        }
+    });
+}
+
+function analyzeSubmissions(analyzeAll) {
+    if (confirm(`Are you sure you want to ${analyzeAll ? 're-analyze all' : 'analyze'} submissions? This may take a few minutes.`)) {
+        const btn = event.target;
+        btn.disabled = true;
+        btn.innerHTML = '<i class="bi bi-hourglass-split"></i> Analyzing...';
+
+        fetch('{{ url_for("admin.analyze_submissions") }}', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({analyze_all: analyzeAll})
+        })
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                alert(`Successfully analyzed ${data.analyzed} submission${data.analyzed !== 1 ? 's' : ''}!${data.errors > 0 ? ' ' + data.errors + ' failed.' : ''}`);
+                location.reload();
+            } else {
+                alert('Error: ' + data.error);
+                btn.disabled = false;
+                btn.innerHTML = analyzeAll ? 'Re-analyze All' : 'Analyze Submissions';
+            }
+        })
+        .catch(error => {
+            alert('Error analyzing submissions');
+            btn.disabled = false;
+            btn.innerHTML = analyzeAll ? 'Re-analyze All' : 'Analyze Submissions';
+        });
+    }
+}
+
+function importData(input) {
+    if (!input.files || !input.files[0]) return;
+
+    if (!confirm('WARNING: This will replace ALL current data (except admin token) with the imported data. Are you sure?')) {
+        input.value = '';
+        return;
+    }
+
+    const formData = new FormData();
+    formData.append('file', input.files[0]);
+
+    fetch('{{ url_for("admin.import_data") }}', {
+        method: 'POST',
+        body: formData
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            alert('Session data imported successfully!');
+            location.reload();
+        } else {
+            alert('Error importing data: ' + (data.error || 'Unknown error'));
+        }
+    })
+    .catch(error => {
+        alert('Error importing data');
+    })
+    .finally(() => {
+        input.value = '';
+    });
+}
+</script>
+{% endblock %}

app/templates/admin/registration.html

@@ -0,0 +1,75 @@
+{% extends "admin/base.html" %}
+
+{% block title %}Registration - Admin Dashboard{% endblock %}
+
+{% block admin_content %}
+<h2 class="mb-4">Participant Registration</h2>
+
+<div class="card shadow-sm mb-4">
+    <div class="card-body">
+        <div class="alert alert-primary">
+            <div class="d-flex align-items-start gap-3">
+                <i class="bi bi-link-45deg" style="font-size: 2rem;"></i>
+                <div class="flex-grow-1">
+                    <h5 class="mb-2">Share this link with participants:</h5>
+                    <div class="bg-white rounded p-3 mb-3">
+                        <code id="registrationUrl">{{ registration_url }}</code>
+                    </div>
+                    <button class="btn btn-primary" onclick="copyUrl()">
+                        <i class="bi bi-clipboard"></i> Copy Registration Link
+                    </button>
+                </div>
+            </div>
+        </div>
+
+        <div class="alert alert-{{ 'success' if token_generation_enabled else 'danger' }} mb-3">
+            <strong>Token Generation: {{ 'ENABLED ✓' if token_generation_enabled else 'DISABLED ✗' }}</strong>
+            <p class="mb-0 mt-1">
+                {{ 'Participants can generate their own tokens using the link above.' if token_generation_enabled
+                   else 'Participants cannot generate tokens. You must create tokens manually in the Tokens tab.' }}
+            </p>
+        </div>
+
+        <div class="bg-light rounded p-3">
+            <h6 class="mb-2">How it works:</h6>
+            <ol class="mb-0">
+                <li>Share the registration link with participants (via email, chat, or display it on screen)</li>
+                <li>Each participant selects their role and enters their name</li>
+                <li>They receive a unique access token instantly</li>
+                <li>Participants use their token to login and submit contributions</li>
+            </ol>
+        </div>
+    </div>
+</div>
+
+<div class="card shadow-sm">
+    <div class="card-body">
+        <h5 class="card-title mb-3">Recent Registrations</h5>
+        {% if recent_tokens %}
+        <div class="list-group">
+            {% for token in recent_tokens %}
+            <div class="list-group-item d-flex justify-content-between align-items-center">
+                <div>
+                    <strong>{{ token.name }}</strong>
+                    <span class="text-muted mx-2">•</span>
+                    <span class="text-muted text-capitalize">{{ token.type }}</span>
+                </div>
+                <code class="text-muted">{{ token.token }}</code>
+            </div>
+            {% endfor %}
+        </div>
+        {% else %}
+        <p class="text-muted mb-0">No registrations yet.</p>
+        {% endif %}
+    </div>
+</div>
+
+<script>
+function copyUrl() {
+    const url = document.getElementById('registrationUrl').textContent;
+    navigator.clipboard.writeText(url).then(() => {
+        alert('Registration link copied to clipboard!');
+    });
+}
+</script>
+{% endblock %}

app/templates/admin/submissions.html

@@ -0,0 +1,176 @@
+{% extends "admin/base.html" %}
+
+{% block title %}Submissions - Admin Dashboard{% endblock %}
+
+{% block admin_content %}
+<div class="d-flex justify-content-between align-items-center mb-4 flex-wrap gap-3">
+    <h2>
+        All Submissions ({{ submissions|length }})
+        {% if flagged_count > 0 %}
+        <span class="badge bg-danger">{{ flagged_count }} flagged</span>
+        {% endif %}
+    </h2>
+
+    <div class="d-flex gap-2 align-items-center">
+        {% if analyzed %}
+        <select class="form-select" onchange="filterCategory(this.value)">
+            <option value="all" {% if category_filter == 'all' %}selected{% endif %}>All Categories</option>
+            {% for cat in categories %}
+            <option value="{{ cat }}" {% if category_filter == cat %}selected{% endif %}>{{ cat }}</option>
+            {% endfor %}
+        </select>
+        {% endif %}
+
+        <div class="form-check">
+            <input class="form-check-input" type="checkbox" id="flaggedOnly"
+                   {% if flagged_only %}checked{% endif %} onchange="toggleFlagged(this.checked)">
+            <label class="form-check-label" for="flaggedOnly">
+                <i class="bi bi-flag-fill text-danger"></i> Flagged Only
+            </label>
+        </div>
+    </div>
+</div>
+
+{% if category_filter != 'all' or flagged_only %}
+<div class="alert alert-info">
+    Showing {{ submissions|length }} submission{{ 's' if submissions|length != 1 else '' }}
+    {% if category_filter != 'all' %} in category: {{ category_filter }}{% endif %}
+    {% if flagged_only %} (flagged only){% endif %}
+</div>
+{% endif %}
+
+<div class="row g-3">
+    {% if submissions %}
+        {% for sub in submissions %}
+        <div class="col-12">
+            <div class="card shadow-sm {% if sub.flagged_as_offensive %}border-danger{% endif %}">
+                <div class="card-body">
+                    <div class="d-flex justify-content-between align-items-start mb-2">
+                        <div class="d-flex gap-2 flex-wrap align-items-center">
+                            <span class="badge bg-secondary text-capitalize">{{ sub.contributor_type }}</span>
+                            <select class="form-select form-select-sm" style="width: auto;"
+                                    onchange="updateCategory({{ sub.id }}, this.value)">
+                                <option value="">Not categorized</option>
+                                {% for cat in categories %}
+                                <option value="{{ cat }}" {% if sub.category == cat %}selected{% endif %}>{{ cat }}</option>
+                                {% endfor %}
+                            </select>
+                            {% if sub.flagged_as_offensive %}
+                            <span class="badge bg-danger">
+                                <i class="bi bi-exclamation-triangle-fill"></i> Flagged as Offensive
+                            </span>
+                            {% endif %}
+                        </div>
+                        <small class="text-muted">{{ sub.timestamp.strftime('%Y-%m-%d %H:%M') if sub.timestamp else '' }}</small>
+                    </div>
+
+                    <p class="mb-3">{{ sub.message }}</p>
+
+                    {% if sub.latitude and sub.longitude %}
+                    <p class="text-muted small mb-3">
+                        <i class="bi bi-geo-alt-fill"></i>
+                        {{ sub.latitude|round(6) }}, {{ sub.longitude|round(6) }}
+                    </p>
+                    {% endif %}
+
+                    <div class="d-flex gap-2 pt-3 border-top">
+                        <button class="btn btn-sm btn-{{ 'success' if sub.flagged_as_offensive else 'warning' }}"
+                                onclick="toggleFlag({{ sub.id }})">
+                            <i class="bi bi-flag-fill"></i>
+                            {{ 'Unflag' if sub.flagged_as_offensive else 'Flag as Offensive' }}
+                        </button>
+                        <button class="btn btn-sm btn-danger" onclick="deleteSubmission({{ sub.id }})">
+                            <i class="bi bi-trash"></i> Delete
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </div>
+        {% endfor %}
+    {% else %}
+    <div class="col-12">
+        <div class="text-center py-5 text-muted">
+            <i class="bi bi-chat-square-text" style="font-size: 4rem;"></i>
+            <p class="mt-3">
+                {% if flagged_only %}
+                    No flagged submissions
+                {% elif category_filter == 'all' %}
+                    No submissions yet
+                {% else %}
+                    No submissions in category: {{ category_filter }}
+                {% endif %}
+            </p>
+        </div>
+    </div>
+    {% endif %}
+</div>
+
+<script>
+function filterCategory(category) {
+    const url = new URL(window.location);
+    url.searchParams.set('category', category);
+    window.location = url;
+}
+
+function toggleFlagged(checked) {
+    const url = new URL(window.location);
+    url.searchParams.set('flagged', checked ? 'true' : 'false');
+    window.location = url;
+}
+
+function updateCategory(submissionId, category) {
+    fetch(`{{ url_for("admin.update_category", submission_id=0) }}`.replace('/0', `/${submissionId}`), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ category: category || null })
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            // Show success feedback
+            const select = event.target;
+            const originalBg = select.style.backgroundColor;
+            select.style.backgroundColor = '#d1fae5';
+            setTimeout(() => {
+                select.style.backgroundColor = originalBg;
+            }, 500);
+        } else {
+            alert('Failed to update category');
+            location.reload();
+        }
+    })
+    .catch(() => {
+        alert('Error updating category');
+        location.reload();
+    });
+}
+
+function toggleFlag(submissionId) {
+    fetch(`{{ url_for("admin.toggle_flag", submission_id=0) }}`.replace('/0', `/${submissionId}`), {
+        method: 'POST'
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            location.reload();
+        }
+    });
+}
+
+function deleteSubmission(submissionId) {
+    if (confirm('Are you sure you want to permanently delete this submission?')) {
+        fetch(`{{ url_for("admin.delete_submission", submission_id=0) }}`.replace('/0', `/${submissionId}`), {
+            method: 'DELETE'
+        })
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                location.reload();
+            }
+        });
+    }
+}
+</script>
+{% endblock %}

app/templates/admin/tokens.html

@@ -0,0 +1,92 @@
+{% extends "admin/base.html" %}
+
+{% block title %}Tokens - Admin Dashboard{% endblock %}
+
+{% block admin_content %}
+<div class="d-flex justify-content-between align-items-center mb-4">
+    <h2>All Access Tokens</h2>
+    <div class="dropdown">
+        <button class="btn btn-primary dropdown-toggle" type="button" data-bs-toggle="dropdown">
+            <i class="bi bi-plus-circle"></i> Create Token Manually
+        </button>
+        <ul class="dropdown-menu">
+            {% for type in contributor_types %}
+            <li><a class="dropdown-menu-item" href="#" onclick="createToken('{{ type.value }}', '{{ type.label }}'); return false;">
+                {{ type.label }}
+            </a></li>
+            {% endfor %}
+        </ul>
+    </div>
+</div>
+
+<div class="card shadow-sm">
+    <div class="card-body">
+        <div class="table-responsive">
+            <table class="table table-hover">
+                <thead>
+                    <tr>
+                        <th>Token</th>
+                        <th>Type</th>
+                        <th>Name</th>
+                        <th>Created</th>
+                        <th class="text-end">Actions</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {% for token in tokens %}
+                    <tr>
+                        <td><code>{{ token.token }}</code></td>
+                        <td class="text-capitalize">{{ token.type }}</td>
+                        <td>{{ token.name }}</td>
+                        <td>{{ token.created_at.strftime('%Y-%m-%d') if token.created_at else '-' }}</td>
+                        <td class="text-end">
+                            {% if token.token != 'ADMIN123' %}
+                            <button class="btn btn-sm btn-outline-danger" onclick="deleteToken({{ token.id }})">
+                                <i class="bi bi-trash"></i>
+                            </button>
+                            {% endif %}
+                        </td>
+                    </tr>
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+    </div>
+</div>
+
+<script>
+function createToken(type, label) {
+    const name = prompt(`Enter user name for ${label} (optional - leave blank for default):`);
+
+    fetch('{{ url_for("admin.create_token") }}', {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({type: type, name: name || ''})
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            location.reload();
+        } else {
+            alert('Error: ' + data.error);
+        }
+    });
+}
+
+function deleteToken(tokenId) {
+    if (confirm('Are you sure you want to delete this token?')) {
+        fetch(`{{ url_for("admin.delete_token", token_id=0) }}`.replace('/0', `/${tokenId}`), {
+            method: 'DELETE'
+        })
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                location.reload();
+            } else {
+                alert('Error: ' + data.error);
+            }
+        });
+    }
+}
+</script>
+{% endblock %}

app/templates/base.html

@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% block title %}Participatory Planning{% endblock %}</title>
+    <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.9.4/leaflet.min.css" />
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/font/bootstrap-icons.css">
+    {% block extra_css %}{% endblock %}
+    <style>
+        .gradient-bg {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        }
+        .card-hover:hover {
+            transform: translateY(-5px);
+            transition: transform 0.3s ease;
+        }
+        .map-container {
+            height: 400px;
+            border-radius: 0.5rem;
+        }
+        .dashboard-map-container {
+            height: 500px;
+            border-radius: 0.5rem;
+        }
+    </style>
+</head>
+<body>
+    {% with messages = get_flashed_messages(with_categories=true) %}
+        {% if messages %}
+            <div class="position-fixed top-0 end-0 p-3" style="z-index: 9999">
+                {% for category, message in messages %}
+                    <div class="alert alert-{{ 'danger' if category == 'error' else category }} alert-dismissible fade show" role="alert">
+                        {{ message }}
+                        <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
+                    </div>
+                {% endfor %}
+            </div>
+        {% endif %}
+    {% endwith %}
+
+    {% block content %}{% endblock %}
+
+    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.9.4/leaflet.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/chart.umd.min.js"></script>
+    {% block extra_js %}{% endblock %}
+</body>
+</html>

app/templates/generate.html

@@ -0,0 +1,100 @@
+{% extends "base.html" %}
+
+{% block title %}Generate Token - Participatory Planning{% endblock %}
+
+{% block content %}
+<div class="min-vh-100 gradient-bg d-flex align-items-center justify-content-center p-4">
+    <div class="card shadow-lg" style="max-width: 800px; width: 100%;">
+        <div class="card-body p-5">
+            <div class="text-center mb-4">
+                <i class="bi bi-key-fill text-success" style="font-size: 4rem;"></i>
+                <h1 class="h3 mt-3 mb-2">Get Your Access Token</h1>
+                <p class="text-muted">Generate a unique token to participate in the planning session</p>
+            </div>
+
+            {% if not token_generation_enabled %}
+            <div class="alert alert-warning">
+                <i class="bi bi-exclamation-triangle-fill"></i>
+                Token generation is currently disabled by the administrator.
+            </div>
+            {% endif %}
+
+            {% if generated_token %}
+            <div class="alert alert-success">
+                <div class="text-center">
+                    <i class="bi bi-check-circle-fill" style="font-size: 3rem;"></i>
+                    <h4 class="mt-3">Token Generated Successfully!</h4>
+
+                    <div class="bg-white rounded p-3 my-3">
+                        <p class="text-muted mb-2">Your Access Token:</p>
+                        <div class="d-flex align-items-center justify-content-center gap-2">
+                            <code class="fs-3 text-success" id="generatedToken">{{ generated_token }}</code>
+                            <button type="button" class="btn btn-primary" onclick="copyToken()">
+                                <i class="bi bi-clipboard"></i> Copy
+                            </button>
+                        </div>
+                    </div>
+
+                    <div class="alert alert-warning">
+                        <strong>Important:</strong> Save this token! You'll need it to login and submit your contributions.
+                    </div>
+
+                    <a href="{{ url_for('auth.login') }}" class="btn btn-primary btn-lg mt-3">
+                        Continue to Login
+                    </a>
+                </div>
+            </div>
+            {% else %}
+            <form method="POST">
+                <div class="mb-4">
+                    <label for="name" class="form-label">Your Name (Optional)</label>
+                    <input type="text" class="form-control" id="name" name="name"
+                           placeholder="Enter your name (leave blank for default)"
+                           {% if not token_generation_enabled %}disabled{% endif %}>
+                </div>
+
+                <div class="mb-4">
+                    <label class="form-label">Select Your Role</label>
+                    <div class="row g-3">
+                        {% for type in contributor_types %}
+                        <div class="col-md-6">
+                            <div class="form-check">
+                                <input class="form-check-input" type="radio" name="type"
+                                       id="type_{{ type.value }}" value="{{ type.value }}"
+                                       {% if not token_generation_enabled %}disabled{% endif %} required>
+                                <label class="form-check-label" for="type_{{ type.value }}">
+                                    <strong>{{ type.label }}</strong>
+                                    <br>
+                                    <small class="text-muted">{{ type.description }}</small>
+                                </label>
+                            </div>
+                        </div>
+                        {% endfor %}
+                    </div>
+                </div>
+
+                <button type="submit" class="btn btn-success btn-lg w-100"
+                        {% if not token_generation_enabled %}disabled{% endif %}>
+                    Generate My Token
+                </button>
+            </form>
+
+            <div class="mt-4 pt-4 border-top text-center">
+                <a href="{{ url_for('auth.login') }}" class="text-decoration-none">
+                    Already have a token? Login here
+                </a>
+            </div>
+            {% endif %}
+        </div>
+    </div>
+</div>
+
+<script>
+function copyToken() {
+    const token = document.getElementById('generatedToken').textContent;
+    navigator.clipboard.writeText(token).then(() => {
+        alert('Token copied to clipboard!');
+    });
+}
+</script>
+{% endblock %}

app/templates/login.html

@@ -0,0 +1,33 @@
+{% extends "base.html" %}
+
+{% block title %}Login - Participatory Planning{% endblock %}
+
+{% block content %}
+<div class="min-vh-100 gradient-bg d-flex align-items-center justify-content-center p-4">
+    <div class="card shadow-lg" style="max-width: 500px; width: 100%;">
+        <div class="card-body p-5">
+            <div class="text-center mb-4">
+                <i class="bi bi-people-fill text-primary" style="font-size: 4rem;"></i>
+                <h1 class="h3 mt-3 mb-2">Participatory Planning</h1>
+                <p class="text-muted">Enter your access token to continue</p>
+            </div>
+
+            <form method="POST">
+                <div class="mb-3">
+                    <label for="token" class="form-label">Access Token</label>
+                    <input type="text" class="form-control form-control-lg" id="token" name="token"
+                           placeholder="Enter your token" required autofocus>
+                </div>
+
+                <button type="submit" class="btn btn-primary btn-lg w-100">Login</button>
+            </form>
+
+            <div class="mt-4 pt-4 border-top text-center">
+                <a href="{{ url_for('auth.generate') }}" class="btn btn-success btn-sm">
+                    <i class="bi bi-key-fill"></i> Don't have a token? Generate one here
+                </a>
+            </div>
+        </div>
+    </div>
+</div>
+{% endblock %}

app/templates/submit.html

@@ -0,0 +1,170 @@
+{% extends "base.html" %}
+
+{% block title %}Submit Contribution{% endblock %}
+
+{% block content %}
+<div class="min-vh-100 bg-light">
+    <nav class="navbar navbar-light bg-white shadow-sm">
+        <div class="container-fluid">
+            <span class="navbar-brand mb-0 h1">Submit Your Contribution</span>
+            <a href="{{ url_for('auth.logout') }}" class="btn btn-outline-secondary">Logout</a>
+        </div>
+    </nav>
+
+    <div class="container py-5">
+        <div class="row justify-content-center">
+            <div class="col-lg-8">
+                <div class="card shadow">
+                    <div class="card-body p-4">
+                        <div class="mb-4">
+                            <h5 class="card-title">Your Contribution</h5>
+                            <p class="text-muted">
+                                Contributor Type: <span class="badge bg-primary text-capitalize">{{ contributor_type }}</span>
+                            </p>
+                        </div>
+
+                        {% if not submission_open %}
+                        <div class="alert alert-warning">
+                            <i class="bi bi-exclamation-triangle-fill"></i>
+                            Submission period is currently closed.
+                        </div>
+                        {% endif %}
+
+                        <form method="POST" id="submissionForm">
+                            <div class="mb-3">
+                                <label for="message" class="form-label">Your Message</label>
+                                <textarea class="form-control" id="message" name="message" rows="6"
+                                          placeholder="Share your expectations, objectives, concerns, ideas..."
+                                          {% if not submission_open %}disabled{% endif %} required></textarea>
+                            </div>
+
+                            <div class="mb-3">
+                                <label class="form-label">Location (Optional)</label>
+                                <div class="d-flex gap-2 flex-wrap mb-2">
+                                    <button type="button" class="btn btn-outline-primary" onclick="toggleMap()">
+                                        <i class="bi bi-geo-alt-fill"></i> <span id="mapToggleText">Add Location</span>
+                                    </button>
+                                    <button type="button" class="btn btn-outline-success" onclick="getCurrentLocation()">
+                                        <i class="bi bi-crosshair"></i> Use My Location
+                                    </button>
+                                    <button type="button" class="btn btn-outline-danger" onclick="clearLocation()" id="clearBtn" style="display: none;">
+                                        <i class="bi bi-x-circle"></i> Clear
+                                    </button>
+                                </div>
+                                <div id="locationDisplay" class="text-muted small" style="display: none;"></div>
+
+                                <div id="mapContainer" style="display: none;">
+                                    <div id="map" class="map-container border mt-2"></div>
+                                </div>
+
+                                <input type="hidden" id="latitude" name="latitude">
+                                <input type="hidden" id="longitude" name="longitude">
+                            </div>
+
+                            <button type="submit" class="btn btn-primary btn-lg w-100"
+                                    {% if not submission_open %}disabled{% endif %}>
+                                <i class="bi bi-send-fill"></i> Submit Contribution
+                            </button>
+                        </form>
+
+                        <div class="mt-4 pt-4 border-top text-center">
+                            <p class="text-muted mb-0">
+                                Your submissions: <strong class="text-primary">{{ submission_count }}</strong>
+                            </p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script>
+let map = null;
+let marker = null;
+let mapVisible = false;
+
+function toggleMap() {
+    mapVisible = !mapVisible;
+    const container = document.getElementById('mapContainer');
+    const toggleText = document.getElementById('mapToggleText');
+
+    if (mapVisible) {
+        container.style.display = 'block';
+        toggleText.textContent = 'Hide Map';
+        if (!map) {
+            initMap();
+        }
+    } else {
+        container.style.display = 'none';
+        toggleText.textContent = 'Add Location';
+    }
+}
+
+function initMap() {
+    map = L.map('map').setView([0, 0], 2);
+
+    L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+        attribution: '© OpenStreetMap'
+    }).addTo(map);
+
+    map.on('click', function(e) {
+        setLocation(e.latlng.lat, e.latlng.lng);
+    });
+
+    setTimeout(() => map.invalidateSize(), 100);
+}
+
+function setLocation(lat, lng) {
+    document.getElementById('latitude').value = lat;
+    document.getElementById('longitude').value = lng;
+
+    const display = document.getElementById('locationDisplay');
+    display.textContent = `Selected: ${lat.toFixed(6)}, ${lng.toFixed(6)}`;
+    display.style.display = 'block';
+
+    document.getElementById('clearBtn').style.display = 'inline-block';
+
+    if (map) {
+        if (marker) {
+            map.removeLayer(marker);
+        }
+        marker = L.marker([lat, lng]).addTo(map);
+        map.setView([lat, lng], 13);
+    }
+}
+
+function getCurrentLocation() {
+    if (navigator.geolocation) {
+        navigator.geolocation.getCurrentPosition(
+            (position) => {
+                const lat = position.coords.latitude;
+                const lng = position.coords.longitude;
+                setLocation(lat, lng);
+
+                if (!mapVisible) {
+                    toggleMap();
+                }
+            },
+            (error) => {
+                alert('Unable to get your location.');
+            }
+        );
+    } else {
+        alert('Geolocation is not supported by your browser.');
+    }
+}
+
+function clearLocation() {
+    document.getElementById('latitude').value = '';
+    document.getElementById('longitude').value = '';
+    document.getElementById('locationDisplay').style.display = 'none';
+    document.getElementById('clearBtn').style.display = 'none';
+
+    if (marker && map) {
+        map.removeLayer(marker);
+        marker = null;
+    }
+}
+</script>
+{% endblock %}

app_hf.py

@@ -0,0 +1,14 @@
+"""
+Hugging Face Spaces entry point
+This wraps the Flask app for Hugging Face deployment
+"""
+import os
+from app import create_app
+
+# Create Flask app
+app = create_app()
+
+# Hugging Face Spaces uses port 7860
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host="0.0.0.0", port=port, debug=False)

requirements.txt

@@ -0,0 +1,7 @@
+Flask==3.0.0
+Flask-SQLAlchemy==3.1.1
+python-dotenv==1.0.0
+transformers==4.36.0
+torch==2.5.0
+sentencepiece>=0.2.0
+gunicorn==21.2.0

wsgi.py

@@ -0,0 +1,9 @@
+"""
+WSGI entry point for production deployment
+"""
+from app import create_app
+
+app = create_app()
+
+if __name__ == "__main__":
+    app.run()