Add PDF export for dashboard with charts and maps

Features:
- Export dashboard data as professional PDF report
- Includes summary statistics
- Category distribution pie chart
- Contributor type bar chart
- Category breakdown table
- Geographic distribution map
- Supports both submission-level and sentence-level modes
- Export button in dashboard UI

Dependencies added:
- reportlab (PDF generation)
- plotly (charts)
- kaleido (chart rendering)

Files added:
- app/utils/pdf_export.py (PDF generator)
- app/utils/__init__.py

Files updated:
- requirements.txt
- app/routes/admin.py (export endpoint)
- app/templates/admin/dashboard.html (export button)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

app/routes/admin.py

@@ -2,6 +2,7 @@ from flask import Blueprint, render_template, request, redirect, url_for, sessio
 from app.models.models import Token, Submission, Settings, TrainingExample, FineTuningRun, SubmissionSentence
 from app import db
 from app.analyzer import get_analyzer
+from app.utils.pdf_export import DashboardPDFExporter
 from functools import wraps
 from typing import Dict
 import json
@@ -180,6 +181,99 @@ def dashboard():
                          breakdown=breakdown,
                          view_mode=view_mode)
 
+@bp.route('/dashboard/export-pdf')
+@admin_required
+def export_dashboard_pdf():
+    """Export dashboard data as PDF"""
+    try:
+        # Get view mode
+        view_mode = request.args.get('mode', 'submissions')
+
+        # Gather same data as dashboard
+        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 - mode dependent
+        if view_mode == 'sentences':
+            category_stats = db.session.query(
+                SubmissionSentence.category,
+                db.func.count(SubmissionSentence.id)
+            ).filter(SubmissionSentence.category != None).group_by(SubmissionSentence.category).all()
+
+            # Breakdown by contributor
+            breakdown = {}
+            for cat in CATEGORIES:
+                breakdown[cat] = {}
+                for ctype in CONTRIBUTOR_TYPES:
+                    count = db.session.query(db.func.count(SubmissionSentence.id)).join(
+                        Submission
+                    ).filter(
+                        SubmissionSentence.category == cat,
+                        Submission.contributor_type == ctype['value']
+                    ).scalar()
+                    breakdown[cat][ctype['value']] = count
+        else:
+            category_stats = db.session.query(
+                Submission.category,
+                db.func.count(Submission.id)
+            ).filter(Submission.category != None).group_by(Submission.category).all()
+
+            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
+
+        # Geotagged submissions
+        geotagged_submissions = Submission.query.filter(
+            Submission.latitude != None,
+            Submission.longitude != None,
+            Submission.category != None
+        ).all()
+
+        # Prepare data for PDF
+        pdf_data = {
+            'submissions': submissions,
+            'category_stats': category_stats,
+            'contributor_stats': contributor_stats,
+            'breakdown': breakdown,
+            'geotagged_submissions': geotagged_submissions,
+            'view_mode': view_mode,
+            'categories': CATEGORIES,
+            'contributor_types': CONTRIBUTOR_TYPES
+        }
+
+        # Generate PDF
+        buffer = io.BytesIO()
+        exporter = DashboardPDFExporter()
+        exporter.generate_pdf(buffer, pdf_data)
+        buffer.seek(0)
+
+        # Generate filename
+        mode_label = "sentence" if view_mode == 'sentences' else "submission"
+        filename = f"dashboard_{mode_label}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+
+        return send_file(
+            buffer,
+            mimetype='application/pdf',
+            as_attachment=True,
+            download_name=filename
+        )
+
+    except Exception as e:
+        logger.error(f"Error exporting dashboard PDF: {str(e)}")
+        flash(f'Error exporting PDF: {str(e)}', 'danger')
+        return redirect(url_for('admin.dashboard'))
+
 # API Endpoints
 
 @bp.route('/api/toggle-submissions', methods=['POST'])

app/templates/admin/dashboard.html

@@ -15,21 +15,29 @@
 <div class="d-flex justify-content-between align-items-center mb-4">
     <h2>Analytics Dashboard</h2>
 
-    <!-- View Mode Selector -->
-    <div class="btn-group" role="group" aria-label="View mode">
-        <input type="radio" class="btn-check" name="viewMode" id="viewSubmissions"
-               {% if view_mode == 'submissions' %}checked{% endif %}
-               onchange="window.location.href='{{ url_for('admin.dashboard', mode='submissions') }}'">
-        <label class="btn btn-outline-primary" for="viewSubmissions">
-            By Submissions
-        </label>
-
-        <input type="radio" class="btn-check" name="viewMode" id="viewSentences"
-               {% if view_mode == 'sentences' %}checked{% endif %}
-               onchange="window.location.href='{{ url_for('admin.dashboard', mode='sentences') }}'">
-        <label class="btn btn-outline-primary" for="viewSentences">
-            By Sentences
-        </label>
+    <div class="d-flex gap-3">
+        <!-- View Mode Selector -->
+        <div class="btn-group" role="group" aria-label="View mode">
+            <input type="radio" class="btn-check" name="viewMode" id="viewSubmissions"
+                   {% if view_mode == 'submissions' %}checked{% endif %}
+                   onchange="window.location.href='{{ url_for('admin.dashboard', mode='submissions') }}'">
+            <label class="btn btn-outline-primary" for="viewSubmissions">
+                By Submissions
+            </label>
+
+            <input type="radio" class="btn-check" name="viewMode" id="viewSentences"
+                   {% if view_mode == 'sentences' %}checked{% endif %}
+                   onchange="window.location.href='{{ url_for('admin.dashboard', mode='sentences') }}'">
+            <label class="btn btn-outline-primary" for="viewSentences">
+                By Sentences
+            </label>
+        </div>
+
+        <!-- Export PDF Button -->
+        <a href="{{ url_for('admin.export_dashboard_pdf', mode=view_mode) }}"
+           class="btn btn-success">
+            <i class="bi bi-file-earmark-pdf"></i> Export PDF
+        </a>
     </div>
 </div>
 

app/utils/pdf_export.py

@@ -0,0 +1,304 @@
+"""
+PDF export utility for dashboard data
+Generates professional PDF reports with charts and maps
+"""
+import io
+from datetime import datetime
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, PageBreak, Image
+from reportlab.lib.enums import TA_CENTER, TA_LEFT, TA_RIGHT
+import plotly.graph_objects as go
+import plotly.express as px
+
+
+class DashboardPDFExporter:
+    """Export dashboard data to PDF with charts and maps"""
+
+    def __init__(self, pagesize=letter):
+        self.pagesize = pagesize
+        self.styles = getSampleStyleSheet()
+        self._setup_custom_styles()
+
+    def _setup_custom_styles(self):
+        """Setup custom paragraph styles"""
+        self.styles.add(ParagraphStyle(
+            name='CustomTitle',
+            parent=self.styles['Heading1'],
+            fontSize=24,
+            textColor=colors.HexColor('#2c3e50'),
+            spaceAfter=30,
+            alignment=TA_CENTER
+        ))
+
+        self.styles.add(ParagraphStyle(
+            name='SectionHeader',
+            parent=self.styles['Heading2'],
+            fontSize=16,
+            textColor=colors.HexColor('#34495e'),
+            spaceAfter=12,
+            spaceBefore=12
+        ))
+
+        self.styles.add(ParagraphStyle(
+            name='MetricLabel',
+            fontSize=10,
+            textColor=colors.HexColor('#7f8c8d'),
+            spaceAfter=4
+        ))
+
+        self.styles.add(ParagraphStyle(
+            name='MetricValue',
+            fontSize=20,
+            textColor=colors.HexColor('#2c3e50'),
+            spaceAfter=12,
+            fontName='Helvetica-Bold'
+        ))
+
+    def generate_pdf(self, buffer, data):
+        """
+        Generate PDF report
+
+        Args:
+            buffer: BytesIO buffer to write PDF to
+            data: Dictionary containing dashboard data with keys:
+                - submissions: list of Submission objects
+                - category_stats: list of (category, count) tuples
+                - contributor_stats: list of (type, count) tuples
+                - breakdown: dict of {category: {contributor_type: count}}
+                - geotagged_submissions: list of geotagged Submission objects
+                - view_mode: 'submissions' or 'sentences'
+                - categories: list of category names
+                - contributor_types: list of contributor type dicts
+        """
+        doc = SimpleDocTemplate(buffer, pagesize=self.pagesize,
+                               rightMargin=72, leftMargin=72,
+                               topMargin=72, bottomMargin=18)
+
+        story = []
+
+        # Title
+        title = Paragraph("Participatory Planning Dashboard Report", self.styles['CustomTitle'])
+        story.append(title)
+        story.append(Spacer(1, 12))
+
+        # Metadata
+        view_mode_label = "Sentence-Level" if data['view_mode'] == 'sentences' else "Submission-Level"
+        metadata = Paragraph(
+            f"<font size=10>Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}<br/>"
+            f"Analysis Mode: {view_mode_label}</font>",
+            self.styles['Normal']
+        )
+        story.append(metadata)
+        story.append(Spacer(1, 24))
+
+        # Summary Statistics
+        story.append(Paragraph("Summary Statistics", self.styles['SectionHeader']))
+        story.extend(self._create_summary_stats(data))
+        story.append(Spacer(1, 24))
+
+        # Category Distribution Chart
+        story.append(Paragraph("Category Distribution", self.styles['SectionHeader']))
+        category_chart = self._create_category_chart(data['category_stats'], data['categories'])
+        if category_chart:
+            story.append(category_chart)
+        story.append(Spacer(1, 24))
+
+        # Contributor Type Distribution
+        story.append(Paragraph("Contributor Type Distribution", self.styles['SectionHeader']))
+        contributor_chart = self._create_contributor_chart(data['contributor_stats'])
+        if contributor_chart:
+            story.append(contributor_chart)
+        story.append(PageBreak())
+
+        # Breakdown Table
+        story.append(Paragraph("Category Breakdown by Contributor Type", self.styles['SectionHeader']))
+        breakdown_table = self._create_breakdown_table(data['breakdown'], data['contributor_types'])
+        story.append(breakdown_table)
+        story.append(Spacer(1, 24))
+
+        # Map
+        if data['geotagged_submissions']:
+            story.append(PageBreak())
+            story.append(Paragraph("Geographic Distribution", self.styles['SectionHeader']))
+            map_image = self._create_map(data['geotagged_submissions'], data['categories'])
+            if map_image:
+                story.append(map_image)
+
+        # Build PDF
+        doc.build(story)
+
+        return buffer
+
+    def _create_summary_stats(self, data):
+        """Create summary statistics section"""
+        elements = []
+
+        total_items = sum(count for _, count in data['category_stats'])
+        total_submissions = len(data['submissions'])
+        total_geotagged = len(data['geotagged_submissions'])
+
+        # Create metrics table
+        metrics_data = [
+            ['Total Submissions', str(total_submissions)],
+            ['Total Items Analyzed', str(total_items)],
+            ['Geotagged Items', str(total_geotagged)],
+            ['Categories', str(len([c for c, count in data['category_stats'] if count > 0]))]
+        ]
+
+        metrics_table = Table(metrics_data, colWidths=[3*inch, 2*inch])
+        metrics_table.setStyle(TableStyle([
+            ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+            ('FONTNAME', (1, 0), (1, -1), 'Helvetica'),
+            ('FONTSIZE', (0, 0), (-1, -1), 12),
+            ('TEXTCOLOR', (0, 0), (0, -1), colors.HexColor('#2c3e50')),
+            ('TEXTCOLOR', (1, 0), (1, -1), colors.HexColor('#3498db')),
+            ('ALIGN', (1, 0), (1, -1), 'RIGHT'),
+            ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
+            ('BOTTOMPADDING', (0, 0), (-1, -1), 12),
+        ]))
+
+        elements.append(metrics_table)
+
+        return elements
+
+    def _create_category_chart(self, category_stats, categories):
+        """Create category distribution pie chart"""
+        if not category_stats:
+            return None
+
+        # Prepare data
+        labels = [cat for cat, _ in category_stats]
+        values = [count for _, count in category_stats]
+
+        # Create plotly figure
+        fig = go.Figure(data=[go.Pie(
+            labels=labels,
+            values=values,
+            hole=0.3,
+            marker=dict(colors=['#3498db', '#2ecc71', '#f39c12', '#e74c3c', '#9b59b6', '#1abc9c'])
+        )])
+
+        fig.update_layout(
+            title='Category Distribution',
+            width=500,
+            height=400,
+            showlegend=True,
+            font=dict(size=10)
+        )
+
+        # Convert to image
+        img_bytes = fig.to_image(format="png")
+        img = Image(io.BytesIO(img_bytes), width=5*inch, height=4*inch)
+
+        return img
+
+    def _create_contributor_chart(self, contributor_stats):
+        """Create contributor type bar chart"""
+        if not contributor_stats:
+            return None
+
+        # Prepare data
+        types = [ctype for ctype, _ in contributor_stats]
+        counts = [count for _, count in contributor_stats]
+
+        # Create plotly figure
+        fig = go.Figure(data=[go.Bar(
+            x=types,
+            y=counts,
+            marker=dict(color='#3498db')
+        )])
+
+        fig.update_layout(
+            title='Submissions by Contributor Type',
+            xaxis_title='Contributor Type',
+            yaxis_title='Count',
+            width=500,
+            height=400,
+            font=dict(size=10)
+        )
+
+        # Convert to image
+        img_bytes = fig.to_image(format="png")
+        img = Image(io.BytesIO(img_bytes), width=5*inch, height=4*inch)
+
+        return img
+
+    def _create_breakdown_table(self, breakdown, contributor_types):
+        """Create category breakdown table"""
+        # Prepare table data
+        headers = ['Category'] + [ct['label'] for ct in contributor_types]
+        data = [headers]
+
+        for category, counts in breakdown.items():
+            row = [category]
+            for ct in contributor_types:
+                row.append(str(counts.get(ct['value'], 0)))
+            data.append(row)
+
+        # Calculate column widths
+        num_cols = len(headers)
+        col_width = 6.5 * inch / num_cols
+
+        table = Table(data, colWidths=[col_width] * num_cols)
+        table.setStyle(TableStyle([
+            ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#3498db')),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, -1), 10),
+            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+            ('GRID', (0, 0), (-1, -1), 1, colors.grey),
+            ('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.white, colors.HexColor('#ecf0f1')])
+        ]))
+
+        return table
+
+    def _create_map(self, geotagged_submissions, categories):
+        """Create geographic distribution map"""
+        if not geotagged_submissions:
+            return None
+
+        # Prepare data
+        lats = [s.latitude for s in geotagged_submissions]
+        lons = [s.longitude for s in geotagged_submissions]
+        cats = [s.category for s in geotagged_submissions]
+        texts = [f"{s.category}<br>{s.text[:100]}..." for s in geotagged_submissions]
+
+        # Create plotly figure
+        fig = go.Figure(data=go.Scattermapbox(
+            lat=lats,
+            lon=lons,
+            mode='markers',
+            marker=dict(
+                size=10,
+                color=[categories.index(c) if c in categories else 0 for c in cats],
+                colorscale='Viridis',
+                showscale=True
+            ),
+            text=texts,
+            hoverinfo='text'
+        ))
+
+        # Calculate center
+        center_lat = sum(lats) / len(lats)
+        center_lon = sum(lons) / len(lons)
+
+        fig.update_layout(
+            mapbox=dict(
+                style='open-street-map',
+                center=dict(lat=center_lat, lon=center_lon),
+                zoom=10
+            ),
+            width=600,
+            height=500,
+            margin=dict(l=0, r=0, t=0, b=0)
+        )
+
+        # Convert to image
+        img_bytes = fig.to_image(format="png")
+        img = Image(io.BytesIO(img_bytes), width=6*inch, height=5*inch)
+
+        return img

requirements.txt

@@ -19,3 +19,8 @@ evaluate>=0.4.0
 
 # Text processing (for sentence segmentation)
 nltk>=3.8.0
+
+# PDF generation
+reportlab>=4.0.0
+plotly>=5.18.0
+kaleido>=0.2.1