('/dashboard/connectivity').then(({ data }) => setConnectivity(data)).catch(() => {}),
);
}
await Promise.allSettled(promises);
@@ -280,21 +285,20 @@ export default function DashboardPage() {
{/* === Welcome Banner === */}
-
-
-
-
- Welcome{user?.name ? `, ${user.name}` : ''}
-
-
- {lastRefresh && `Updated ${lastRefresh.toLocaleTimeString()}`}
-
-
+
+
+
+ Welcome{user?.name ? `, ${user.name}` : ''}
+
+
+ {lastRefresh && `Updated ${lastRefresh.toLocaleTimeString()}`}
+
{isSuperAdmin && homepageUrl && (
setActiveView(val as 'dashboard' | 'homepage')}
options={[
@@ -306,35 +310,29 @@ export default function DashboardPage() {
)}
{activeView === 'dashboard' && (
-
- {showInfluence && (
- } onClick={() => navigate('/app/campaigns')}>Campaign
- )}
- {showMap && (
- } onClick={() => navigate('/app/map')}>Location
- )}
- {showMedia && (
- } onClick={() => navigate('/app/media/library')}>Video
- )}
- } onClick={() => navigate('/app/pages')}>Page
+
+ {showInfluence && } onClick={() => navigate('/app/campaigns')} />}
+ {showMap && } onClick={() => navigate('/app/map')} />}
+ {showMedia && } onClick={() => navigate('/app/media/library')} />}
+ } onClick={() => navigate('/app/pages')} />
{isSuperAdmin && (
<>
- } onClick={() => navigate('/app/observability')}>Monitoring
- } onClick={() => navigate('/app/tunnel')}>Tunnel
- } onClick={() => navigate('/app/services/nocodb')}>NocoDB
- } onClick={() => navigate('/app/services/n8n')}>Workflows
- } onClick={() => navigate('/app/services/gitea')}>Git
- } onClick={() => navigate('/app/code')}>Code
- } onClick={() => navigate('/app/docs')}>Docs
- } onClick={() => navigate('/app/services/miniqr')}>QR
- } onClick={() => navigate('/app/map/data-quality')}>Data Quality
+ } onClick={() => navigate('/app/observability')} />
+ } onClick={() => navigate('/app/tunnel')} />
+ } onClick={() => navigate('/app/services/nocodb')} />
+ } onClick={() => navigate('/app/services/n8n')} />
+ } onClick={() => navigate('/app/services/gitea')} />
+ } onClick={() => navigate('/app/code')} />
+ } onClick={() => navigate('/app/docs')} />
+ } onClick={() => navigate('/app/services/miniqr')} />
+ } onClick={() => navigate('/app/map/data-quality')} />
)}
- } onClick={handleRefresh}>Refresh
+ } onClick={handleRefresh} />
)}
{activeView === 'homepage' && (
- } onClick={handleRefresh}>Refresh
+ } onClick={handleRefresh} />
)}
@@ -400,107 +398,130 @@ export default function DashboardPage() {
);
})()}
- {/* === Weather + Key Metrics Row === */}
-
- {weather && (
-
-
- {getWeatherIcon(weather.weatherCode, weather.isDay)}
- {Math.round(weather.temperature)}{'°C'}
-
-
- {weather.weatherDescription}
-
-
-
- {'Feels ' + Math.round(weather.apparentTemperature) + '° · ' + weather.humidity + '% · ' + Math.round(weather.windSpeed) + ' km/h'}
-
-
-
- )}
+ {/* === Status Bar (weather + stats + pending actions + connectivity) === */}
+ {summary && (
+
+
+
+ {weather && (
+
+ {getWeatherIcon(weather.weatherCode, weather.isDay)}
+ {Math.round(weather.temperature)}°C
+ {weather.weatherDescription}
+
+ )}
+ {/* Quick stat chips */}
+ } color="#1890ff" value={summary.users.total} label="Users" onClick={() => navigate('/app/users')} />
+ {showInfluence && } color="#52c41a" value={summary.campaigns.active} label={`of ${summary.campaigns.total}`} onClick={() => navigate('/app/campaigns')} />}
+ {showMap && } color="#722ed1" value={summary.locations.total.toLocaleString()} label={`${geocodePct}% geo`} onClick={() => navigate('/app/map')} />}
+ {showInfluence && } color="#faad14" value={summary.emails.sent} label="sent" onClick={() => navigate('/app/email-queue')} />}
+ {showMedia && } color="#13c2c2" value={summary.videos.published} label={`of ${summary.videos.total}`} onClick={() => navigate('/app/media/library')} />}
+ {showMap && } color="#eb2f96" value={summary.shifts.upcoming} label={`${summary.shifts.open} open`} onClick={() => navigate('/app/map/shifts')} />}
+ {/* Pending action tags */}
+ {summary.responses.pending > 0 && (
+ navigate('/app/responses')}>
+ {summary.responses.pending} pending
+
+ )}
+ {summary.locations.total > 0 && summary.locations.total - summary.locations.geocoded > 0 && (
+ navigate('/app/map')}>
+ {summary.locations.total - summary.locations.geocoded} ungeocoded
+
+ )}
+ {summary.emails.queued > 0 && (
+ navigate('/app/email-queue')}>
+ {summary.emails.queued} queued
+
+ )}
+ {summary.campaignModeration.pendingReview > 0 && (
+ navigate('/app/campaign-moderation')}>
+ {summary.campaignModeration.pendingReview} review
+
+ )}
+
+ {isSuperAdmin && connectivity && (
+
+
+
+
+
+
+ )}
+
+
+ )}
-
- } color="#1890ff" onClick={() => navigate('/app/users')} />
-
+ {/* === Email Queue Widget (shown if queue has items) === */}
+ {queue && (queue.waiting > 0 || queue.active > 0 || queue.failed > 0) && (
+ 0 ? '#ff4d4f' : queue.paused ? '#faad14' : '#1890ff'}` }}
+ styles={{ body: { padding: '6px 16px' } }}
+ >
+
+
+
+
+ Email Queue
+ {queue.paused && Paused}
+
+
+ Waiting} value={queue.waiting} valueStyle={{ fontSize: 18 }} />
+ Active} value={queue.active} valueStyle={{ fontSize: 18, color: '#1890ff' }} />
+ {queue.failed > 0 && (
+ Failed} value={queue.failed} valueStyle={{ fontSize: 18, color: '#ff4d4f' }} />
+ )}
+
+
+
+
+
+ )}
+ {/* === Module Overview Row (3 columns) === */}
+
{showInfluence && (
-
- } color="#52c41a" onClick={() => navigate('/app/campaigns')} />
-
- )}
-
- {showMap && (
-
- } color="#722ed1" onClick={() => navigate('/app/map')} />
-
- )}
-
- {showInfluence && (
-
- } color="#faad14" onClick={() => navigate('/app/email-queue')} />
-
- )}
-
- {showMedia && (
-
- } color="#13c2c2" onClick={() => navigate('/app/media/library')} />
-
- )}
-
- {showMap && (
-
- } color="#eb2f96" onClick={() => navigate('/app/map/shifts')} />
-
- )}
-
-
- {/* === Module Overview Row === */}
-
- {showInfluence && (
-
+
Influence}
+ title={
+
+
+ Influence
+ {summary && {summary.campaigns.active} active / {summary.campaigns.total}}
+
+ }
size="small"
extra={}
style={{ height: '100%' }}
>
{summary && (
-
-
-
-
- Campaigns:
- {summary.campaigns.active} Active
- {summary.campaigns.draft} Draft
- {summary.campaigns.paused > 0 && {summary.campaigns.paused} Paused}
+
+
+
+ {summary.campaigns.active} Active
+ {summary.campaigns.draft} Draft
+ {summary.campaigns.paused > 0 && {summary.campaigns.paused} Paused}
+
+
+ Responses: {summary.responses.total}
+ {summary.responses.pending > 0 && {summary.responses.pending} pending}
+
+
+ Emails: {summary.emails.sent} sent
+ {summary.emails.failed > 0 && {summary.emails.failed} failed}
+
+ {queue && (
+
+ Queue: {queue.waiting} waiting
+ {queue.paused && Paused}
-
- Responses:
- {summary.responses.total} total
- {summary.responses.pending > 0 && {summary.responses.pending} pending}
-
-
- Queue:
- {queue ? (
- <>
- {queue.waiting} waiting, {queue.active} active
- {queue.paused && Paused}
-
- ) : unavailable}
-
- {summary.campaignModeration.pendingReview > 0 && (
-
-
-
- )}
-
-
-
+ )}
+
+ {summary.campaigns.total > 0 && screens.md && (
+
+
)}
@@ -510,9 +531,15 @@ export default function DashboardPage() {
)}
{showMap && (
-
+
Map & Canvassing}
+ title={
+
+
+ Map
+ {summary && {summary.locations.total.toLocaleString()} locations}
+
+ }
size="small"
extra={}
style={{ height: '100%' }}
@@ -520,84 +547,90 @@ export default function DashboardPage() {
{summary && (
- Geocoding:
+ Geocoded:
{summary.locations.geocoded.toLocaleString()}/{summary.locations.total.toLocaleString()}
-
- Addresses:
- {summary.locations.addresses.toLocaleString()}
- {summary.cuts.total} cuts
-
-
- Canvassing:
- {summary.canvass.totalVisits} visits
- {summary.canvass.activeSessions > 0 && {summary.canvass.activeSessions} active}
-
+
+ Addresses: {summary.locations.addresses.toLocaleString()}
+ {summary.cuts.total} cuts
+
+
+ Canvassing: {summary.canvass.totalVisits} visits
+ {summary.canvass.activeSessions > 0 && {summary.canvass.activeSessions} active}
+
+
+ Shifts: {summary.shifts.upcoming} upcoming
+ {summary.shifts.open} open
+
)}
)}
-
+
Content}
- size="small"
- extra={}
- style={{ height: '100%' }}
- >
- {summary && (
-
-
- Pages:
- {summary.pages.published} published
- / {summary.pages.total}
-
-
- Templates:
- {summary.emailTemplates.total}
-
- {showInfluence && (
-
- Rep Cache:
- {summary.representatives.totalCached}
-
- )}
- {showMedia && (
-
- Videos:
- {summary.videos.published} published / {summary.videos.total}
-
- )}
+ title={
+
+
+ Users & Content
+ {summary && {summary.users.total} users}
- )}
-
-
-
-
-
Users}
+ }
size="small"
extra={}
style={{ height: '100%' }}
>
{summary && (
-
- {Object.entries(summary.users.byRole)
- .filter(([, count]) => count > 0)
- .map(([role, count]) => (
-
- {ROLE_LABELS[role] || role}: {count}
-
- ))}
- {summary.users.suspended > 0 && Suspended: {summary.users.suspended}}
-
+
+
+ {Object.entries(summary.users.byRole)
+ .filter(([, count]) => count > 0)
+ .map(([role, count]) => (
+
+ {ROLE_LABELS[role] || role}: {count}
+
+ ))}
+ {summary.users.suspended > 0 && Suspended: {summary.users.suspended}}
+
+
+ Pages: {summary.pages.published} published
+ / {summary.pages.total}
+
+
+ Templates: {summary.emailTemplates.total}
+ {showInfluence && Reps: {summary.representatives.totalCached}}
+
+ {showMedia && (
+
+ Videos: {summary.videos.published} published
+ / {summary.videos.total}
+
+ )}
+
)}
+ {/* === Activity Feed + Events + Chat === */}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{/* === System + Docker Section (SUPER_ADMIN only) === */}
{isSuperAdmin && (
<>
@@ -876,34 +909,6 @@ function MiniSystemChart({ timeSeries }: { timeSeries: TimeSeriesResult }) {
);
}
-// --- Stat Card Component ---
-
-function StatCard({ title, value, subtitle, icon, color, onClick }: {
- title: string;
- value?: number | null;
- subtitle: string;
- icon: React.ReactNode;
- color: string;
- onClick: () => void;
-}) {
- return (
-
- {title}}
- value={value ?? '--'}
- prefix={icon}
- valueStyle={{ color, fontSize: 22 }}
- />
- {subtitle}
-
- );
-}
// --- Service Badge Component (with pulse animation) ---
@@ -927,6 +932,47 @@ const SERVICE_ICONS: Record
= {
homepage: ,
};
+// --- Quick Stat chip (for status bar) ---
+
+function QuickStat({ icon, color, value, label, onClick }: {
+ icon: React.ReactNode;
+ color: string;
+ value: string | number;
+ label: string;
+ onClick: () => void;
+}) {
+ return (
+
+ {icon}
+ {value}
+ {label}
+
+ );
+}
+
+function ConnectivityDot({ label, online }: { label: string; online: boolean }) {
+ return (
+
+
+
+ {label}
+
+
+ );
+}
+
function ServiceBadge({ name, online, icon }: {
name: string;
online?: boolean;
diff --git a/admin/src/pages/GancioPage.tsx b/admin/src/pages/GancioPage.tsx
new file mode 100644
index 00000000..8ca381b0
--- /dev/null
+++ b/admin/src/pages/GancioPage.tsx
@@ -0,0 +1,127 @@
+import { useState, useEffect, useCallback, useMemo } from 'react';
+import { useOutletContext } from 'react-router-dom';
+import { Button, Space, Badge, Spin, Grid, Result } from 'antd';
+import { ReloadOutlined, LinkOutlined, CalendarOutlined } from '@ant-design/icons';
+import { api } from '@/lib/api';
+import type { AppOutletContext } from '@/components/AppLayout';
+import type { ServicesStatus, ServicesConfig } from '@/types/api';
+import { buildServiceUrl } from '@/lib/service-url';
+
+export default function GancioPage() {
+ const { setPageHeader } = useOutletContext();
+ const screens = Grid.useBreakpoint();
+ const isMobile = !screens.md;
+
+ const [online, setOnline] = useState(null);
+ const [config, setConfig] = useState(null);
+ const [loading, setLoading] = useState(true);
+
+ const fetchStatus = useCallback(async () => {
+ try {
+ const [statusRes, configRes] = await Promise.all([
+ api.get('/services/status'),
+ api.get('/services/config'),
+ ]);
+ setOnline(statusRes.data.gancio.online);
+ setConfig(configRes.data);
+ } catch {
+ setOnline(false);
+ } finally {
+ setLoading(false);
+ }
+ }, []);
+
+ useEffect(() => {
+ fetchStatus();
+ }, [fetchStatus]);
+
+ const serviceUrl = config
+ ? buildServiceUrl(config.gancioSubdomain, config.domain, config.gancioPort)
+ : null;
+
+ const handleRefresh = useCallback(() => {
+ fetchStatus();
+ }, [fetchStatus]);
+
+ const headerActions = useMemo(() => (
+
+
+ }
+ onClick={handleRefresh}
+ size="small"
+ >
+ Refresh
+
+ {serviceUrl && (
+ }
+ href={serviceUrl}
+ target="_blank"
+ size="small"
+ >
+ Open in New Tab
+
+ )}
+
+ ), [online, handleRefresh, serviceUrl]);
+
+ useEffect(() => {
+ setPageHeader({
+ title: 'Events',
+ actions: headerActions,
+ fullBleed: true
+ });
+ return () => setPageHeader(null);
+ }, [setPageHeader, headerActions]);
+
+ if (isMobile) {
+ return (
+ }
+ />
+ );
+ }
+
+ if (loading) {
+ return (
+
+
+
+ );
+ }
+
+ if (!online || !serviceUrl) {
+ return (
+
+ Retry
+
+ }
+ />
+ );
+ }
+
+ return (
+
+ );
+}
diff --git a/admin/src/pages/ListmonkPage.tsx b/admin/src/pages/ListmonkPage.tsx
index 549922ba..9b733707 100644
--- a/admin/src/pages/ListmonkPage.tsx
+++ b/admin/src/pages/ListmonkPage.tsx
@@ -44,6 +44,7 @@ export default function ListmonkPage() {
const [status, setStatus] = useState(null);
const [stats, setStats] = useState(null);
const [config, setConfig] = useState(null);
+ const [eventSyncStats, setEventSyncStats] = useState<{ enabled: boolean; lastSyncAt: string | null; todaySyncCount: number } | null>(null);
const [loading, setLoading] = useState(true);
const [syncing, setSyncing] = useState>({});
const [iframeSrc, setIframeSrc] = useState(null);
@@ -79,11 +80,20 @@ export default function ListmonkPage() {
}
}, []);
+ const fetchEventSyncStats = useCallback(async () => {
+ try {
+ const res = await api.get<{ enabled: boolean; lastSyncAt: string | null; todaySyncCount: number }>('/listmonk/event-sync-stats');
+ setEventSyncStats(res.data);
+ } catch {
+ // Event sync stats fetch failed — leave null
+ }
+ }, []);
+
const fetchAll = useCallback(async () => {
setLoading(true);
- await Promise.all([fetchStatus(), fetchStats(), fetchConfig()]);
+ await Promise.all([fetchStatus(), fetchStats(), fetchConfig(), fetchEventSyncStats()]);
setLoading(false);
- }, [fetchStatus, fetchStats, fetchConfig]);
+ }, [fetchStatus, fetchStats, fetchConfig, fetchEventSyncStats]);
useEffect(() => {
fetchAll();
@@ -350,6 +360,29 @@ export default function ListmonkPage() {
/>
+
+
+
+
+
+
+ {eventSyncStats?.lastSyncAt ? dayjs(eventSyncStats.lastSyncAt).fromNow() : 'No events yet'}
+
+
+ {eventSyncStats?.todaySyncCount ?? 0}
+
+
+
+
+
();
const screens = Grid.useBreakpoint();
@@ -15,6 +17,9 @@ export default function NocoDBPage() {
const [online, setOnline] = useState(null);
const [config, setConfig] = useState(null);
const [loading, setLoading] = useState(true);
+ const [bannerDismissed, setBannerDismissed] = useState(
+ () => localStorage.getItem(BANNER_DISMISSED_KEY) === 'true'
+ );
const fetchStatus = useCallback(async () => {
try {
@@ -109,15 +114,38 @@ export default function NocoDBPage() {
}
return (
-
+
+ {!bannerDismissed && (
+
+ If the database browser appears blank, you may need to{' '}
+
+ sign in to NocoDB in a new tab
+ {' '}
+ first, then refresh this page.
+
+ }
+ type="info"
+ showIcon
+ closable
+ onClose={() => {
+ setBannerDismissed(true);
+ localStorage.setItem(BANNER_DISMISSED_KEY, 'true');
+ }}
+ style={{ borderRadius: 0, flexShrink: 0 }}
+ />
+ )}
+
+
+
+
+ );
+ }
+
+ if (!rcConfig?.enabled) {
+ return (
+
+ );
+ }
+
+ if (!online || !serviceUrl) {
+ return (
+
+ Retry
+
+ }
+ />
+ );
+ }
+
+ if (authError) {
+ return (
+
+ Retry
+
+ }
+ />
+ );
+ }
+
+ // Load full RC UI (with sidebar) — layout=embedded hides the channel sidebar
+ const iframeSrc = serviceUrl;
+
+ return (
+
+ );
+}
diff --git a/admin/src/pages/SettingsPage.tsx b/admin/src/pages/SettingsPage.tsx
index fefe0a27..c2833dc4 100644
--- a/admin/src/pages/SettingsPage.tsx
+++ b/admin/src/pages/SettingsPage.tsx
@@ -501,6 +501,89 @@ export default function SettingsPage() {
+
+
+
+
+
+
+
+
+
Admin Alerts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Volunteer Emails
+
+
+
+
+
+
+
+
+
+
+
+
+ );
+ }
+
+ if (!online || !serviceUrl) {
+ return (
+
+ Retry
+
+ }
+ />
+ );
+ }
+
+ const showHttpWarning = isLocalAccess || isHttpAccess;
+
+ return (
+
+ {showHttpWarning && (
+
}
+ showIcon
+ banner
+ message={
+
+ HTTPS required for account creation.
+ {' '}You are accessing Vaultwarden over HTTP (localhost). Browsing an existing vault works,
+ but creating accounts or accepting invites requires HTTPS.
+ {httpsUrl ? (
+ <>
+ {' '}Use your tunnel URL instead:{' '}
+ {httpsUrl}
+
+ ) : (
+ <> Configure a Pangolin tunnel resource for the vault subdomain to enable HTTPS access.
+ )}
+
+ }
+ closable
+ />
+ )}
+
+
+ }
+ title="Desktop Recommended"
+ subTitle="Chat works best on a larger screen."
+ />
+
+ );
+ }
+
+ if (loading) {
+ return (
+
+
+
+ );
+ }
+
+ if (!rcConfig?.enabled) {
+ return (
+
+
+
+ );
+ }
+
+ if (!online || error) {
+ return (
+
+ Retry}
+ />
+
+ );
+ }
+
+ const serviceUrl = buildServiceUrl(rcConfig.subdomain, rcConfig.domain, rcConfig.embedPort);
+ const iframeSrc = `${serviceUrl}/channel/general?layout=embedded`;
+
+ return (
+
+ );
+}
diff --git a/admin/src/types/api.ts b/admin/src/types/api.ts
index f43648ba..b24c3d2f 100644
--- a/admin/src/types/api.ts
+++ b/admin/src/types/api.ts
@@ -1005,6 +1005,9 @@ export interface ServicesStatus {
miniqr: { online: boolean; url: string };
excalidraw: { online: boolean; url: string };
homepage: { online: boolean; url: string };
+ vaultwarden: { online: boolean; url: string };
+ rocketchat: { online: boolean; url: string };
+ gancio: { online: boolean; url: string };
}
export interface ServicesConfig {
@@ -1039,6 +1042,15 @@ export interface ServicesConfig {
// Homepage (service dashboard)
homepagePort: number;
homepageSubdomain: string;
+ // Vaultwarden (password manager)
+ vaultwardenPort: number;
+ vaultwardenSubdomain: string;
+ // Rocket.Chat (team chat)
+ rocketchatPort: number;
+ rocketchatSubdomain: string;
+ // Gancio (event management)
+ gancioPort: number;
+ gancioSubdomain: string;
}
// --- Site Settings ---
@@ -1088,6 +1100,16 @@ export interface SiteSettings {
enableMediaFeatures: boolean;
enablePayments: boolean;
enableGalleryAds: boolean;
+ enableChat: boolean;
+ enableEvents: boolean;
+ // Notification settings
+ notifyAdminShiftSignup: boolean;
+ notifyAdminResponseSubmitted: boolean;
+ notifyAdminSignRequested: boolean;
+ notifyAdminShiftCancellation: boolean;
+ notifyVolunteerSessionSummary: boolean;
+ notifyVolunteerCancellation: boolean;
+ notifyVolunteerShiftReminder: boolean;
createdAt: string;
updatedAt: string;
}
@@ -1693,6 +1715,96 @@ export interface ApiMetrics {
statusBreakdown: { status: string; count: number }[];
}
+// --- Canvass Export ---
+
+export interface ExportContactsPreviewResult {
+ totalContacts: number;
+ contactsWithEmail: number;
+ byCut: { cutId: string; cutName: string; contacts: number; withEmail: number }[];
+ byOutcome: Record;
+ bySupportLevel: Record;
+}
+
+export interface ExportContactsResult {
+ created: number;
+ skippedDuplicate: number;
+ skippedNoEmail: number;
+ campaignId: string;
+ campaignTitle: string;
+}
+
+export interface CutCampaignAnalytics {
+ cutId: string;
+ cutName: string;
+ totalAddresses: number;
+ visitedAddresses: number;
+ completionPct: number;
+ addressesWithEmail: number;
+ supportBreakdown: Record;
+}
+
+// --- Dashboard Activity Feed ---
+
+export interface ActivityItem {
+ id: string;
+ type: 'shift_signup' | 'response_submitted' | 'canvass_completed' | 'email_sent' | 'user_created';
+ module: 'map' | 'influence' | 'users';
+ title: string;
+ description: string;
+ timestamp: string;
+}
+
+export interface ActivityFeedResult {
+ items: ActivityItem[];
+ total: number;
+ page: number;
+ limit: number;
+}
+
+// --- Dashboard Connectivity ---
+
+export interface ConnectivityStatus {
+ smtp: boolean;
+ listmonk: boolean;
+ rocketchat: boolean;
+ gancio: boolean;
+}
+
+// --- Dashboard Today Events (Gancio) ---
+
+export interface TodayEvent {
+ id: number;
+ title: string;
+ description: string;
+ placeName: string;
+ startTime: string;
+ endTime: string | null;
+ tags: string[];
+}
+
+export interface TodayEventsResult {
+ enabled: boolean;
+ events: TodayEvent[];
+ total: number;
+}
+
+// --- Dashboard Chat Summary (Rocket.Chat) ---
+
+export interface ChatMessage {
+ id: string;
+ channel: string;
+ username: string;
+ text: string;
+ timestamp: string;
+ isBot: boolean;
+}
+
+export interface ChatSummaryResult {
+ enabled: boolean;
+ messages: ChatMessage[];
+ unreadChannels: number;
+}
+
// --- Dashboard Time-Series ---
export interface TimeSeriesPoint {
diff --git a/api/prisma/init-gancio-db.sh b/api/prisma/init-gancio-db.sh
new file mode 100755
index 00000000..cae44ae3
--- /dev/null
+++ b/api/prisma/init-gancio-db.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+###############################################################################
+# Gancio Database Initialization Script
+###############################################################################
+# Creates a separate PostgreSQL database for Gancio event management.
+#
+# Database: gancio
+# Purpose: Stores Gancio events, users, and configuration
+# Runs: Automatically on first PostgreSQL container startup via docker-entrypoint-initdb.d
+###############################################################################
+set -e
+
+psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" <<-EOSQL
+ -- Create Gancio database if it doesn't exist
+ SELECT 'CREATE DATABASE gancio'
+ WHERE NOT EXISTS (SELECT FROM pg_database WHERE datname = 'gancio')\gexec
+
+ -- Grant all privileges to the main user
+ GRANT ALL PRIVILEGES ON DATABASE gancio TO ${POSTGRES_USER};
+EOSQL
+
+echo "Gancio database 'gancio' created successfully"
diff --git a/api/prisma/migrations/20260218000000_add_shift_cancellation_notification/migration.sql b/api/prisma/migrations/20260218000000_add_shift_cancellation_notification/migration.sql
new file mode 100644
index 00000000..58e852a4
--- /dev/null
+++ b/api/prisma/migrations/20260218000000_add_shift_cancellation_notification/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "site_settings" ADD COLUMN IF NOT EXISTS "notifyAdminShiftCancellation" BOOLEAN NOT NULL DEFAULT true;
diff --git a/api/prisma/migrations/20260218100000_add_gancio_event_id/migration.sql b/api/prisma/migrations/20260218100000_add_gancio_event_id/migration.sql
new file mode 100644
index 00000000..6a8d7f2d
--- /dev/null
+++ b/api/prisma/migrations/20260218100000_add_gancio_event_id/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "shifts" ADD COLUMN "gancioEventId" INTEGER;
diff --git a/api/prisma/migrations/20260218200000_add_enable_events_setting/migration.sql b/api/prisma/migrations/20260218200000_add_enable_events_setting/migration.sql
new file mode 100644
index 00000000..9fcd349a
--- /dev/null
+++ b/api/prisma/migrations/20260218200000_add_enable_events_setting/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "site_settings" ADD COLUMN IF NOT EXISTS "enable_events" BOOLEAN NOT NULL DEFAULT false;
diff --git a/api/prisma/schema.prisma b/api/prisma/schema.prisma
index c54b1619..c0e841ea 100644
--- a/api/prisma/schema.prisma
+++ b/api/prisma/schema.prisma
@@ -647,6 +647,9 @@ model Shift {
series ShiftSeries? @relation(fields: [seriesId], references: [id], onDelete: SetNull)
isException Boolean @default(false)
+ // Gancio event sync
+ gancioEventId Int?
+
createdBy String?
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
@@ -844,6 +847,17 @@ model SiteSettings {
enableMediaFeatures Boolean @default(true) @map("enable_media_features")
enablePayments Boolean @default(false)
enableGalleryAds Boolean @default(false) @map("enable_gallery_ads")
+ enableChat Boolean @default(false) @map("enable_chat")
+ enableEvents Boolean @default(false) @map("enable_events")
+
+ // Notification settings
+ notifyAdminShiftSignup Boolean @default(true)
+ notifyAdminResponseSubmitted Boolean @default(true)
+ notifyAdminSignRequested Boolean @default(true)
+ notifyAdminShiftCancellation Boolean @default(true)
+ notifyVolunteerSessionSummary Boolean @default(true)
+ notifyVolunteerCancellation Boolean @default(true)
+ notifyVolunteerShiftReminder Boolean @default(true)
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
diff --git a/api/prisma/seed.ts b/api/prisma/seed.ts
index 33d5afdd..527f8dd0 100644
--- a/api/prisma/seed.ts
+++ b/api/prisma/seed.ts
@@ -311,6 +311,25 @@ async function main() {
buttonText: 'Buy Now',
},
},
+ {
+ id: 'default-gancio-events',
+ type: 'gancio-events',
+ label: 'Event Calendar',
+ category: 'Content',
+ sortOrder: 12,
+ schema: {
+ maxlength: { type: 'number', label: 'Max Events', default: 10 },
+ theme: { type: 'select', label: 'Theme', options: ['dark', 'light'], default: 'dark' },
+ tags: { type: 'string', label: 'Filter by Tags (comma-separated)' },
+ title: { type: 'string', label: 'Section Title', default: 'Upcoming Events' },
+ },
+ defaults: {
+ maxlength: 10,
+ theme: 'dark',
+ tags: '',
+ title: 'Upcoming Events',
+ },
+ },
];
for (const block of defaultBlocks) {
@@ -531,6 +550,89 @@ async function seedEmailTemplates(admin: { id: string; email: string }) {
{ key: 'ORGANIZATION_NAME', label: 'Organization Name', description: 'Name of the organization', isRequired: true, isConditional: false, sampleValue: 'Changemaker Lite', sortOrder: 7 },
],
},
+ {
+ key: 'admin-shift-signup-alert',
+ name: 'Admin: New Shift Signup Alert',
+ description: 'Notification sent to admins when a volunteer signs up for a shift',
+ category: EmailTemplateCategory.MAP,
+ subjectLine: 'New shift signup — {{SHIFT_TITLE}}',
+ isSystem: true,
+ variables: [
+ { key: 'ORGANIZATION_NAME', label: 'Organization Name', description: 'Name of the organization', isRequired: true, isConditional: false, sampleValue: 'Changemaker Lite', sortOrder: 0 },
+ { key: 'SHIFT_TITLE', label: 'Shift Title', description: 'Title of the shift', isRequired: true, isConditional: false, sampleValue: 'Weekend Canvassing - Downtown', sortOrder: 1 },
+ { key: 'SHIFT_DATE', label: 'Shift Date', description: 'Date of the shift', isRequired: true, isConditional: false, sampleValue: 'Saturday, February 22, 2026', sortOrder: 2 },
+ { key: 'VOLUNTEER_NAME', label: 'Volunteer Name', description: 'Name of the volunteer who signed up', isRequired: true, isConditional: false, sampleValue: 'Jane Doe', sortOrder: 3 },
+ { key: 'VOLUNTEER_EMAIL', label: 'Volunteer Email', description: 'Email of the volunteer', isRequired: true, isConditional: false, sampleValue: 'jane@example.com', sortOrder: 4 },
+ { key: 'SIGNUP_SOURCE', label: 'Signup Source', description: 'How the volunteer signed up (Public Form, Authenticated Volunteer)', isRequired: true, isConditional: false, sampleValue: 'Public Form', sortOrder: 5 },
+ { key: 'ADMIN_URL', label: 'Admin URL', description: 'URL to the admin shifts page', isRequired: true, isConditional: false, sampleValue: 'https://app.cmlite.org/app/map/shifts', sortOrder: 6 },
+ ],
+ },
+ {
+ key: 'admin-response-submitted-alert',
+ name: 'Admin: Response Submitted Alert',
+ description: 'Notification sent to admins when a new response is submitted to the response wall',
+ category: EmailTemplateCategory.INFLUENCE,
+ subjectLine: 'New response submitted — {{CAMPAIGN_TITLE}}',
+ isSystem: true,
+ variables: [
+ { key: 'ORGANIZATION_NAME', label: 'Organization Name', description: 'Name of the organization', isRequired: true, isConditional: false, sampleValue: 'Changemaker Lite', sortOrder: 0 },
+ { key: 'CAMPAIGN_TITLE', label: 'Campaign Title', description: 'Title of the campaign', isRequired: true, isConditional: false, sampleValue: 'Support Climate Action Bill C-12', sortOrder: 1 },
+ { key: 'REPRESENTATIVE_NAME', label: 'Representative Name', description: 'Name of the representative the response is about', isRequired: true, isConditional: false, sampleValue: 'Hon. John Smith', sortOrder: 2 },
+ { key: 'RESPONSE_TYPE', label: 'Response Type', description: 'Type of response (Support, Oppose, etc.)', isRequired: true, isConditional: false, sampleValue: 'SUPPORT', sortOrder: 3 },
+ { key: 'SUBMITTER_NAME', label: 'Submitter Name', description: 'Name of the person who submitted', isRequired: true, isConditional: false, sampleValue: 'Jane Doe', sortOrder: 4 },
+ { key: 'ADMIN_URL', label: 'Admin URL', description: 'URL to the admin responses page', isRequired: true, isConditional: false, sampleValue: 'https://app.cmlite.org/app/influence/responses', sortOrder: 5 },
+ ],
+ },
+ {
+ key: 'admin-sign-requested-alert',
+ name: 'Admin: Sign Requested Alert',
+ description: 'Notification sent to admins when a resident requests a yard sign during canvassing',
+ category: EmailTemplateCategory.MAP,
+ subjectLine: 'Sign requested — {{ADDRESS}}',
+ isSystem: true,
+ variables: [
+ { key: 'ORGANIZATION_NAME', label: 'Organization Name', description: 'Name of the organization', isRequired: true, isConditional: false, sampleValue: 'Changemaker Lite', sortOrder: 0 },
+ { key: 'VOLUNTEER_NAME', label: 'Canvasser Name', description: 'Name of the volunteer who recorded the sign request', isRequired: true, isConditional: false, sampleValue: 'John Smith', sortOrder: 1 },
+ { key: 'ADDRESS', label: 'Address', description: 'Street address where sign was requested', isRequired: true, isConditional: false, sampleValue: '123 Main Street', sortOrder: 2 },
+ { key: 'SHIFT_TITLE', label: 'Shift Title', description: 'Title of the canvassing shift', isRequired: true, isConditional: false, sampleValue: 'Weekend Canvassing - Downtown', sortOrder: 3 },
+ { key: 'SIGN_SIZE', label: 'Sign Size', description: 'Requested sign size', isRequired: false, isConditional: true, sampleValue: 'Large', sortOrder: 4 },
+ { key: 'ADMIN_URL', label: 'Admin URL', description: 'URL to the admin canvass dashboard', isRequired: true, isConditional: false, sampleValue: 'https://app.cmlite.org/app/canvass/dashboard', sortOrder: 5 },
+ ],
+ },
+ {
+ key: 'volunteer-session-summary',
+ name: 'Volunteer: Canvass Session Summary',
+ description: 'Summary email sent to a volunteer after completing a canvassing session',
+ category: EmailTemplateCategory.MAP,
+ subjectLine: 'Canvass session summary — {{CUT_NAME}}',
+ isSystem: true,
+ variables: [
+ { key: 'ORGANIZATION_NAME', label: 'Organization Name', description: 'Name of the organization', isRequired: true, isConditional: false, sampleValue: 'Changemaker Lite', sortOrder: 0 },
+ { key: 'VOLUNTEER_NAME', label: 'Volunteer Name', description: 'Name of the volunteer', isRequired: true, isConditional: false, sampleValue: 'Jane Doe', sortOrder: 1 },
+ { key: 'CUT_NAME', label: 'Cut/Area Name', description: 'Name of the canvassing area', isRequired: true, isConditional: false, sampleValue: 'Downtown Core', sortOrder: 2 },
+ { key: 'SESSION_DATE', label: 'Session Date', description: 'Date of the session', isRequired: true, isConditional: false, sampleValue: 'Saturday, February 22, 2026', sortOrder: 3 },
+ { key: 'VISIT_COUNT', label: 'Visit Count', description: 'Number of doors visited', isRequired: true, isConditional: false, sampleValue: '42', sortOrder: 4 },
+ { key: 'DURATION_MINUTES', label: 'Duration (minutes)', description: 'Session duration in minutes', isRequired: true, isConditional: false, sampleValue: '95', sortOrder: 5 },
+ { key: 'DISTANCE_KM', label: 'Distance (km)', description: 'Distance walked in kilometers', isRequired: true, isConditional: false, sampleValue: '2.3', sortOrder: 6 },
+ { key: 'OUTCOME_BREAKDOWN', label: 'Outcome Breakdown', description: 'HTML table (email) or text list (plain text) of visit outcomes', isRequired: false, isConditional: true, sampleValue: 'Spoke With: 20, Not Home: 15, Refused: 7', sortOrder: 7 },
+ ],
+ },
+ {
+ key: 'volunteer-cancellation-ack',
+ name: 'Volunteer: Signup Cancellation Acknowledgement',
+ description: 'Confirmation email sent to a volunteer when their shift signup is cancelled',
+ category: EmailTemplateCategory.MAP,
+ subjectLine: 'Signup cancelled — {{SHIFT_TITLE}}',
+ isSystem: true,
+ variables: [
+ { key: 'ORGANIZATION_NAME', label: 'Organization Name', description: 'Name of the organization', isRequired: true, isConditional: false, sampleValue: 'Changemaker Lite', sortOrder: 0 },
+ { key: 'VOLUNTEER_NAME', label: 'Volunteer Name', description: 'Name of the volunteer', isRequired: true, isConditional: false, sampleValue: 'Jane Doe', sortOrder: 1 },
+ { key: 'SHIFT_TITLE', label: 'Shift Title', description: 'Title of the cancelled shift signup', isRequired: true, isConditional: false, sampleValue: 'Weekend Canvassing - Downtown', sortOrder: 2 },
+ { key: 'SHIFT_DATE', label: 'Shift Date', description: 'Date of the shift', isRequired: true, isConditional: false, sampleValue: 'Saturday, February 22, 2026', sortOrder: 3 },
+ { key: 'SHIFT_TIME', label: 'Shift Time', description: 'Time range of the shift', isRequired: true, isConditional: false, sampleValue: '10:00 AM — 2:00 PM', sortOrder: 4 },
+ { key: 'SIGNUP_URL', label: 'Signup URL', description: 'URL to browse available shifts', isRequired: true, isConditional: false, sampleValue: 'https://app.cmlite.org/shifts', sortOrder: 5 },
+ ],
+ },
];
let seededCount = 0;
diff --git a/api/src/config/env.ts b/api/src/config/env.ts
index 2f331f19..0a0a3937 100644
--- a/api/src/config/env.ts
+++ b/api/src/config/env.ts
@@ -11,6 +11,11 @@ const envSchema = z.object({
ADMIN_URL: z.string().default('http://localhost:3000'),
DOMAIN: z.string().default('cmlite.org'),
+ // Bunker Ops (Fleet Management)
+ INSTANCE_LABEL: z.string().default(''),
+ BUNKER_OPS_ENABLED: z.string().default('false'),
+ BUNKER_OPS_REMOTE_WRITE_URL: z.string().default(''),
+
// Database
DATABASE_URL: z.string(),
@@ -45,6 +50,7 @@ const envSchema = z.object({
LISTMONK_ADMIN_USER: z.string().default('admin'),
LISTMONK_ADMIN_PASSWORD: z.string().default(''),
LISTMONK_SYNC_ENABLED: z.string().default('false'),
+ LISTMONK_WEBHOOK_SECRET: z.string().default(''),
LISTMONK_PROXY_PORT: z.coerce.number().default(9002),
// Represent API (Canadian electoral data)
@@ -101,6 +107,25 @@ const envSchema = z.object({
HOMEPAGE_URL: z.string().default('http://homepage-changemaker:3000'),
HOMEPAGE_EMBED_PORT: z.coerce.number().default(8887),
+ // Vaultwarden (password manager)
+ VAULTWARDEN_URL: z.string().default('http://vaultwarden-changemaker:80'),
+ VAULTWARDEN_EMBED_PORT: z.coerce.number().default(8890),
+
+ // Rocket.Chat (team chat)
+ ROCKETCHAT_URL: z.string().default('http://rocketchat-changemaker:3000'),
+ ROCKETCHAT_ADMIN_USER: z.string().default(''),
+ ROCKETCHAT_ADMIN_PASSWORD: z.string().default(''),
+ ROCKETCHAT_EMBED_PORT: z.coerce.number().default(8891),
+ ENABLE_CHAT: z.string().default('false'),
+
+ // Gancio (event management)
+ GANCIO_URL: z.string().default('http://gancio-changemaker:13120'),
+ GANCIO_PORT: z.coerce.number().default(8092),
+ GANCIO_EMBED_PORT: z.coerce.number().default(8892),
+ GANCIO_ADMIN_USER: z.string().default('admin'),
+ GANCIO_ADMIN_PASSWORD: z.string().default(''),
+ GANCIO_SYNC_ENABLED: z.string().default('false'),
+
// Pangolin (tunnel / reverse proxy)
PANGOLIN_API_URL: z.string()
.default('')
diff --git a/api/src/modules/dashboard/dashboard.routes.ts b/api/src/modules/dashboard/dashboard.routes.ts
index c4bc1132..07ab0d54 100644
--- a/api/src/modules/dashboard/dashboard.routes.ts
+++ b/api/src/modules/dashboard/dashboard.routes.ts
@@ -9,6 +9,10 @@ import {
getApiMetrics,
getTimeSeries,
getContainerResources,
+ getActivityFeed,
+ getConnectivity,
+ getTodayEvents,
+ getChatSummary,
} from './dashboard.service';
const router = Router();
@@ -121,4 +125,47 @@ router.get('/container-resources', requireRole('SUPER_ADMIN'), async (_req: Requ
}
});
+// GET /api/dashboard/activity — recent activity feed (paginated)
+router.get('/activity', async (req: Request, res: Response, next: NextFunction) => {
+ try {
+ const page = Math.max(1, parseInt(req.query.page as string) || 1);
+ const limit = Math.min(50, Math.max(1, parseInt(req.query.limit as string) || 20));
+ const module = (req.query.module as string) || 'all';
+ const result = await getActivityFeed({ page, limit, module });
+ res.json(result);
+ } catch (err) {
+ next(err);
+ }
+});
+
+// GET /api/dashboard/connectivity — service connectivity checks
+router.get('/connectivity', async (_req: Request, res: Response, next: NextFunction) => {
+ try {
+ const connectivity = await getConnectivity();
+ res.json(connectivity);
+ } catch (err) {
+ next(err);
+ }
+});
+
+// GET /api/dashboard/today-events — today's events from Gancio
+router.get('/today-events', async (_req: Request, res: Response, next: NextFunction) => {
+ try {
+ const events = await getTodayEvents();
+ res.json(events);
+ } catch (err) {
+ next(err);
+ }
+});
+
+// GET /api/dashboard/chat-summary — recent messages from Rocket.Chat
+router.get('/chat-summary', async (_req: Request, res: Response, next: NextFunction) => {
+ try {
+ const summary = await getChatSummary();
+ res.json(summary);
+ } catch (err) {
+ next(err);
+ }
+});
+
export const dashboardRouter = router;
diff --git a/api/src/modules/dashboard/dashboard.service.ts b/api/src/modules/dashboard/dashboard.service.ts
index df1fd899..f4a44bd9 100644
--- a/api/src/modules/dashboard/dashboard.service.ts
+++ b/api/src/modules/dashboard/dashboard.service.ts
@@ -7,6 +7,9 @@ import { env } from '../../config/env';
import { fetchWithTimeout } from '../../utils/fetch-with-timeout';
import { validatePromQLQueries } from '../../utils/promql-validator';
import { isServiceOnline } from '../../utils/health-check';
+import { listmonkClient } from '../../services/listmonk.client';
+import { gancioClient } from '../../services/gancio.client';
+import { rocketchatClient } from '../../services/rocketchat.client';
import { logger } from '../../utils/logger';
// --- Types ---
@@ -264,6 +267,171 @@ export async function getDashboardSummary(): Promise {
};
}
+// --- Activity Feed ---
+
+export interface ActivityItem {
+ id: string;
+ type: 'shift_signup' | 'response_submitted' | 'canvass_completed' | 'email_sent' | 'user_created';
+ module: 'map' | 'influence' | 'users';
+ title: string;
+ description: string;
+ timestamp: string;
+}
+
+export interface ActivityFeedResult {
+ items: ActivityItem[];
+ total: number;
+ page: number;
+ limit: number;
+}
+
+export async function getActivityFeed(opts: {
+ page: number;
+ limit: number;
+ module?: string;
+}): Promise {
+ const { page, limit, module } = opts;
+ const skip = (page - 1) * limit;
+ const since = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000); // last 7 days
+
+ const items: ActivityItem[] = [];
+
+ const queries: Promise[] = [];
+
+ // Shift signups (map module)
+ if (!module || module === 'all' || module === 'map') {
+ queries.push(
+ prisma.shiftSignup.findMany({
+ where: { signupDate: { gte: since }, status: 'CONFIRMED' },
+ orderBy: { signupDate: 'desc' },
+ take: limit * 2,
+ select: { id: true, userName: true, userEmail: true, shiftTitle: true, signupDate: true },
+ }).then(signups => {
+ for (const s of signups) {
+ items.push({
+ id: `signup-${s.id}`,
+ type: 'shift_signup',
+ module: 'map',
+ title: 'Shift Signup',
+ description: `${s.userName || s.userEmail} signed up for ${s.shiftTitle}`,
+ timestamp: s.signupDate.toISOString(),
+ });
+ }
+ }).catch(() => {}),
+ );
+ }
+
+ // Canvass sessions (map module)
+ if (!module || module === 'all' || module === 'map') {
+ queries.push(
+ prisma.canvassSession.findMany({
+ where: { status: 'COMPLETED', endedAt: { gte: since } },
+ orderBy: { endedAt: 'desc' },
+ take: limit * 2,
+ select: { id: true, endedAt: true, userId: true, cut: { select: { name: true } } },
+ }).then(async sessions => {
+ const userIds = sessions.map(s => s.userId);
+ const users = await prisma.user.findMany({
+ where: { id: { in: userIds } },
+ select: { id: true, name: true, email: true },
+ });
+ const userMap = new Map(users.map(u => [u.id, u]));
+ for (const s of sessions) {
+ const user = userMap.get(s.userId);
+ items.push({
+ id: `canvass-${s.id}`,
+ type: 'canvass_completed',
+ module: 'map',
+ title: 'Canvass Completed',
+ description: `${user?.name || user?.email || 'Unknown'} completed a session${s.cut?.name ? ` in ${s.cut.name}` : ''}`,
+ timestamp: (s.endedAt || new Date()).toISOString(),
+ });
+ }
+ }).catch(() => {}),
+ );
+ }
+
+ // Responses (influence module)
+ if (!module || module === 'all' || module === 'influence') {
+ queries.push(
+ prisma.representativeResponse.findMany({
+ where: { createdAt: { gte: since } },
+ orderBy: { createdAt: 'desc' },
+ take: limit * 2,
+ select: { id: true, createdAt: true, submittedByName: true, campaign: { select: { title: true } } },
+ }).then(responses => {
+ for (const r of responses) {
+ items.push({
+ id: `response-${r.id}`,
+ type: 'response_submitted',
+ module: 'influence',
+ title: 'Response Submitted',
+ description: `${r.submittedByName || 'Anonymous'} submitted a response for ${r.campaign.title}`,
+ timestamp: r.createdAt.toISOString(),
+ });
+ }
+ }).catch(() => {}),
+ );
+ }
+
+ // Users (users module)
+ if (!module || module === 'all' || module === 'users') {
+ queries.push(
+ prisma.user.findMany({
+ where: { createdAt: { gte: since } },
+ orderBy: { createdAt: 'desc' },
+ take: limit * 2,
+ select: { id: true, name: true, email: true, role: true, createdAt: true },
+ }).then(users => {
+ for (const u of users) {
+ items.push({
+ id: `user-${u.id}`,
+ type: 'user_created',
+ module: 'users',
+ title: 'New User',
+ description: `${u.name || u.email} (${u.role.replace(/_/g, ' ')})`,
+ timestamp: u.createdAt.toISOString(),
+ });
+ }
+ }).catch(() => {}),
+ );
+ }
+
+ await Promise.all(queries);
+
+ // Sort by timestamp descending, paginate
+ items.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+ const total = items.length;
+ const paged = items.slice(skip, skip + limit);
+
+ return { items: paged, total, page, limit };
+}
+
+// --- Connectivity Checks ---
+
+export interface ConnectivityStatus {
+ smtp: boolean;
+ listmonk: boolean;
+ rocketchat: boolean;
+ gancio: boolean;
+}
+
+export async function getConnectivity(): Promise {
+ const [smtp, listmonk, rocketchat, gancio] = await Promise.all([
+ isServiceOnline(`${env.SMTP_HOST}`, 3000).catch(() => false),
+ listmonkClient.checkHealth().catch(() => false),
+ isServiceOnline(env.ROCKETCHAT_URL || '', 3000).catch(() => false),
+ gancioClient.isAvailable().catch(() => false),
+ ]);
+
+ return {
+ smtp: !!smtp,
+ listmonk: !!listmonk,
+ rocketchat: !!rocketchat,
+ gancio: !!gancio,
+ };
+}
+
export function getSystemInfo(): SystemInfo {
const totalMem = os.totalmem();
const freeMem = os.freemem();
@@ -619,3 +787,140 @@ export async function getApiMetrics(): Promise {
return null;
}
}
+
+// --- Today's Events from Gancio ---
+
+export interface TodayEvent {
+ id: number;
+ title: string;
+ description: string;
+ placeName: string;
+ startTime: string; // ISO string
+ endTime: string | null;
+ tags: string[];
+}
+
+export interface TodayEventsResult {
+ enabled: boolean;
+ events: TodayEvent[];
+ total: number;
+}
+
+export async function getTodayEvents(): Promise {
+ if (!gancioClient.enabled) {
+ return { enabled: false, events: [], total: 0 };
+ }
+
+ try {
+ // Gancio public API: GET /api/events returns all upcoming events
+ const url = `${env.GANCIO_URL}/api/events`;
+ const res = await fetch(url, { signal: AbortSignal.timeout(5000) });
+
+ if (!res.ok) {
+ logger.debug(`Gancio events API returned ${res.status}`);
+ return { enabled: true, events: [], total: 0 };
+ }
+
+ const rawEvents = await res.json() as Array<{
+ id: number;
+ title: string;
+ description: string;
+ place_name: string;
+ place_address: string;
+ start_datetime: number;
+ end_datetime?: number;
+ tags: string[];
+ }>;
+
+ // Filter to today's events (UTC-based day boundaries matching local server time)
+ const now = new Date();
+ const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+ const todayEnd = new Date(todayStart.getTime() + 86400000);
+ const todayStartUnix = Math.floor(todayStart.getTime() / 1000);
+ const todayEndUnix = Math.floor(todayEnd.getTime() / 1000);
+
+ const todayEvents = rawEvents
+ .filter(e => e.start_datetime >= todayStartUnix && e.start_datetime < todayEndUnix)
+ .sort((a, b) => a.start_datetime - b.start_datetime)
+ .slice(0, 20)
+ .map(e => ({
+ id: e.id,
+ title: e.title,
+ description: (e.description || '').slice(0, 200),
+ placeName: e.place_name || '',
+ startTime: new Date(e.start_datetime * 1000).toISOString(),
+ endTime: e.end_datetime ? new Date(e.end_datetime * 1000).toISOString() : null,
+ tags: Array.isArray(e.tags) ? e.tags : [],
+ }));
+
+ return { enabled: true, events: todayEvents, total: todayEvents.length };
+ } catch (err) {
+ logger.debug('Failed to fetch today events from Gancio:', err);
+ return { enabled: true, events: [], total: 0 };
+ }
+}
+
+// --- Chat Summary from Rocket.Chat ---
+
+export interface ChatMessage {
+ id: string;
+ channel: string;
+ username: string;
+ text: string;
+ timestamp: string;
+ isBot: boolean;
+}
+
+export interface ChatSummaryResult {
+ enabled: boolean;
+ messages: ChatMessage[];
+ unreadChannels: number;
+}
+
+export async function getChatSummary(): Promise {
+ const chatEnabled = env.ENABLE_CHAT === 'true';
+ if (!chatEnabled) {
+ return { enabled: false, messages: [], unreadChannels: 0 };
+ }
+
+ try {
+ const online = await rocketchatClient.healthCheck();
+ if (!online) {
+ return { enabled: true, messages: [], unreadChannels: 0 };
+ }
+
+ // Fetch recent messages from our notification channels
+ const channels = ['general', 'shifts', 'canvassing', 'campaigns'];
+ const allMessages: ChatMessage[] = [];
+
+ await Promise.all(
+ channels.map(async (channelName) => {
+ const messages = await rocketchatClient.getChannelHistory(channelName, 5);
+ for (const msg of messages) {
+ if (!msg.msg?.trim()) continue;
+ allMessages.push({
+ id: msg._id,
+ channel: channelName,
+ username: msg.alias || msg.u?.username || 'unknown',
+ text: msg.msg.slice(0, 300),
+ timestamp: msg.ts,
+ isBot: !!(msg.bot || msg.alias),
+ });
+ }
+ }),
+ );
+
+ // Sort by timestamp descending, take most recent 15
+ allMessages.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+ const messages = allMessages.slice(0, 15);
+
+ return {
+ enabled: true,
+ messages,
+ unreadChannels: 0,
+ };
+ } catch (err) {
+ logger.debug('Failed to fetch chat summary:', err);
+ return { enabled: true, messages: [], unreadChannels: 0 };
+ }
+}
diff --git a/api/src/modules/influence/responses/responses.service.ts b/api/src/modules/influence/responses/responses.service.ts
index 99b309eb..9fcfbff0 100644
--- a/api/src/modules/influence/responses/responses.service.ts
+++ b/api/src/modules/influence/responses/responses.service.ts
@@ -1,10 +1,14 @@
import { randomBytes } from 'crypto';
-import { CampaignStatus, Prisma, ResponseStatus } from '@prisma/client';
+import { CampaignStatus, Prisma, ResponseStatus, UserRole } from '@prisma/client';
import { prisma } from '../../../config/database';
import { AppError } from '../../../middleware/error-handler';
import { emailService } from '../../../services/email.service';
+import { notificationQueueService } from '../../../services/notification-queue.service';
+import { getAdminEmailsByRole, isNotificationEnabled } from '../../../services/notification.helper';
import { env } from '../../../config/env';
+import { logger } from '../../../utils/logger';
import { recordResponseSubmission } from '../../../utils/metrics';
+import { rocketchatWebhookService } from '../../../services/rocketchat-webhook.service';
import type {
SubmitResponseInput,
ListPublicResponsesInput,
@@ -77,6 +81,33 @@ export const responsesService = {
recordResponseSubmission();
+ // Notification: admin response submitted alert
+ try {
+ if (await isNotificationEnabled('notifyAdminResponseSubmitted')) {
+ const adminEmails = await getAdminEmailsByRole([UserRole.SUPER_ADMIN, UserRole.INFLUENCE_ADMIN]);
+ if (adminEmails.length > 0) {
+ const adminUrl = `${env.ADMIN_URL || 'http://localhost:3000'}/app/influence/responses`;
+ await notificationQueueService.enqueue({
+ type: 'admin-response-submitted',
+ adminEmails,
+ campaignTitle: campaign.title,
+ representativeName: data.representativeName,
+ responseType: data.responseType,
+ submitterName: data.isAnonymous ? 'Anonymous' : (data.submittedByName || 'Anonymous'),
+ adminUrl,
+ });
+ }
+ }
+ } catch (err) {
+ logger.error('Failed to enqueue response submitted notification:', err);
+ }
+
+ // Notify Rocket.Chat
+ rocketchatWebhookService.onCampaignResponseSubmitted({
+ campaignTitle: campaign.title,
+ representativeName: data.representativeName,
+ }).catch(() => {});
+
return {
id: response.id,
status: response.status,
diff --git a/api/src/modules/listmonk/listmonk-webhook.routes.ts b/api/src/modules/listmonk/listmonk-webhook.routes.ts
new file mode 100644
index 00000000..f5939064
--- /dev/null
+++ b/api/src/modules/listmonk/listmonk-webhook.routes.ts
@@ -0,0 +1,69 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { prisma } from '../../config/database';
+import { env } from '../../config/env';
+import { logger } from '../../utils/logger';
+
+const router = Router();
+
+/**
+ * POST /api/listmonk/webhook?secret=...
+ *
+ * Handles Listmonk webhook events for reverse sync (e.g., unsubscribes).
+ * Validates a shared secret query parameter. No JWT auth — Listmonk calls this.
+ */
+router.post(
+ '/webhook',
+ async (req: Request, res: Response, next: NextFunction) => {
+ try {
+ const secret = req.query.secret as string;
+ if (!env.LISTMONK_WEBHOOK_SECRET || secret !== env.LISTMONK_WEBHOOK_SECRET) {
+ res.status(403).json({ error: 'Invalid webhook secret' });
+ return;
+ }
+
+ const event = req.body;
+ const eventType = event?.event;
+
+ if (eventType === 'subscriber.unsubscribed' || eventType === 'subscriber.disabled') {
+ const email = event?.data?.subscriber?.email;
+ if (!email) {
+ res.json({ ok: true, action: 'skipped', reason: 'no email' });
+ return;
+ }
+
+ // Store opt-out flag in user's permissions JSON field
+ const user = await prisma.user.findUnique({
+ where: { email },
+ select: { id: true, permissions: true },
+ });
+
+ if (user) {
+ const permissions = (user.permissions as Record) || {};
+ permissions.listmonkOptOut = true;
+ permissions.listmonkOptOutAt = new Date().toISOString();
+
+ await prisma.user.update({
+ where: { id: user.id },
+ data: { permissions: permissions as any },
+ });
+
+ logger.info(`Listmonk webhook: marked user ${email} as opted-out`);
+ res.json({ ok: true, action: 'opted_out', email });
+ return;
+ }
+
+ logger.debug(`Listmonk webhook: no user found for ${email}`);
+ res.json({ ok: true, action: 'skipped', reason: 'user not found' });
+ return;
+ }
+
+ // Unknown event type — acknowledge but don't process
+ logger.debug(`Listmonk webhook: unhandled event type "${eventType}"`);
+ res.json({ ok: true, action: 'ignored', eventType });
+ } catch (err) {
+ next(err);
+ }
+ },
+);
+
+export { router as listmonkWebhookRouter };
diff --git a/api/src/modules/listmonk/listmonk.routes.ts b/api/src/modules/listmonk/listmonk.routes.ts
index 19841788..7c7f9cce 100644
--- a/api/src/modules/listmonk/listmonk.routes.ts
+++ b/api/src/modules/listmonk/listmonk.routes.ts
@@ -4,6 +4,7 @@ import { authenticate } from '../../middleware/auth.middleware';
import { requireRole } from '../../middleware/rbac.middleware';
import { listmonkClient } from '../../services/listmonk.client';
import { listmonkSyncService } from '../../services/listmonk-sync.service';
+import { listmonkEventSyncService } from '../../services/listmonk-event-sync.service';
import { env } from '../../config/env';
const router = Router();
@@ -141,6 +142,14 @@ router.post(
},
);
+// GET /api/listmonk/event-sync-stats — event-driven sync stats
+router.get(
+ '/event-sync-stats',
+ (_req: Request, res: Response) => {
+ res.json(listmonkEventSyncService.getStats());
+ },
+);
+
// GET /api/listmonk/proxy-url — get proxy port + token for iframe embedding
router.get(
'/proxy-url',
diff --git a/api/src/modules/map/canvass/canvass-export.routes.ts b/api/src/modules/map/canvass/canvass-export.routes.ts
new file mode 100644
index 00000000..b1bf80c8
--- /dev/null
+++ b/api/src/modules/map/canvass/canvass-export.routes.ts
@@ -0,0 +1,57 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { authenticate } from '../../../middleware/auth.middleware';
+import { requireRole } from '../../../middleware/rbac.middleware';
+import { validate } from '../../../middleware/validate';
+import { exportContactsPreviewSchema, exportContactsSchema } from './canvass-export.schemas';
+import {
+ previewExportContacts,
+ exportContactsToCampaign,
+ getCutCampaignAnalytics,
+} from './canvass-export.service';
+
+const router = Router();
+router.use(authenticate);
+router.use(requireRole('SUPER_ADMIN', 'MAP_ADMIN', 'INFLUENCE_ADMIN'));
+
+// POST /api/map/canvass/export-contacts/preview — preview matching contacts
+router.post(
+ '/export-contacts/preview',
+ validate(exportContactsPreviewSchema),
+ async (req: Request, res: Response, next: NextFunction) => {
+ try {
+ const result = await previewExportContacts(req.body);
+ res.json(result);
+ } catch (err) {
+ next(err);
+ }
+ },
+);
+
+// POST /api/map/canvass/export-contacts — export contacts to campaign
+router.post(
+ '/export-contacts',
+ validate(exportContactsSchema),
+ async (req: Request, res: Response, next: NextFunction) => {
+ try {
+ const result = await exportContactsToCampaign(req.body);
+ res.json(result);
+ } catch (err) {
+ next(err);
+ }
+ },
+);
+
+// GET /api/map/canvass/analytics/cuts — per-cut campaign analytics
+router.get(
+ '/analytics/cuts',
+ async (_req: Request, res: Response, next: NextFunction) => {
+ try {
+ const analytics = await getCutCampaignAnalytics();
+ res.json({ cuts: analytics });
+ } catch (err) {
+ next(err);
+ }
+ },
+);
+
+export { router as canvassExportRouter };
diff --git a/api/src/modules/map/canvass/canvass-export.schemas.ts b/api/src/modules/map/canvass/canvass-export.schemas.ts
new file mode 100644
index 00000000..33b07e69
--- /dev/null
+++ b/api/src/modules/map/canvass/canvass-export.schemas.ts
@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+export const exportContactsPreviewSchema = z.object({
+ cutIds: z.array(z.string()).min(1, 'At least one cut required'),
+ outcomes: z.array(z.enum([
+ 'NOT_HOME', 'REFUSED', 'MOVED', 'ALREADY_VOTED',
+ 'SPOKE_WITH', 'LEFT_LITERATURE', 'COME_BACK_LATER',
+ ])).optional(),
+ supportLevelMin: z.number().int().min(1).max(4).optional(),
+ supportLevelMax: z.number().int().min(1).max(4).optional(),
+ hasEmail: z.boolean().optional(),
+ hasSign: z.boolean().optional(),
+ visitedSince: z.string().datetime().optional(),
+});
+
+export const exportContactsSchema = exportContactsPreviewSchema.extend({
+ campaignId: z.string().min(1, 'Campaign ID required'),
+});
+
+export type ExportContactsPreviewInput = z.infer;
+export type ExportContactsInput = z.infer;
diff --git a/api/src/modules/map/canvass/canvass-export.service.ts b/api/src/modules/map/canvass/canvass-export.service.ts
new file mode 100644
index 00000000..a90df97a
--- /dev/null
+++ b/api/src/modules/map/canvass/canvass-export.service.ts
@@ -0,0 +1,392 @@
+import { Prisma, SupportLevel, VisitOutcome } from '@prisma/client';
+import { prisma } from '../../../config/database';
+import { isPointInPolygon, parseGeoJsonPolygon, calculateBounds } from '../../../utils/spatial';
+import { logger } from '../../../utils/logger';
+import type { ExportContactsPreviewInput, ExportContactsInput } from './canvass-export.schemas';
+
+const SUPPORT_LEVEL_ORDER: Record = {
+ LEVEL_1: 1,
+ LEVEL_2: 2,
+ LEVEL_3: 3,
+ LEVEL_4: 4,
+};
+
+const MAX_EXPORT = 10_000;
+
+// --- Types ---
+
+interface ContactCandidate {
+ addressId: string;
+ firstName: string | null;
+ lastName: string | null;
+ email: string | null;
+ supportLevel: SupportLevel | null;
+ sign: boolean;
+ cutName: string;
+ locationAddress: string;
+ unitNumber: string | null;
+ latestOutcome: VisitOutcome | null;
+ latestVisitDate: Date | null;
+}
+
+export interface ExportPreviewResult {
+ totalContacts: number;
+ contactsWithEmail: number;
+ byCut: { cutId: string; cutName: string; contacts: number; withEmail: number }[];
+ byOutcome: Record;
+ bySupportLevel: Record;
+}
+
+export interface ExportResult {
+ created: number;
+ skippedDuplicate: number;
+ skippedNoEmail: number;
+ campaignId: string;
+ campaignTitle: string;
+}
+
+export interface CutCampaignAnalytics {
+ cutId: string;
+ cutName: string;
+ totalAddresses: number;
+ visitedAddresses: number;
+ completionPct: number;
+ addressesWithEmail: number;
+ supportBreakdown: Record;
+}
+
+// --- Helpers ---
+
+async function resolveContactsFromCuts(
+ filters: ExportContactsPreviewInput,
+): Promise {
+ const cuts = await prisma.cut.findMany({
+ where: { id: { in: filters.cutIds } },
+ select: { id: true, name: true, geojson: true },
+ });
+
+ const allContacts: ContactCandidate[] = [];
+
+ for (const cut of cuts) {
+ const polygons = parseGeoJsonPolygon(cut.geojson);
+
+ // Calculate bounds for a fast DB pre-filter
+ const allCoords = polygons.flat();
+ const bounds = calculateBounds(allCoords);
+
+ const locations = await prisma.location.findMany({
+ where: {
+ latitude: { gte: new Prisma.Decimal(bounds.minLat.toString()), lte: new Prisma.Decimal(bounds.maxLat.toString()) },
+ longitude: { gte: new Prisma.Decimal(bounds.minLng.toString()), lte: new Prisma.Decimal(bounds.maxLng.toString()) },
+ },
+ select: {
+ id: true,
+ latitude: true,
+ longitude: true,
+ address: true,
+ addresses: {
+ select: {
+ id: true,
+ unitNumber: true,
+ firstName: true,
+ lastName: true,
+ email: true,
+ supportLevel: true,
+ sign: true,
+ },
+ },
+ },
+ });
+
+ // In-memory polygon filter
+ for (const loc of locations) {
+ const lat = Number(loc.latitude);
+ const lng = Number(loc.longitude);
+ if (!polygons.some(p => isPointInPolygon(lat, lng, p))) continue;
+
+ for (const addr of loc.addresses) {
+ allContacts.push({
+ addressId: addr.id,
+ firstName: addr.firstName,
+ lastName: addr.lastName,
+ email: addr.email,
+ supportLevel: addr.supportLevel,
+ sign: addr.sign,
+ cutName: cut.name,
+ locationAddress: loc.address,
+ unitNumber: addr.unitNumber,
+ latestOutcome: null,
+ latestVisitDate: null,
+ });
+ }
+ }
+ }
+
+ if (allContacts.length === 0) return [];
+
+ // Fetch latest visit for each address to apply outcome/date filters
+ const addressIds = [...new Set(allContacts.map(c => c.addressId))];
+ const latestVisits = await prisma.canvassVisit.findMany({
+ where: { addressId: { in: addressIds } },
+ distinct: ['addressId'],
+ orderBy: { visitedAt: 'desc' },
+ select: { addressId: true, outcome: true, visitedAt: true },
+ });
+ const visitMap = new Map(latestVisits.map(v => [v.addressId, v]));
+
+ // Annotate contacts with latest visit data
+ for (const contact of allContacts) {
+ const visit = visitMap.get(contact.addressId);
+ if (visit) {
+ contact.latestOutcome = visit.outcome;
+ contact.latestVisitDate = visit.visitedAt;
+ }
+ }
+
+ // Apply filters
+ let filtered = allContacts;
+
+ if (filters.outcomes && filters.outcomes.length > 0) {
+ const outcomeSet = new Set(filters.outcomes);
+ filtered = filtered.filter(c => c.latestOutcome && outcomeSet.has(c.latestOutcome));
+ }
+
+ if (filters.supportLevelMin !== undefined || filters.supportLevelMax !== undefined) {
+ const min = filters.supportLevelMin ?? 1;
+ const max = filters.supportLevelMax ?? 4;
+ filtered = filtered.filter(c => {
+ if (!c.supportLevel) return false;
+ const level = SUPPORT_LEVEL_ORDER[c.supportLevel] ?? 0;
+ return level >= min && level <= max;
+ });
+ }
+
+ if (filters.hasEmail === true) {
+ filtered = filtered.filter(c => !!c.email);
+ }
+
+ if (filters.hasSign === true) {
+ filtered = filtered.filter(c => c.sign);
+ }
+
+ if (filters.visitedSince) {
+ const since = new Date(filters.visitedSince);
+ filtered = filtered.filter(c => c.latestVisitDate && c.latestVisitDate >= since);
+ }
+
+ // Deduplicate by addressId (in case of overlapping cuts)
+ const seen = new Set();
+ const deduped: ContactCandidate[] = [];
+ for (const c of filtered) {
+ if (!seen.has(c.addressId)) {
+ seen.add(c.addressId);
+ deduped.push(c);
+ }
+ }
+
+ return deduped.slice(0, MAX_EXPORT);
+}
+
+// --- Service Functions ---
+
+export async function previewExportContacts(
+ filters: ExportContactsPreviewInput,
+): Promise {
+ const contacts = await resolveContactsFromCuts(filters);
+
+ const byCut: Record = {};
+ const byOutcome: Record = {};
+ const bySupportLevel: Record = {};
+ let withEmail = 0;
+
+ for (const c of contacts) {
+ // By cut
+ const cutKey = c.cutName;
+ if (!byCut[cutKey]) byCut[cutKey] = { cutName: cutKey, contacts: 0, withEmail: 0 };
+ byCut[cutKey].contacts++;
+ if (c.email) {
+ byCut[cutKey].withEmail++;
+ withEmail++;
+ }
+
+ // By outcome
+ if (c.latestOutcome) {
+ byOutcome[c.latestOutcome] = (byOutcome[c.latestOutcome] || 0) + 1;
+ }
+
+ // By support level
+ if (c.supportLevel) {
+ bySupportLevel[c.supportLevel] = (bySupportLevel[c.supportLevel] || 0) + 1;
+ }
+ }
+
+ // Map byCut to array with cutIds
+ const cuts = await prisma.cut.findMany({
+ where: { id: { in: filters.cutIds } },
+ select: { id: true, name: true },
+ });
+ const cutIdMap = new Map(cuts.map(c => [c.name, c.id]));
+
+ return {
+ totalContacts: contacts.length,
+ contactsWithEmail: withEmail,
+ byCut: Object.entries(byCut).map(([name, data]) => ({
+ cutId: cutIdMap.get(name) || '',
+ cutName: name,
+ contacts: data.contacts,
+ withEmail: data.withEmail,
+ })),
+ byOutcome,
+ bySupportLevel,
+ };
+}
+
+export async function exportContactsToCampaign(
+ filters: ExportContactsInput,
+): Promise {
+ const campaign = await prisma.campaign.findUnique({
+ where: { id: filters.campaignId },
+ select: { id: true, title: true, slug: true, allowCustomRecipients: true },
+ });
+
+ if (!campaign) {
+ throw new Error('Campaign not found');
+ }
+
+ // Auto-enable custom recipients if not already
+ if (!campaign.allowCustomRecipients) {
+ await prisma.campaign.update({
+ where: { id: campaign.id },
+ data: { allowCustomRecipients: true },
+ });
+ }
+
+ const contacts = await resolveContactsFromCuts(filters);
+
+ // Get existing custom recipients to deduplicate
+ const existing = await prisma.customRecipient.findMany({
+ where: { campaignId: campaign.id },
+ select: { recipientEmail: true },
+ });
+ const existingEmails = new Set(existing.map(r => r.recipientEmail.toLowerCase()));
+
+ let created = 0;
+ let skippedDuplicate = 0;
+ let skippedNoEmail = 0;
+
+ // Deduplicate by email across all contacts
+ const emailsSeen = new Set();
+
+ const toCreate: Prisma.CustomRecipientCreateManyInput[] = [];
+
+ for (const c of contacts) {
+ if (!c.email) {
+ skippedNoEmail++;
+ continue;
+ }
+
+ const emailLower = c.email.toLowerCase();
+
+ if (existingEmails.has(emailLower) || emailsSeen.has(emailLower)) {
+ skippedDuplicate++;
+ continue;
+ }
+
+ emailsSeen.add(emailLower);
+
+ const name = [c.firstName, c.lastName].filter(Boolean).join(' ') || c.email;
+ const addrLabel = c.unitNumber
+ ? `${c.locationAddress} Unit ${c.unitNumber}`
+ : c.locationAddress;
+
+ toCreate.push({
+ campaignId: campaign.id,
+ campaignSlug: campaign.slug,
+ recipientName: name,
+ recipientEmail: c.email,
+ notes: `From canvass: ${c.cutName} — ${addrLabel}${c.supportLevel ? ` (${c.supportLevel})` : ''}${c.latestOutcome ? ` [${c.latestOutcome}]` : ''}`,
+ });
+ }
+
+ if (toCreate.length > 0) {
+ await prisma.customRecipient.createMany({ data: toCreate });
+ created = toCreate.length;
+ }
+
+ logger.info(`Exported ${created} contacts to campaign "${campaign.title}" (${skippedDuplicate} dupes, ${skippedNoEmail} no email)`);
+
+ return {
+ created,
+ skippedDuplicate,
+ skippedNoEmail,
+ campaignId: campaign.id,
+ campaignTitle: campaign.title,
+ };
+}
+
+export async function getCutCampaignAnalytics(): Promise {
+ const cuts = await prisma.cut.findMany({
+ select: { id: true, name: true, geojson: true },
+ orderBy: { name: 'asc' },
+ });
+
+ const results: CutCampaignAnalytics[] = [];
+
+ for (const cut of cuts) {
+ const polygons = parseGeoJsonPolygon(cut.geojson);
+ const allCoords = polygons.flat();
+ const bounds = calculateBounds(allCoords);
+
+ const locations = await prisma.location.findMany({
+ where: {
+ latitude: { gte: new Prisma.Decimal(bounds.minLat.toString()), lte: new Prisma.Decimal(bounds.maxLat.toString()) },
+ longitude: { gte: new Prisma.Decimal(bounds.minLng.toString()), lte: new Prisma.Decimal(bounds.maxLng.toString()) },
+ },
+ select: {
+ latitude: true,
+ longitude: true,
+ addresses: {
+ select: { id: true, email: true, supportLevel: true },
+ },
+ },
+ });
+
+ let totalAddresses = 0;
+ let addressesWithEmail = 0;
+ const addressIds: string[] = [];
+ const supportBreakdown: Record = {};
+
+ for (const loc of locations) {
+ if (!polygons.some(p => isPointInPolygon(Number(loc.latitude), Number(loc.longitude), p))) continue;
+
+ for (const addr of loc.addresses) {
+ totalAddresses++;
+ addressIds.push(addr.id);
+ if (addr.email) addressesWithEmail++;
+ if (addr.supportLevel) {
+ supportBreakdown[addr.supportLevel] = (supportBreakdown[addr.supportLevel] || 0) + 1;
+ }
+ }
+ }
+
+ const visitedCount = addressIds.length > 0
+ ? await prisma.canvassVisit.findMany({
+ where: { addressId: { in: addressIds } },
+ distinct: ['addressId'],
+ select: { addressId: true },
+ }).then(r => r.length)
+ : 0;
+
+ results.push({
+ cutId: cut.id,
+ cutName: cut.name,
+ totalAddresses,
+ visitedAddresses: visitedCount,
+ completionPct: totalAddresses > 0 ? Math.round((visitedCount / totalAddresses) * 100) : 0,
+ addressesWithEmail,
+ supportBreakdown,
+ });
+ }
+
+ return results;
+}
diff --git a/api/src/modules/map/canvass/canvass.service.ts b/api/src/modules/map/canvass/canvass.service.ts
index 6c9ee0ce..24ff346e 100644
--- a/api/src/modules/map/canvass/canvass.service.ts
+++ b/api/src/modules/map/canvass/canvass.service.ts
@@ -7,6 +7,11 @@ import { recordLocationQuery } from '../../../utils/metrics';
import { isPointInPolygon, parseGeoJsonPolygon } from '../../../utils/spatial';
import { calculateWalkingRoute } from './canvass-route.service';
import { recordCanvassVisit, setActiveCanvassSessions } from '../../../utils/metrics';
+import { notificationQueueService } from '../../../services/notification-queue.service';
+import { getAdminEmailsByRole, isNotificationEnabled } from '../../../services/notification.helper';
+import { env } from '../../../config/env';
+import { rocketchatWebhookService } from '../../../services/rocketchat-webhook.service';
+import { listmonkEventSyncService } from '../../../services/listmonk-event-sync.service';
import type {
RecordVisitInput,
BulkRecordVisitInput,
@@ -237,6 +242,90 @@ export const canvassService = {
// Recalculate cut completion percentage
await this.recalculateCutCompletion(session.cutId);
+ // Notify Rocket.Chat
+ try {
+ const [rcUser, rcCut, rcVisitCount] = await Promise.all([
+ prisma.user.findUnique({ where: { id: userId }, select: { name: true, email: true } }),
+ prisma.cut.findUnique({ where: { id: session.cutId }, select: { name: true } }),
+ prisma.canvassVisit.count({ where: { sessionId } }),
+ ]);
+ rocketchatWebhookService.onCanvassSessionCompleted({
+ userName: rcUser?.name || rcUser?.email || 'Unknown',
+ visitCount: rcVisitCount,
+ cutName: rcCut?.name || undefined,
+ }).catch(() => {});
+ } catch { /* non-critical */ }
+
+ // Notification: volunteer session summary
+ try {
+ if (await isNotificationEnabled('notifyVolunteerSessionSummary')) {
+ const [user, cut, visitCount, outcomeGroups, trackingSession] = await Promise.all([
+ prisma.user.findUnique({ where: { id: userId }, select: { email: true, name: true } }),
+ prisma.cut.findUnique({ where: { id: session.cutId }, select: { name: true } }),
+ prisma.canvassVisit.count({ where: { sessionId } }),
+ prisma.canvassVisit.groupBy({ by: ['outcome'], where: { sessionId }, _count: true }),
+ prisma.trackingSession.findFirst({
+ where: { userId, canvassSessionId: sessionId },
+ select: { totalDistanceM: true },
+ }),
+ ]);
+
+ if (user && visitCount > 0) {
+ const durationMs = updated.endedAt
+ ? updated.endedAt.getTime() - session.startedAt.getTime()
+ : 0;
+ const durationMinutes = Math.round(durationMs / 60000);
+ const distanceKm = trackingSession?.totalDistanceM
+ ? Number(trackingSession.totalDistanceM) / 1000
+ : 0;
+
+ const outcomeBreakdown: Record = {};
+ for (const row of outcomeGroups) {
+ outcomeBreakdown[row.outcome] = row._count;
+ }
+
+ await notificationQueueService.enqueue({
+ type: 'volunteer-session-summary',
+ volunteerEmail: user.email,
+ volunteerName: user.name || user.email,
+ cutName: cut?.name || 'Unknown area',
+ sessionDate: session.startedAt.toLocaleDateString('en-CA', {
+ weekday: 'long', year: 'numeric', month: 'long', day: 'numeric',
+ }),
+ visitCount,
+ durationMinutes,
+ distanceKm,
+ outcomeBreakdown,
+ });
+ }
+ }
+ } catch (err) {
+ logger.error('Failed to enqueue session summary notification:', err);
+ }
+
+ // Listmonk event sync — add canvasser to subscribers
+ try {
+ const [syncUser, syncCut, syncVisitCount, syncOutcomes] = await Promise.all([
+ prisma.user.findUnique({ where: { id: userId }, select: { email: true, name: true } }),
+ prisma.cut.findUnique({ where: { id: session.cutId }, select: { name: true } }),
+ prisma.canvassVisit.count({ where: { sessionId } }),
+ prisma.canvassVisit.groupBy({ by: ['outcome'], where: { sessionId }, _count: true }),
+ ]);
+ if (syncUser) {
+ const outcomes: Record = {};
+ for (const row of syncOutcomes) {
+ outcomes[row.outcome] = row._count;
+ }
+ listmonkEventSyncService.onCanvassSessionCompleted({
+ email: syncUser.email,
+ name: syncUser.name || syncUser.email,
+ cutName: syncCut?.name || 'Unknown',
+ visitCount: syncVisitCount,
+ outcomes,
+ }).catch(() => {});
+ }
+ } catch { /* non-critical */ }
+
return updated;
},
@@ -549,6 +638,36 @@ export const canvassService = {
recordCanvassVisit(data.outcome);
+ // Notification: sign request alert for admins
+ if (data.signRequested) {
+ try {
+ if (await isNotificationEnabled('notifyAdminSignRequested')) {
+ const adminEmails = await getAdminEmailsByRole([UserRole.SUPER_ADMIN, UserRole.MAP_ADMIN]);
+ if (adminEmails.length > 0) {
+ const [volunteer, shift] = await Promise.all([
+ prisma.user.findUnique({ where: { id: userId }, select: { name: true } }),
+ data.shiftId ? prisma.shift.findUnique({ where: { id: data.shiftId }, select: { title: true } }) : null,
+ ]);
+
+ const addressStr = visit.address?.location?.address || 'Unknown address';
+ const adminUrl = `${env.ADMIN_URL || 'http://localhost:3000'}/app/canvass/dashboard`;
+
+ await notificationQueueService.enqueue({
+ type: 'admin-sign-requested',
+ adminEmails,
+ volunteerName: volunteer?.name || 'Unknown',
+ address: addressStr,
+ shiftTitle: shift?.title || 'No shift',
+ signSize: data.signSize || '',
+ adminUrl,
+ });
+ }
+ }
+ } catch (err) {
+ logger.error('Failed to enqueue sign request notification:', err);
+ }
+ }
+
return visit;
},
diff --git a/api/src/modules/map/shifts/shifts.service.ts b/api/src/modules/map/shifts/shifts.service.ts
index af912a72..4bcf1012 100644
--- a/api/src/modules/map/shifts/shifts.service.ts
+++ b/api/src/modules/map/shifts/shifts.service.ts
@@ -1,11 +1,16 @@
import bcrypt from 'bcryptjs';
-import { Prisma, ShiftStatus, SignupStatus, SignupSource } from '@prisma/client';
+import { Prisma, ShiftStatus, SignupStatus, SignupSource, UserRole } from '@prisma/client';
import { prisma } from '../../../config/database';
import { AppError } from '../../../middleware/error-handler';
import { emailService } from '../../../services/email.service';
+import { notificationQueueService } from '../../../services/notification-queue.service';
+import { getAdminEmailsByRole, isNotificationEnabled } from '../../../services/notification.helper';
import { env } from '../../../config/env';
import { logger } from '../../../utils/logger';
import { recordShiftSignup } from '../../../utils/metrics';
+import { rocketchatWebhookService } from '../../../services/rocketchat-webhook.service';
+import { listmonkEventSyncService } from '../../../services/listmonk-event-sync.service';
+import { gancioClient } from '../../../services/gancio.client';
import type {
CreateShiftInput,
UpdateShiftInput,
@@ -121,6 +126,27 @@ export const shiftsService = {
},
});
+ // Gancio event sync (fire-and-forget)
+ if (gancioClient.enabled) {
+ gancioClient.createEvent({
+ title: shift.title,
+ description: shift.description,
+ location: shift.location,
+ date: shift.date,
+ startTime: shift.startTime,
+ endTime: shift.endTime,
+ }).then(async (eventId) => {
+ if (eventId) {
+ await prisma.shift.update({
+ where: { id: shift.id },
+ data: { gancioEventId: eventId },
+ });
+ }
+ }).catch((err) => {
+ logger.warn('Gancio sync on shift create failed:', err);
+ });
+ }
+
return shift;
},
@@ -150,6 +176,20 @@ export const shiftsService = {
data: updateData,
});
+ // Gancio event sync (fire-and-forget)
+ if (gancioClient.enabled && shift.gancioEventId) {
+ gancioClient.updateEvent(shift.gancioEventId, {
+ title: shift.title,
+ description: shift.description,
+ location: shift.location,
+ date: shift.date,
+ startTime: shift.startTime,
+ endTime: shift.endTime,
+ }).catch((err) => {
+ logger.warn('Gancio sync on shift update failed:', err);
+ });
+ }
+
return shift;
},
@@ -159,6 +199,13 @@ export const shiftsService = {
throw new AppError(404, 'Shift not found', 'SHIFT_NOT_FOUND');
}
+ // Delete Gancio event before deleting shift (fire-and-forget)
+ if (gancioClient.enabled && existing.gancioEventId) {
+ gancioClient.deleteEvent(existing.gancioEventId).catch((err) => {
+ logger.warn('Gancio sync on shift delete failed:', err);
+ });
+ }
+
await prisma.shift.delete({ where: { id } });
},
@@ -246,6 +293,14 @@ export const shiftsService = {
}),
]);
+ // Listmonk event sync
+ listmonkEventSyncService.onShiftSignup({
+ email: data.userEmail,
+ name: data.userName || data.userEmail,
+ shiftTitle: shift.title,
+ shiftDate: new Date(shift.date).toISOString().split('T')[0],
+ }).catch(() => {});
+
return signup;
},
@@ -403,8 +458,74 @@ export const shiftsService = {
logger.error('Failed to send shift signup confirmation email:', err);
}
+ // Notify Rocket.Chat
+ const shiftDateStr = new Date(shift.date).toLocaleDateString('en-CA', { month: 'short', day: 'numeric' });
+ rocketchatWebhookService.onShiftSignup({
+ userName: data.name || data.email,
+ shiftTitle: shift.title,
+ shiftDate: shiftDateStr,
+ }).catch(() => {});
+
+ // Notification: admin shift signup alert
+ try {
+ if (await isNotificationEnabled('notifyAdminShiftSignup')) {
+ const adminEmails = await getAdminEmailsByRole([UserRole.SUPER_ADMIN, UserRole.MAP_ADMIN]);
+ if (adminEmails.length > 0) {
+ const adminUrl = `${env.ADMIN_URL || 'http://localhost:3000'}/app/map/shifts`;
+ const shiftDate = new Date(shift.date);
+ const dateStr = shiftDate.toLocaleDateString('en-CA', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
+ await notificationQueueService.enqueue({
+ type: 'admin-shift-signup',
+ adminEmails,
+ shiftTitle: shift.title,
+ shiftDate: dateStr,
+ volunteerName: data.name,
+ volunteerEmail: data.email,
+ signupSource: 'Public Form',
+ adminUrl,
+ });
+ }
+ }
+ } catch (err) {
+ logger.error('Failed to enqueue admin shift signup notification:', err);
+ }
+
+ // Notification: schedule 24h pre-shift reminder
+ try {
+ if (await isNotificationEnabled('notifyVolunteerShiftReminder')) {
+ const shiftDatetime = new Date(shift.date);
+ const [startH, startM] = shift.startTime.split(':').map(Number);
+ shiftDatetime.setHours(startH || 0, startM || 0, 0, 0);
+
+ await notificationQueueService.scheduleShiftReminder({
+ type: 'volunteer-shift-reminder',
+ recipientEmail: data.email,
+ recipientName: data.name,
+ shiftTitle: shift.title,
+ shiftDate: shiftDatetime.toLocaleDateString('en-CA', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }),
+ shiftStartTime: shift.startTime,
+ shiftEndTime: shift.endTime,
+ shiftLocation: shift.location || 'TBD',
+ shiftDescription: shift.description || '',
+ currentVolunteers: shift.currentVolunteers + 1,
+ maxVolunteers: shift.maxVolunteers,
+ shiftStatus: shift.status,
+ }, shiftDatetime);
+ }
+ } catch (err) {
+ logger.error('Failed to schedule shift reminder:', err);
+ }
+
recordShiftSignup();
+ // Listmonk event sync
+ listmonkEventSyncService.onShiftSignup({
+ email: data.email,
+ name: data.name,
+ shiftTitle: shift.title,
+ shiftDate: new Date(shift.date).toISOString().split('T')[0],
+ }).catch(() => {});
+
return { signup, isNewUser };
},
@@ -421,6 +542,8 @@ export const shiftsService = {
throw new AppError(400, 'Signup already cancelled', 'ALREADY_CANCELLED');
}
+ const shift = await prisma.shift.findUnique({ where: { id: shiftId } });
+
await prisma.$transaction([
prisma.shiftSignup.update({
where: { id: signup.id },
@@ -434,6 +557,68 @@ export const shiftsService = {
},
}),
]);
+
+ // Notification: cancellation acknowledgement + cancel reminder
+ try {
+ if (shift && await isNotificationEnabled('notifyVolunteerCancellation')) {
+ const shiftDate = new Date(shift.date);
+ const dateStr = shiftDate.toLocaleDateString('en-CA', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
+ const signupUrl = `${env.CORS_ORIGINS.split(',')[0].trim()}/shifts`;
+ await notificationQueueService.enqueue({
+ type: 'volunteer-cancellation',
+ volunteerEmail: userEmail,
+ volunteerName: signup.userName || userEmail,
+ shiftTitle: shift.title,
+ shiftDate: dateStr,
+ shiftTime: `${shift.startTime} — ${shift.endTime}`,
+ signupUrl,
+ });
+ }
+
+ // Cancel the pending shift reminder
+ if (shift) {
+ const shiftDatetime = new Date(shift.date);
+ const [startH, startM] = shift.startTime.split(':').map(Number);
+ shiftDatetime.setHours(startH || 0, startM || 0, 0, 0);
+ await notificationQueueService.cancelShiftReminder(userEmail, shiftDatetime);
+ }
+ } catch (err) {
+ logger.error('Failed to enqueue cancellation notification:', err);
+ }
+
+ // Notify Rocket.Chat of cancellation
+ if (shift) {
+ const shiftDateStr = new Date(shift.date).toLocaleDateString('en-CA', { month: 'short', day: 'numeric' });
+ rocketchatWebhookService.onShiftCancellation({
+ userName: signup.userName || userEmail,
+ shiftTitle: shift.title,
+ shiftDate: shiftDateStr,
+ }).catch(() => {});
+ }
+
+ // Notification: admin shift cancellation alert
+ try {
+ if (shift && await isNotificationEnabled('notifyAdminShiftCancellation')) {
+ const adminEmails = await getAdminEmailsByRole([UserRole.SUPER_ADMIN, UserRole.MAP_ADMIN]);
+ if (adminEmails.length > 0) {
+ const adminUrl = `${env.ADMIN_URL || 'http://localhost:3000'}/app/map/shifts`;
+ const shiftDate = new Date(shift.date);
+ const dateStr = shiftDate.toLocaleDateString('en-CA', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
+ await notificationQueueService.enqueue({
+ type: 'admin-shift-cancellation',
+ adminEmails,
+ shiftTitle: shift.title,
+ shiftDate: dateStr,
+ volunteerName: signup.userName || userEmail,
+ volunteerEmail: userEmail,
+ cancellationSource: 'Public Form',
+ adminUrl,
+ });
+ }
+ }
+ } catch (err) {
+ logger.error('Failed to enqueue admin shift cancellation notification:', err);
+ }
},
async getUpcomingForVolunteer(userId: string) {
@@ -560,11 +745,77 @@ export const shiftsService = {
logger.error('Failed to send volunteer shift signup confirmation email:', err);
}
+ // Notify Rocket.Chat
+ const shiftDateStr = new Date(shift.date).toLocaleDateString('en-CA', { month: 'short', day: 'numeric' });
+ rocketchatWebhookService.onShiftSignup({
+ userName: user.name || user.email,
+ shiftTitle: shift.title,
+ shiftDate: shiftDateStr,
+ }).catch(() => {});
+
+ // Notification: admin shift signup alert
+ try {
+ if (await isNotificationEnabled('notifyAdminShiftSignup')) {
+ const adminEmails = await getAdminEmailsByRole([UserRole.SUPER_ADMIN, UserRole.MAP_ADMIN]);
+ if (adminEmails.length > 0) {
+ const adminUrl = `${env.ADMIN_URL || 'http://localhost:3000'}/app/map/shifts`;
+ const shiftDate = new Date(shift.date);
+ const dateStr = shiftDate.toLocaleDateString('en-CA', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
+ await notificationQueueService.enqueue({
+ type: 'admin-shift-signup',
+ adminEmails,
+ shiftTitle: shift.title,
+ shiftDate: dateStr,
+ volunteerName: user.name || user.email,
+ volunteerEmail: user.email,
+ signupSource: 'Authenticated Volunteer',
+ adminUrl,
+ });
+ }
+ }
+ } catch (err) {
+ logger.error('Failed to enqueue admin shift signup notification:', err);
+ }
+
+ // Notification: schedule 24h pre-shift reminder
+ try {
+ if (await isNotificationEnabled('notifyVolunteerShiftReminder')) {
+ const shiftDatetime = new Date(shift.date);
+ const [startH, startM] = shift.startTime.split(':').map(Number);
+ shiftDatetime.setHours(startH || 0, startM || 0, 0, 0);
+
+ await notificationQueueService.scheduleShiftReminder({
+ type: 'volunteer-shift-reminder',
+ recipientEmail: user.email,
+ recipientName: user.name || user.email,
+ shiftTitle: shift.title,
+ shiftDate: shiftDatetime.toLocaleDateString('en-CA', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }),
+ shiftStartTime: shift.startTime,
+ shiftEndTime: shift.endTime,
+ shiftLocation: shift.location || 'TBD',
+ shiftDescription: shift.description || '',
+ currentVolunteers: shift.currentVolunteers + 1,
+ maxVolunteers: shift.maxVolunteers,
+ shiftStatus: shift.status,
+ }, shiftDatetime);
+ }
+ } catch (err) {
+ logger.error('Failed to schedule shift reminder:', err);
+ }
+
+ // Listmonk event sync
+ listmonkEventSyncService.onShiftSignup({
+ email: user.email,
+ name: user.name || user.email,
+ shiftTitle: shift.title,
+ shiftDate: new Date(shift.date).toISOString().split('T')[0],
+ }).catch(() => {});
+
return signup;
},
async cancelVolunteerSignup(shiftId: string, userId: string) {
- const user = await prisma.user.findUnique({ where: { id: userId }, select: { email: true } });
+ const user = await prisma.user.findUnique({ where: { id: userId }, select: { email: true, name: true } });
if (!user) throw new AppError(404, 'User not found', 'USER_NOT_FOUND');
const signup = await prisma.shiftSignup.findUnique({
@@ -574,6 +825,8 @@ export const shiftsService = {
if (!signup) throw new AppError(404, 'Signup not found', 'SIGNUP_NOT_FOUND');
if (signup.status === SignupStatus.CANCELLED) throw new AppError(400, 'Already cancelled', 'ALREADY_CANCELLED');
+ const shift = await prisma.shift.findUnique({ where: { id: shiftId } });
+
await prisma.$transaction([
prisma.shiftSignup.update({
where: { id: signup.id },
@@ -587,6 +840,68 @@ export const shiftsService = {
},
}),
]);
+
+ // Notification: cancellation acknowledgement + cancel reminder
+ try {
+ if (shift && await isNotificationEnabled('notifyVolunteerCancellation')) {
+ const shiftDate = new Date(shift.date);
+ const dateStr = shiftDate.toLocaleDateString('en-CA', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
+ const signupUrl = `${env.CORS_ORIGINS.split(',')[0].trim()}/shifts`;
+ await notificationQueueService.enqueue({
+ type: 'volunteer-cancellation',
+ volunteerEmail: user.email,
+ volunteerName: user.name || user.email,
+ shiftTitle: shift.title,
+ shiftDate: dateStr,
+ shiftTime: `${shift.startTime} — ${shift.endTime}`,
+ signupUrl,
+ });
+ }
+
+ // Cancel the pending shift reminder
+ if (shift) {
+ const shiftDatetime = new Date(shift.date);
+ const [startH, startM] = shift.startTime.split(':').map(Number);
+ shiftDatetime.setHours(startH || 0, startM || 0, 0, 0);
+ await notificationQueueService.cancelShiftReminder(user.email, shiftDatetime);
+ }
+ } catch (err) {
+ logger.error('Failed to enqueue cancellation notification:', err);
+ }
+
+ // Notify Rocket.Chat of cancellation
+ if (shift) {
+ const shiftDateStr = new Date(shift.date).toLocaleDateString('en-CA', { month: 'short', day: 'numeric' });
+ rocketchatWebhookService.onShiftCancellation({
+ userName: user.name || user.email,
+ shiftTitle: shift.title,
+ shiftDate: shiftDateStr,
+ }).catch(() => {});
+ }
+
+ // Notification: admin shift cancellation alert
+ try {
+ if (shift && await isNotificationEnabled('notifyAdminShiftCancellation')) {
+ const adminEmails = await getAdminEmailsByRole([UserRole.SUPER_ADMIN, UserRole.MAP_ADMIN]);
+ if (adminEmails.length > 0) {
+ const adminUrl = `${env.ADMIN_URL || 'http://localhost:3000'}/app/map/shifts`;
+ const shiftDate = new Date(shift.date);
+ const dateStr = shiftDate.toLocaleDateString('en-CA', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
+ await notificationQueueService.enqueue({
+ type: 'admin-shift-cancellation',
+ adminEmails,
+ shiftTitle: shift.title,
+ shiftDate: dateStr,
+ volunteerName: user.name || user.email,
+ volunteerEmail: user.email,
+ cancellationSource: 'Volunteer Portal',
+ adminUrl,
+ });
+ }
+ }
+ } catch (err) {
+ logger.error('Failed to enqueue admin shift cancellation notification:', err);
+ }
},
async getMySignups(userId: string) {
diff --git a/api/src/modules/rocketchat/rocketchat.routes.ts b/api/src/modules/rocketchat/rocketchat.routes.ts
new file mode 100644
index 00000000..df42f7e5
--- /dev/null
+++ b/api/src/modules/rocketchat/rocketchat.routes.ts
@@ -0,0 +1,81 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { authenticate } from '../../middleware/auth.middleware';
+import { requireNonTemp } from '../../middleware/rbac.middleware';
+import { env } from '../../config/env';
+import { logger } from '../../utils/logger';
+import { rocketchatClient } from '../../services/rocketchat.client';
+import { rocketchatService } from './rocketchat.service';
+import { siteSettingsService } from '../settings/settings.service';
+
+const router = Router();
+
+/** Check if chat is enabled (DB setting wins, env var is fallback for first boot) */
+async function isChatEnabled(): Promise {
+ try {
+ const settings = await siteSettingsService.get();
+ // DB setting is authoritative; env var is the initial default
+ return settings.enableChat;
+ } catch {
+ return env.ENABLE_CHAT === 'true';
+ }
+}
+
+// GET /api/rocketchat/status — health check (any authenticated user)
+router.get(
+ '/status',
+ authenticate,
+ async (_req: Request, res: Response, next: NextFunction) => {
+ try {
+ const enabled = await isChatEnabled();
+ const online = enabled ? await rocketchatClient.healthCheck() : false;
+ res.json({ online, enabled });
+ } catch (err) {
+ logger.error('RC status check failed:', err);
+ next(err);
+ }
+ },
+);
+
+// GET /api/rocketchat/config — return RC URLs + enabled status
+router.get(
+ '/config',
+ authenticate,
+ async (_req: Request, res: Response, _next: NextFunction) => {
+ const enabled = await isChatEnabled();
+ res.json({
+ enabled,
+ embedPort: env.ROCKETCHAT_EMBED_PORT,
+ subdomain: 'chat',
+ domain: env.DOMAIN,
+ });
+ },
+);
+
+// POST /api/rocketchat/auth — get RC session token for current user (SSO)
+router.post(
+ '/auth',
+ authenticate,
+ requireNonTemp,
+ async (req: Request, res: Response, next: NextFunction) => {
+ try {
+ const enabled = await isChatEnabled();
+ if (!enabled) {
+ res.status(400).json({ error: 'Chat is not enabled' });
+ return;
+ }
+
+ const userId = req.user!.id;
+ const tokenData = await rocketchatService.getAuthToken(userId);
+
+ res.json({
+ authToken: tokenData.authToken,
+ rcUserId: tokenData.rcUserId,
+ });
+ } catch (err) {
+ logger.error('RC auth failed:', err);
+ next(err);
+ }
+ },
+);
+
+export const rocketchatRouter = router;
diff --git a/api/src/modules/rocketchat/rocketchat.service.ts b/api/src/modules/rocketchat/rocketchat.service.ts
new file mode 100644
index 00000000..f92e2176
--- /dev/null
+++ b/api/src/modules/rocketchat/rocketchat.service.ts
@@ -0,0 +1,129 @@
+import { createHmac } from 'crypto';
+import { prisma } from '../../config/database';
+import { env } from '../../config/env';
+import { logger } from '../../utils/logger';
+import { rocketchatClient } from '../../services/rocketchat.client';
+
+// Changemaker role → Rocket.Chat role mapping
+const ROLE_MAP: Record = {
+ SUPER_ADMIN: ['admin'],
+ INFLUENCE_ADMIN: ['moderator'],
+ MAP_ADMIN: ['moderator'],
+ USER: ['user'],
+ TEMP: ['user'],
+};
+
+/**
+ * Generate a deterministic password for a Rocket.Chat user.
+ * Never exposed to users — only used for RC internal auth.
+ */
+function generateRCPassword(userId: string): string {
+ return createHmac('sha256', env.JWT_ACCESS_SECRET)
+ .update(`rc:${userId}`)
+ .digest('hex');
+}
+
+/**
+ * Generate a safe username from email, with collision avoidance suffix.
+ */
+function generateUsername(email: string, suffix = 0): string {
+ const base = email.split('@')[0].toLowerCase().replace(/[^a-z0-9._-]/g, '');
+ return suffix > 0 ? `${base}${suffix}` : base;
+}
+
+class RocketChatService {
+ /**
+ * Get a Rocket.Chat auth token for the given Changemaker user.
+ * Provisions / syncs the RC user as needed.
+ */
+ async getAuthToken(changemakerUserId: string): Promise<{
+ authToken: string;
+ rcUserId: string;
+ }> {
+ // 1. Look up Changemaker user
+ const user = await prisma.user.findUnique({
+ where: { id: changemakerUserId },
+ });
+ if (!user) throw new Error('User not found');
+
+ // 2. Check for cached RC user ID in permissions JSON
+ const permissions = (user.permissions as Record) || {};
+ let rcUserId = permissions._rcUserId as string | undefined;
+
+ if (rcUserId) {
+ // Sync roles on every access
+ const rcRoles = ROLE_MAP[user.role] || ['user'];
+ try {
+ await rocketchatClient.updateUser(rcUserId, {
+ name: user.name || user.email.split('@')[0],
+ roles: rcRoles,
+ });
+ } catch (err) {
+ logger.warn('RC role sync failed, continuing:', err);
+ }
+ } else {
+ // 3. Find or create RC user
+ let rcUser = await rocketchatClient.findUserByEmail(user.email);
+
+ if (!rcUser) {
+ // Generate unique username with collision handling
+ let username = generateUsername(user.email);
+ let suffix = 0;
+ const maxAttempts = 5;
+ while (suffix < maxAttempts) {
+ try {
+ rcUser = await rocketchatClient.createUser({
+ email: user.email,
+ name: user.name || user.email.split('@')[0],
+ username,
+ password: generateRCPassword(user.id),
+ roles: ROLE_MAP[user.role] || ['user'],
+ });
+ break;
+ } catch (err) {
+ if (err instanceof Error && err.message.includes('already in use')) {
+ suffix++;
+ username = generateUsername(user.email, suffix);
+ } else {
+ throw err;
+ }
+ }
+ }
+ if (!rcUser) throw new Error('Failed to create RC user after retries');
+ }
+
+ rcUserId = rcUser._id;
+
+ // 4. Cache RC user ID in permissions JSON (no migration needed)
+ await prisma.user.update({
+ where: { id: user.id },
+ data: {
+ permissions: { ...permissions, _rcUserId: rcUserId },
+ },
+ });
+ }
+
+ // 5. Generate login token
+ const tokenData = await rocketchatClient.createUserToken(rcUserId);
+ return {
+ authToken: tokenData.authToken,
+ rcUserId: tokenData.userId,
+ };
+ }
+
+ /**
+ * Setup default channels on first use
+ */
+ async ensureDefaultChannels(): Promise {
+ try {
+ await rocketchatClient.ensureChannel('shifts', 'Shift coordination and updates');
+ await rocketchatClient.ensureChannel('canvassing', 'Canvass activity and updates');
+ await rocketchatClient.ensureChannel('campaigns', 'Campaign activity and responses');
+ logger.info('RC default channels verified');
+ } catch (err) {
+ logger.warn('RC ensureDefaultChannels failed:', err);
+ }
+ }
+}
+
+export const rocketchatService = new RocketChatService();
diff --git a/api/src/modules/services/services.routes.ts b/api/src/modules/services/services.routes.ts
index d66a2161..5e1bd336 100644
--- a/api/src/modules/services/services.routes.ts
+++ b/api/src/modules/services/services.routes.ts
@@ -17,7 +17,7 @@ router.get(
'/status',
async (_req: Request, res: Response, next: NextFunction) => {
try {
- const [nocodbOnline, n8nOnline, giteaOnline, mailhogOnline, miniqrOnline, excalidrawOnline, homepageOnline] = await Promise.all([
+ const [nocodbOnline, n8nOnline, giteaOnline, mailhogOnline, miniqrOnline, excalidrawOnline, homepageOnline, vaultwardenOnline, rocketchatOnline, gancioOnline] = await Promise.all([
isServiceOnline(env.NOCODB_URL),
isServiceOnline(env.N8N_URL),
isServiceOnline(env.GITEA_URL),
@@ -25,6 +25,9 @@ router.get(
isServiceOnline(env.MINI_QR_URL),
isServiceOnline(env.EXCALIDRAW_URL),
isServiceOnline(env.HOMEPAGE_URL),
+ isServiceOnline(env.VAULTWARDEN_URL),
+ isServiceOnline(`${env.ROCKETCHAT_URL}/api/info`),
+ isServiceOnline(env.GANCIO_URL),
]);
// Update Prometheus gauges
@@ -35,6 +38,9 @@ router.get(
setServiceUp('miniqr', miniqrOnline);
setServiceUp('excalidraw', excalidrawOnline);
setServiceUp('homepage', homepageOnline);
+ setServiceUp('vaultwarden', vaultwardenOnline);
+ setServiceUp('rocketchat', rocketchatOnline);
+ setServiceUp('gancio', gancioOnline);
res.json({
nocodb: { online: nocodbOnline, url: env.NOCODB_URL },
@@ -44,6 +50,9 @@ router.get(
miniqr: { online: miniqrOnline, url: env.MINI_QR_URL },
excalidraw: { online: excalidrawOnline, url: env.EXCALIDRAW_URL },
homepage: { online: homepageOnline, url: env.HOMEPAGE_URL },
+ vaultwarden: { online: vaultwardenOnline, url: env.VAULTWARDEN_URL },
+ rocketchat: { online: rocketchatOnline, url: env.ROCKETCHAT_URL },
+ gancio: { online: gancioOnline, url: env.GANCIO_URL },
});
} catch (err) {
logger.error('Failed to check services status', err);
@@ -88,6 +97,15 @@ router.get(
// Homepage (service dashboard)
homepagePort: env.HOMEPAGE_EMBED_PORT,
homepageSubdomain: 'home',
+ // Vaultwarden (password manager)
+ vaultwardenPort: env.VAULTWARDEN_EMBED_PORT,
+ vaultwardenSubdomain: 'vault',
+ // Rocket.Chat (team chat)
+ rocketchatPort: env.ROCKETCHAT_EMBED_PORT,
+ rocketchatSubdomain: 'chat',
+ // Gancio (event management)
+ gancioPort: env.GANCIO_EMBED_PORT,
+ gancioSubdomain: 'events',
});
},
);
diff --git a/api/src/modules/settings/settings.schemas.ts b/api/src/modules/settings/settings.schemas.ts
index 7ac0ec9e..2cb797e1 100644
--- a/api/src/modules/settings/settings.schemas.ts
+++ b/api/src/modules/settings/settings.schemas.ts
@@ -49,6 +49,17 @@ export const updateSiteSettingsSchema = z.object({
enableMediaFeatures: z.boolean().optional(),
enablePayments: z.boolean().optional(),
enableGalleryAds: z.boolean().optional(),
+ enableChat: z.boolean().optional(),
+ enableEvents: z.boolean().optional(),
+
+ // Notification settings
+ notifyAdminShiftSignup: z.boolean().optional(),
+ notifyAdminResponseSubmitted: z.boolean().optional(),
+ notifyAdminSignRequested: z.boolean().optional(),
+ notifyAdminShiftCancellation: z.boolean().optional(),
+ notifyVolunteerSessionSummary: z.boolean().optional(),
+ notifyVolunteerCancellation: z.boolean().optional(),
+ notifyVolunteerShiftReminder: z.boolean().optional(),
});
export type UpdateSiteSettingsInput = z.infer;
diff --git a/api/src/server.ts b/api/src/server.ts
index d528a3e2..c98fec6a 100644
--- a/api/src/server.ts
+++ b/api/src/server.ts
@@ -27,6 +27,7 @@ import shiftSeriesRouter from './modules/map/shifts/shift-series.routes';
import { mapSettingsRouter } from './modules/map/settings/settings.routes';
import { qrRouter } from './modules/qr/qr.routes';
import { listmonkRouter } from './modules/listmonk/listmonk.routes';
+import { listmonkWebhookRouter } from './modules/listmonk/listmonk-webhook.routes';
import { pagesPublicRouter } from './modules/pages/pages-public.routes';
import { pagesAdminRouter } from './modules/pages/pages-admin.routes';
import { blocksRouter } from './modules/pages/blocks.routes';
@@ -34,9 +35,12 @@ import { docsRouter } from './modules/docs/docs.routes';
import { servicesRouter } from './modules/services/services.routes';
import { siteSettingsRouter } from './modules/settings/settings.routes';
import { canvassVolunteerRouter, canvassAdminRouter } from './modules/map/canvass/canvass.routes';
+import { canvassExportRouter } from './modules/map/canvass/canvass-export.routes';
import { trackingVolunteerRouter, trackingAdminRouter } from './modules/map/tracking/tracking.routes';
import { geocodingRouter } from './modules/map/geocoding/geocoding.routes';
import { pangolinRouter } from './modules/pangolin/pangolin.routes';
+import { rocketchatRouter } from './modules/rocketchat/rocketchat.routes';
+import { rocketchatWebhookService } from './services/rocketchat-webhook.service';
import { narImportRouter } from './modules/map/locations/nar-import.routes';
import { areaImportRouter } from './modules/map/locations/area-import.routes';
import emailTemplatesRouter from './modules/email-templates/email-templates-admin.routes';
@@ -45,6 +49,7 @@ import { dashboardRouter } from './modules/dashboard/dashboard.routes';
import { initEncryption } from './utils/crypto';
import { emailService } from './services/email.service';
import { emailQueueService } from './services/email-queue.service';
+import { notificationQueueService } from './services/notification-queue.service';
import { geocodeQueueService } from './services/geocode-queue.service';
import { startProxy, stopProxy } from './services/listmonk-proxy.service';
import { pagesService } from './modules/pages/pages.service';
@@ -167,6 +172,7 @@ app.use('/api/map/shifts', shiftsAdminRouter); // Admin shift CRUD (au
app.use('/api/map/geocoding', geocodingRouter); // Geocoding search (MAP_ADMIN+)
app.use('/api/map/settings', mapSettingsRouter); // Map settings (public GET, auth PUT)
app.use('/api/qr', qrRouter); // QR code generation (public)
+app.use('/api/listmonk', listmonkWebhookRouter); // Listmonk webhook (shared secret, no JWT)
app.use('/api/listmonk', listmonkRouter); // Listmonk newsletter sync (SUPER_ADMIN)
app.use('/api/email-templates', emailTemplatesRouter); // Email template management (ADMIN roles)
app.use('/api/pages', pagesPublicRouter); // Public landing pages (no auth)
@@ -176,10 +182,12 @@ app.use('/api/docs', docsRouter); // Docs status + config
app.use('/api/services', servicesRouter); // Platform services status (SUPER_ADMIN)
app.use('/api/map/canvass', canvassVolunteerRouter); // Volunteer canvass routes (auth required)
app.use('/api/map/canvass', canvassAdminRouter); // Admin canvass routes (MAP_ADMIN+)
+app.use('/api/map/canvass', canvassExportRouter); // Canvass-to-campaign export (admin roles)
app.use('/api/map/tracking', trackingVolunteerRouter); // Volunteer GPS tracking (auth required)
app.use('/api/map/tracking', trackingAdminRouter); // Admin GPS tracking (MAP_ADMIN+)
app.use('/api/settings', siteSettingsRouter); // Site settings (public GET, SUPER_ADMIN PUT)
app.use('/api/pangolin', pangolinRouter); // Pangolin tunnel management (SUPER_ADMIN)
+app.use('/api/rocketchat', rocketchatRouter); // Rocket.Chat SSO + status (auth required)
app.use('/api/observability', observabilityRouter); // Observability / monitoring (SUPER_ADMIN)
app.use('/api/dashboard', dashboardRouter); // Dashboard summary (ADMIN roles)
app.use('/api/payments', paymentsPublicRouter); // Public payment routes (plans, checkout, my subscription)
@@ -210,6 +218,7 @@ async function start() {
await emailService.rebuildTransporter();
emailQueueService.startWorker();
+ notificationQueueService.startWorker();
geocodeQueueService.startWorker();
startProxy();
@@ -239,6 +248,9 @@ async function start() {
docsAnalyticsService.cleanupOldData(90).catch(() => {});
setInterval(() => docsAnalyticsService.cleanupOldData(90).catch(() => {}), 24 * 60 * 60 * 1000);
+ // Setup Rocket.Chat notification channels (non-blocking)
+ rocketchatWebhookService.setupChannels().catch(() => {});
+
// Sync MkDocs overrides on startup
pagesService.syncOverrides()
.then(({ imported, updated }) => {
@@ -283,6 +295,7 @@ for (const signal of ['SIGTERM', 'SIGINT']) {
logger.info(`${signal} received, shutting down...`);
await stopProxy();
await emailQueueService.close();
+ await notificationQueueService.close();
await geocodeQueueService.close();
await prisma.$disconnect();
redis.disconnect();
diff --git a/api/src/services/email-queue.service.ts b/api/src/services/email-queue.service.ts
index 87debabc..3ebc30d9 100644
--- a/api/src/services/email-queue.service.ts
+++ b/api/src/services/email-queue.service.ts
@@ -5,6 +5,7 @@ import { prisma } from '../config/database';
import { logger } from '../utils/logger';
import { emailService } from './email.service';
import { recordEmailSent, recordEmailFailed, setEmailQueueSize, emailSendDuration } from '../utils/metrics';
+import { listmonkEventSyncService } from './listmonk-event-sync.service';
interface CampaignEmailJobData {
campaignEmailId: string;
@@ -65,6 +66,13 @@ class EmailQueueService {
if (result.success) {
recordEmailSent(campaignId);
+ // Listmonk event sync
+ listmonkEventSyncService.onCampaignEmailSent({
+ email: emailData.userEmail,
+ name: emailData.userName,
+ campaignSlug: emailData.campaignTitle,
+ postalCode: emailData.postalCode,
+ }).catch(() => {});
} else {
recordEmailFailed(campaignId, 'send_failure');
throw new Error(`Failed to send email to ${emailData.recipientEmail}`);
diff --git a/api/src/services/email.service.ts b/api/src/services/email.service.ts
index 79fdf29a..af7ddfbe 100644
--- a/api/src/services/email.service.ts
+++ b/api/src/services/email.service.ts
@@ -748,6 +748,260 @@ class EmailService {
});
}
+ // ─── Notification Emails ────────────────────────────────────────────
+
+ async sendAdminShiftSignupAlert(options: {
+ adminEmails: string[];
+ shiftTitle: string;
+ shiftDate: string;
+ volunteerName: string;
+ volunteerEmail: string;
+ signupSource: string;
+ adminUrl: string;
+ }): Promise {
+ const orgName = await this.getOrganizationName();
+ const vars: Record = {
+ ORGANIZATION_NAME: orgName,
+ SHIFT_TITLE: options.shiftTitle,
+ SHIFT_DATE: options.shiftDate,
+ VOLUNTEER_NAME: options.volunteerName,
+ VOLUNTEER_EMAIL: options.volunteerEmail,
+ SIGNUP_SOURCE: options.signupSource,
+ ADMIN_URL: options.adminUrl,
+ };
+
+ const dbTemplate = await this.loadTemplateFromDatabase('admin-shift-signup-alert');
+
+ let html: string, text: string, subject: string;
+ if (dbTemplate) {
+ html = await this.processTemplate(dbTemplate.html, vars);
+ text = await this.processTextTemplate(dbTemplate.text, vars);
+ subject = this.processSubject(dbTemplate.subject, vars);
+ } else {
+ const htmlTemplate = this.loadTemplate('admin-shift-signup-alert', 'html');
+ const txtTemplate = this.loadTemplate('admin-shift-signup-alert', 'txt');
+ html = await this.processTemplate(htmlTemplate, vars);
+ text = await this.processTextTemplate(txtTemplate, vars);
+ subject = `New shift signup — ${options.shiftTitle}`;
+ }
+
+ for (const email of options.adminEmails) {
+ await this.sendEmail({ to: email, subject, html, text });
+ }
+ }
+
+ async sendAdminShiftCancellationAlert(options: {
+ adminEmails: string[];
+ shiftTitle: string;
+ shiftDate: string;
+ volunteerName: string;
+ volunteerEmail: string;
+ cancellationSource: string;
+ adminUrl: string;
+ }): Promise {
+ const orgName = await this.getOrganizationName();
+ const vars: Record = {
+ ORGANIZATION_NAME: orgName,
+ SHIFT_TITLE: options.shiftTitle,
+ SHIFT_DATE: options.shiftDate,
+ VOLUNTEER_NAME: options.volunteerName,
+ VOLUNTEER_EMAIL: options.volunteerEmail,
+ CANCELLATION_SOURCE: options.cancellationSource,
+ ADMIN_URL: options.adminUrl,
+ };
+
+ const dbTemplate = await this.loadTemplateFromDatabase('admin-shift-cancellation-alert');
+
+ let html: string, text: string, subject: string;
+ if (dbTemplate) {
+ html = await this.processTemplate(dbTemplate.html, vars);
+ text = await this.processTextTemplate(dbTemplate.text, vars);
+ subject = this.processSubject(dbTemplate.subject, vars);
+ } else {
+ const htmlTemplate = this.loadTemplate('admin-shift-cancellation-alert', 'html');
+ const txtTemplate = this.loadTemplate('admin-shift-cancellation-alert', 'txt');
+ html = await this.processTemplate(htmlTemplate, vars);
+ text = await this.processTextTemplate(txtTemplate, vars);
+ subject = `Shift cancellation — ${options.shiftTitle}`;
+ }
+
+ for (const email of options.adminEmails) {
+ await this.sendEmail({ to: email, subject, html, text });
+ }
+ }
+
+ async sendAdminResponseSubmittedAlert(options: {
+ adminEmails: string[];
+ campaignTitle: string;
+ representativeName: string;
+ responseType: string;
+ submitterName: string;
+ adminUrl: string;
+ }): Promise {
+ const orgName = await this.getOrganizationName();
+ const vars: Record = {
+ ORGANIZATION_NAME: orgName,
+ CAMPAIGN_TITLE: options.campaignTitle,
+ REPRESENTATIVE_NAME: options.representativeName,
+ RESPONSE_TYPE: options.responseType.replace(/_/g, ' '),
+ SUBMITTER_NAME: options.submitterName,
+ ADMIN_URL: options.adminUrl,
+ };
+
+ const dbTemplate = await this.loadTemplateFromDatabase('admin-response-submitted-alert');
+
+ let html: string, text: string, subject: string;
+ if (dbTemplate) {
+ html = await this.processTemplate(dbTemplate.html, vars);
+ text = await this.processTextTemplate(dbTemplate.text, vars);
+ subject = this.processSubject(dbTemplate.subject, vars);
+ } else {
+ const htmlTemplate = this.loadTemplate('admin-response-submitted-alert', 'html');
+ const txtTemplate = this.loadTemplate('admin-response-submitted-alert', 'txt');
+ html = await this.processTemplate(htmlTemplate, vars);
+ text = await this.processTextTemplate(txtTemplate, vars);
+ subject = `New response submitted — ${options.campaignTitle}`;
+ }
+
+ for (const email of options.adminEmails) {
+ await this.sendEmail({ to: email, subject, html, text });
+ }
+ }
+
+ async sendAdminSignRequestedAlert(options: {
+ adminEmails: string[];
+ volunteerName: string;
+ address: string;
+ shiftTitle: string;
+ signSize: string;
+ adminUrl: string;
+ }): Promise {
+ const orgName = await this.getOrganizationName();
+ const vars: Record = {
+ ORGANIZATION_NAME: orgName,
+ VOLUNTEER_NAME: options.volunteerName,
+ ADDRESS: options.address,
+ SHIFT_TITLE: options.shiftTitle,
+ SIGN_SIZE: options.signSize || 'Not specified',
+ ADMIN_URL: options.adminUrl,
+ };
+
+ const dbTemplate = await this.loadTemplateFromDatabase('admin-sign-requested-alert');
+
+ let html: string, text: string, subject: string;
+ if (dbTemplate) {
+ html = await this.processTemplate(dbTemplate.html, vars);
+ text = await this.processTextTemplate(dbTemplate.text, vars);
+ subject = this.processSubject(dbTemplate.subject, vars);
+ } else {
+ const htmlTemplate = this.loadTemplate('admin-sign-requested-alert', 'html');
+ const txtTemplate = this.loadTemplate('admin-sign-requested-alert', 'txt');
+ html = await this.processTemplate(htmlTemplate, vars);
+ text = await this.processTextTemplate(txtTemplate, vars);
+ subject = `Sign requested — ${options.address}`;
+ }
+
+ for (const email of options.adminEmails) {
+ await this.sendEmail({ to: email, subject, html, text });
+ }
+ }
+
+ async sendVolunteerSessionSummary(options: {
+ volunteerEmail: string;
+ volunteerName: string;
+ cutName: string;
+ sessionDate: string;
+ visitCount: number;
+ durationMinutes: number;
+ distanceKm: number;
+ outcomeBreakdown: Record;
+ }): Promise {
+ const orgName = await this.getOrganizationName();
+
+ // Build outcome breakdown as HTML table and plain text list
+ const outcomeEntries = Object.entries(options.outcomeBreakdown);
+ let outcomeHtml = '';
+ let outcomeText = '';
+
+ if (outcomeEntries.length > 0) {
+ outcomeHtml = '| Outcome | Count |
|---|
';
+ outcomeText = 'Outcome Breakdown:\n';
+ for (const [outcome, count] of outcomeEntries) {
+ const label = outcome.replace(/_/g, ' ');
+ outcomeHtml += `| ${this.escapeHtml(label)} | ${count} |
`;
+ outcomeText += ` ${label}: ${count}\n`;
+ }
+ outcomeHtml += '
';
+ }
+
+ const vars: Record = {
+ ORGANIZATION_NAME: orgName,
+ VOLUNTEER_NAME: options.volunteerName,
+ CUT_NAME: options.cutName,
+ SESSION_DATE: options.sessionDate,
+ VISIT_COUNT: options.visitCount.toString(),
+ DURATION_MINUTES: options.durationMinutes.toString(),
+ DISTANCE_KM: options.distanceKm.toFixed(1),
+ OUTCOME_BREAKDOWN: outcomeHtml,
+ };
+
+ const dbTemplate = await this.loadTemplateFromDatabase('volunteer-session-summary');
+
+ let html: string, text: string, subject: string;
+ if (dbTemplate) {
+ html = await this.processTemplate(dbTemplate.html, vars);
+ // Use plain text breakdown for text version
+ vars.OUTCOME_BREAKDOWN = outcomeText;
+ text = await this.processTextTemplate(dbTemplate.text, vars);
+ subject = this.processSubject(dbTemplate.subject, vars);
+ } else {
+ const htmlTemplate = this.loadTemplate('volunteer-session-summary', 'html');
+ const txtTemplate = this.loadTemplate('volunteer-session-summary', 'txt');
+ html = await this.processTemplate(htmlTemplate, vars);
+ vars.OUTCOME_BREAKDOWN = outcomeText;
+ text = await this.processTextTemplate(txtTemplate, vars);
+ subject = `Canvass session summary — ${options.cutName}`;
+ }
+
+ await this.sendEmail({ to: options.volunteerEmail, subject, html, text });
+ }
+
+ async sendVolunteerCancellationAck(options: {
+ volunteerEmail: string;
+ volunteerName: string;
+ shiftTitle: string;
+ shiftDate: string;
+ shiftTime: string;
+ signupUrl: string;
+ }): Promise {
+ const orgName = await this.getOrganizationName();
+ const vars: Record = {
+ ORGANIZATION_NAME: orgName,
+ VOLUNTEER_NAME: options.volunteerName,
+ SHIFT_TITLE: options.shiftTitle,
+ SHIFT_DATE: options.shiftDate,
+ SHIFT_TIME: options.shiftTime,
+ SIGNUP_URL: options.signupUrl,
+ };
+
+ const dbTemplate = await this.loadTemplateFromDatabase('volunteer-cancellation-ack');
+
+ let html: string, text: string, subject: string;
+ if (dbTemplate) {
+ html = await this.processTemplate(dbTemplate.html, vars);
+ text = await this.processTextTemplate(dbTemplate.text, vars);
+ subject = this.processSubject(dbTemplate.subject, vars);
+ } else {
+ const htmlTemplate = this.loadTemplate('volunteer-cancellation-ack', 'html');
+ const txtTemplate = this.loadTemplate('volunteer-cancellation-ack', 'txt');
+ html = await this.processTemplate(htmlTemplate, vars);
+ text = await this.processTextTemplate(txtTemplate, vars);
+ subject = `Signup cancelled — ${options.shiftTitle}`;
+ }
+
+ await this.sendEmail({ to: options.volunteerEmail, subject, html, text });
+ }
+
async sendResponseVerification(options: {
recipientEmail: string;
campaignTitle: string;
diff --git a/api/src/services/gancio.client.ts b/api/src/services/gancio.client.ts
new file mode 100644
index 00000000..1f7cec95
--- /dev/null
+++ b/api/src/services/gancio.client.ts
@@ -0,0 +1,246 @@
+import { env } from '../config/env';
+import { logger } from '../utils/logger';
+
+// --- Types ---
+
+export interface GancioEvent {
+ id: number;
+ title: string;
+ description: string;
+ place_name: string;
+ place_address: string;
+ start_datetime: number; // Unix timestamp
+ end_datetime?: number;
+ tags: string[];
+}
+
+interface GancioLoginResponse {
+ access_token: string;
+ token_type: string;
+}
+
+// --- Client ---
+
+class GancioClient {
+ private accessToken: string | null = null;
+ private tokenExpiresAt = 0;
+
+ private get baseUrl(): string {
+ return env.GANCIO_URL;
+ }
+
+ get enabled(): boolean {
+ return env.GANCIO_SYNC_ENABLED === 'true' && !!env.GANCIO_ADMIN_PASSWORD;
+ }
+
+ /**
+ * Authenticate with Gancio OAuth password grant, cache token for 1 hour.
+ * Gancio uses POST /oauth/login with application/x-www-form-urlencoded body
+ * (oauth2orize standard). Fields: username, password, client_id="self", grant_type="password".
+ */
+ private async login(): Promise {
+ if (this.accessToken && Date.now() < this.tokenExpiresAt) return;
+
+ const url = `${this.baseUrl}/oauth/login`;
+ const controller = new AbortController();
+ const timeout = setTimeout(() => controller.abort(), 10000);
+
+ // Gancio's oauth2orize endpoint requires URL-encoded form data (not JSON)
+ const formBody = new URLSearchParams({
+ username: env.GANCIO_ADMIN_USER,
+ password: env.GANCIO_ADMIN_PASSWORD,
+ client_id: 'self',
+ grant_type: 'password',
+ });
+
+ try {
+ const res = await fetch(url, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+ body: formBody.toString(),
+ signal: controller.signal,
+ });
+
+ if (!res.ok) {
+ const text = await res.text().catch(() => '');
+ throw new Error(`Gancio login failed (${res.status}): ${text}`);
+ }
+
+ const data = await res.json() as GancioLoginResponse;
+ this.accessToken = data.access_token;
+ // Cache for 1 hour
+ this.tokenExpiresAt = Date.now() + 60 * 60 * 1000;
+ logger.debug('Gancio auth token refreshed');
+ } finally {
+ clearTimeout(timeout);
+ }
+ }
+
+ /**
+ * Make an authenticated JSON request to the Gancio API
+ */
+ private async request(
+ method: string,
+ path: string,
+ body?: Record,
+ ): Promise {
+ await this.login();
+
+ const url = `${this.baseUrl}${path}`;
+ const controller = new AbortController();
+ const timeout = setTimeout(() => controller.abort(), 10000);
+
+ const headers: Record = {};
+ if (this.accessToken) {
+ headers['Authorization'] = `Bearer ${this.accessToken}`;
+ }
+
+ let fetchBody: string | undefined;
+ if (body) {
+ headers['Content-Type'] = 'application/json';
+ fetchBody = JSON.stringify(body);
+ }
+
+ try {
+ const res = await fetch(url, {
+ method,
+ headers,
+ body: fetchBody,
+ signal: controller.signal,
+ });
+
+ if (!res.ok) {
+ const text = await res.text().catch(() => '');
+ throw new Error(`Gancio API ${method} ${path} returned ${res.status}: ${text}`);
+ }
+
+ const contentType = res.headers.get('content-type') || '';
+ if (contentType.includes('application/json')) {
+ return await res.json() as T;
+ }
+ return {} as T;
+ } finally {
+ clearTimeout(timeout);
+ }
+ }
+
+ // --- Health ---
+
+ async isAvailable(): Promise {
+ try {
+ const controller = new AbortController();
+ const timeout = setTimeout(() => controller.abort(), 5000);
+ try {
+ const res = await fetch(`${this.baseUrl}/api/events`, {
+ signal: controller.signal,
+ });
+ return res.ok;
+ } finally {
+ clearTimeout(timeout);
+ }
+ } catch {
+ return false;
+ }
+ }
+
+ // --- Event CRUD ---
+
+ /**
+ * Create a Gancio event from a shift
+ */
+ async createEvent(shift: {
+ title: string;
+ description?: string | null;
+ location?: string | null;
+ date: Date;
+ startTime: string;
+ endTime: string;
+ }): Promise {
+ if (!this.enabled) return null;
+
+ try {
+ const startDatetime = this.buildTimestamp(shift.date, shift.startTime);
+ const endDatetime = this.buildTimestamp(shift.date, shift.endTime);
+ const placeName = shift.location || 'TBD';
+
+ const event = await this.request('POST', '/api/event', {
+ title: shift.title,
+ description: shift.description || '',
+ place_name: placeName,
+ place_address: shift.location || placeName,
+ start_datetime: startDatetime,
+ end_datetime: endDatetime,
+ tags: ['volunteer', 'shift'],
+ });
+
+ logger.info(`Gancio: created event ${event.id} for shift "${shift.title}"`);
+ return event.id;
+ } catch (err) {
+ logger.warn('Gancio createEvent failed:', err instanceof Error ? err.message : err);
+ return null;
+ }
+ }
+
+ /**
+ * Update an existing Gancio event
+ */
+ async updateEvent(eventId: number, shift: {
+ title: string;
+ description?: string | null;
+ location?: string | null;
+ date: Date;
+ startTime: string;
+ endTime: string;
+ }): Promise {
+ if (!this.enabled) return;
+
+ try {
+ const startDatetime = this.buildTimestamp(shift.date, shift.startTime);
+ const endDatetime = this.buildTimestamp(shift.date, shift.endTime);
+ const placeName = shift.location || 'TBD';
+
+ await this.request('PUT', '/api/event', {
+ id: eventId,
+ title: shift.title,
+ description: shift.description || '',
+ place_name: placeName,
+ place_address: shift.location || placeName,
+ start_datetime: startDatetime,
+ end_datetime: endDatetime,
+ tags: ['volunteer', 'shift'],
+ });
+
+ logger.info(`Gancio: updated event ${eventId}`);
+ } catch (err) {
+ logger.warn(`Gancio updateEvent(${eventId}) failed:`, err instanceof Error ? err.message : err);
+ }
+ }
+
+ /**
+ * Delete a Gancio event
+ */
+ async deleteEvent(eventId: number): Promise {
+ if (!this.enabled) return;
+
+ try {
+ await this.request('DELETE', `/api/event/${eventId}`);
+ logger.info(`Gancio: deleted event ${eventId}`);
+ } catch (err) {
+ logger.warn(`Gancio deleteEvent(${eventId}) failed:`, err instanceof Error ? err.message : err);
+ }
+ }
+
+ // --- Helpers ---
+
+ /**
+ * Combine a Date and "HH:MM" time string into a Unix timestamp (seconds)
+ */
+ private buildTimestamp(date: Date, time: string): number {
+ const d = new Date(date);
+ const [h, m] = time.split(':').map(Number);
+ d.setHours(h || 0, m || 0, 0, 0);
+ return Math.floor(d.getTime() / 1000);
+ }
+}
+
+export const gancioClient = new GancioClient();
diff --git a/api/src/services/listmonk-event-sync.service.ts b/api/src/services/listmonk-event-sync.service.ts
new file mode 100644
index 00000000..5fececb4
--- /dev/null
+++ b/api/src/services/listmonk-event-sync.service.ts
@@ -0,0 +1,153 @@
+import { env } from '../config/env';
+import { logger } from '../utils/logger';
+import { listmonkClient } from './listmonk.client';
+import { listmonkSyncService } from './listmonk-sync.service';
+
+/**
+ * Event-driven Listmonk sync — fire-and-forget subscriber upserts
+ * triggered by application events (shift signups, canvass completions, campaign emails).
+ *
+ * All methods silently fail if LISTMONK_SYNC_ENABLED is false or Listmonk is unreachable.
+ */
+class ListmonkEventSyncService {
+ private _lastSyncAt: Date | null = null;
+ private _todaySyncCount = 0;
+ private _todayDate = '';
+
+ private get enabled(): boolean {
+ return env.LISTMONK_SYNC_ENABLED === 'true';
+ }
+
+ private incrementCounter(): void {
+ const today = new Date().toISOString().split('T')[0];
+ if (today !== this._todayDate) {
+ this._todayDate = today;
+ this._todaySyncCount = 0;
+ }
+ this._todaySyncCount++;
+ this._lastSyncAt = new Date();
+ }
+
+ /**
+ * Sync a shift signup to Listmonk "All Contacts" + "Volunteers" lists.
+ */
+ async onShiftSignup(data: {
+ email: string;
+ name: string;
+ shiftTitle: string;
+ shiftDate: string;
+ cutName?: string;
+ }): Promise {
+ if (!this.enabled) return;
+
+ try {
+ await listmonkSyncService.ensureInitialized();
+ const allContactsId = listmonkSyncService.getListId('All Contacts');
+ const volunteersId = listmonkSyncService.getListId('Volunteers');
+ if (!allContactsId || !volunteersId) return;
+
+ await listmonkClient.upsertSubscriber(
+ data.email,
+ data.name,
+ [allContactsId, volunteersId],
+ {
+ source: 'shift_signup',
+ last_shift_title: data.shiftTitle,
+ last_shift_date: data.shiftDate,
+ cut_name: data.cutName || null,
+ last_synced: new Date().toISOString(),
+ },
+ );
+ this.incrementCounter();
+ logger.debug(`Listmonk event sync: shift signup for ${data.email}`);
+ } catch (err) {
+ logger.debug('Listmonk event sync failed (onShiftSignup):', err);
+ }
+ }
+
+ /**
+ * Sync a completed canvass session to Listmonk "All Contacts" + "Canvassers" lists.
+ */
+ async onCanvassSessionCompleted(data: {
+ email: string;
+ name: string;
+ cutName: string;
+ visitCount: number;
+ outcomes: Record;
+ }): Promise {
+ if (!this.enabled) return;
+
+ try {
+ await listmonkSyncService.ensureInitialized();
+ const allContactsId = listmonkSyncService.getListId('All Contacts');
+ const canvassersId = listmonkSyncService.getListId('Canvassers');
+ if (!allContactsId || !canvassersId) return;
+
+ await listmonkClient.upsertSubscriber(
+ data.email,
+ data.name,
+ [allContactsId, canvassersId],
+ {
+ source: 'canvasser',
+ last_cut: data.cutName,
+ last_visit_count: data.visitCount,
+ last_outcomes: data.outcomes,
+ last_synced: new Date().toISOString(),
+ },
+ );
+ this.incrementCounter();
+ logger.debug(`Listmonk event sync: canvass session for ${data.email}`);
+ } catch (err) {
+ logger.debug('Listmonk event sync failed (onCanvassSessionCompleted):', err);
+ }
+ }
+
+ /**
+ * Sync a sent campaign email to Listmonk "All Contacts" + "Campaign Participants" lists.
+ */
+ async onCampaignEmailSent(data: {
+ email: string;
+ name: string;
+ campaignSlug: string;
+ postalCode?: string;
+ }): Promise {
+ if (!this.enabled) return;
+
+ try {
+ await listmonkSyncService.ensureInitialized();
+ const allContactsId = listmonkSyncService.getListId('All Contacts');
+ const participantsId = listmonkSyncService.getListId('Campaign Participants');
+ if (!allContactsId || !participantsId) return;
+
+ await listmonkClient.upsertSubscriber(
+ data.email,
+ data.name,
+ [allContactsId, participantsId],
+ {
+ source: 'campaign_participant',
+ campaign_slug: data.campaignSlug,
+ postal_code: data.postalCode || null,
+ last_synced: new Date().toISOString(),
+ },
+ );
+ this.incrementCounter();
+ logger.debug(`Listmonk event sync: campaign email for ${data.email}`);
+ } catch (err) {
+ logger.debug('Listmonk event sync failed (onCampaignEmailSent):', err);
+ }
+ }
+
+ getStats(): {
+ enabled: boolean;
+ lastSyncAt: string | null;
+ todaySyncCount: number;
+ } {
+ return {
+ enabled: this.enabled,
+ lastSyncAt: this._lastSyncAt?.toISOString() || null,
+ todaySyncCount: this._todaySyncCount,
+ };
+ }
+}
+
+export const listmonkEventSyncService = new ListmonkEventSyncService();
diff --git a/api/src/services/listmonk-sync.service.ts b/api/src/services/listmonk-sync.service.ts
index e0e62612..1b1601c8 100644
--- a/api/src/services/listmonk-sync.service.ts
+++ b/api/src/services/listmonk-sync.service.ts
@@ -15,6 +15,8 @@ const LIST_DEFINITIONS: Array<{ name: string; tags: string[] }> = [
{ name: 'Support Level 4 (Opposition)', tags: ['v2', 'map', 'support'] },
{ name: 'Has Campaign Sign', tags: ['v2', 'map', 'signs'] },
{ name: 'Users', tags: ['v2', 'users'] },
+ { name: 'Volunteers', tags: ['v2', 'map', 'shifts'] },
+ { name: 'Canvassers', tags: ['v2', 'map', 'canvass'] },
];
const SUPPORT_LEVEL_LIST_MAP: Record = {
@@ -49,12 +51,16 @@ class ListmonkSyncService {
logger.info('Listmonk lists initialized', { listIds: this.listIds });
}
- private async ensureInitialized(): Promise {
+ async ensureInitialized(): Promise {
if (!this.initialized) {
await this.initializeLists();
}
}
+ getListId(name: string): number | undefined {
+ return this.listIds[name];
+ }
+
async syncCampaignParticipants(): Promise {
await this.ensureInitialized();
const result: BulkSyncResult = { total: 0, success: 0, failed: 0, errors: [] };
diff --git a/api/src/services/notification-queue.service.ts b/api/src/services/notification-queue.service.ts
new file mode 100644
index 00000000..0a338c3a
--- /dev/null
+++ b/api/src/services/notification-queue.service.ts
@@ -0,0 +1,228 @@
+import { Queue, Worker, type Job } from 'bullmq';
+import { env } from '../config/env';
+import { logger } from '../utils/logger';
+import { emailService } from './email.service';
+
+// ─── Job Data Types ────────────────────────────────────────────────
+
+interface AdminShiftSignupJob {
+ type: 'admin-shift-signup';
+ adminEmails: string[];
+ shiftTitle: string;
+ shiftDate: string;
+ volunteerName: string;
+ volunteerEmail: string;
+ signupSource: string;
+ adminUrl: string;
+}
+
+interface AdminResponseSubmittedJob {
+ type: 'admin-response-submitted';
+ adminEmails: string[];
+ campaignTitle: string;
+ representativeName: string;
+ responseType: string;
+ submitterName: string;
+ adminUrl: string;
+}
+
+interface AdminSignRequestedJob {
+ type: 'admin-sign-requested';
+ adminEmails: string[];
+ volunteerName: string;
+ address: string;
+ shiftTitle: string;
+ signSize: string;
+ adminUrl: string;
+}
+
+interface AdminShiftCancellationJob {
+ type: 'admin-shift-cancellation';
+ adminEmails: string[];
+ shiftTitle: string;
+ shiftDate: string;
+ volunteerName: string;
+ volunteerEmail: string;
+ cancellationSource: string;
+ adminUrl: string;
+}
+
+interface VolunteerSessionSummaryJob {
+ type: 'volunteer-session-summary';
+ volunteerEmail: string;
+ volunteerName: string;
+ cutName: string;
+ sessionDate: string;
+ visitCount: number;
+ durationMinutes: number;
+ distanceKm: number;
+ outcomeBreakdown: Record;
+}
+
+interface VolunteerCancellationJob {
+ type: 'volunteer-cancellation';
+ volunteerEmail: string;
+ volunteerName: string;
+ shiftTitle: string;
+ shiftDate: string;
+ shiftTime: string;
+ signupUrl: string;
+}
+
+interface VolunteerShiftReminderJob {
+ type: 'volunteer-shift-reminder';
+ recipientEmail: string;
+ recipientName: string;
+ shiftTitle: string;
+ shiftDate: string;
+ shiftStartTime: string;
+ shiftEndTime: string;
+ shiftLocation: string;
+ shiftDescription: string;
+ currentVolunteers: number;
+ maxVolunteers: number;
+ shiftStatus: string;
+}
+
+type NotificationJobData =
+ | AdminShiftSignupJob
+ | AdminResponseSubmittedJob
+ | AdminSignRequestedJob
+ | AdminShiftCancellationJob
+ | VolunteerSessionSummaryJob
+ | VolunteerCancellationJob
+ | VolunteerShiftReminderJob;
+
+// ─── Queue Service ─────────────────────────────────────────────────
+
+class NotificationQueueService {
+ private queue: Queue;
+ private worker: Worker | null = null;
+
+ constructor() {
+ this.queue = new Queue('notification-emails', {
+ connection: { url: env.REDIS_URL },
+ defaultJobOptions: {
+ attempts: 3,
+ backoff: { type: 'exponential', delay: 5000 },
+ removeOnComplete: { age: 24 * 60 * 60, count: 500 },
+ removeOnFail: { age: 7 * 24 * 60 * 60 },
+ },
+ });
+ }
+
+ startWorker() {
+ this.worker = new Worker(
+ 'notification-emails',
+ async (job: Job) => {
+ const { data } = job;
+ logger.info(`Processing notification job ${job.id} type=${data.type}`);
+
+ switch (data.type) {
+ case 'admin-shift-signup':
+ await emailService.sendAdminShiftSignupAlert(data);
+ break;
+ case 'admin-response-submitted':
+ await emailService.sendAdminResponseSubmittedAlert(data);
+ break;
+ case 'admin-sign-requested':
+ await emailService.sendAdminSignRequestedAlert(data);
+ break;
+ case 'admin-shift-cancellation':
+ await emailService.sendAdminShiftCancellationAlert(data);
+ break;
+ case 'volunteer-session-summary':
+ await emailService.sendVolunteerSessionSummary(data);
+ break;
+ case 'volunteer-cancellation':
+ await emailService.sendVolunteerCancellationAck(data);
+ break;
+ case 'volunteer-shift-reminder':
+ await emailService.sendShiftDetailsEmail({
+ recipientEmail: data.recipientEmail,
+ recipientName: data.recipientName,
+ shiftTitle: data.shiftTitle,
+ shiftDate: data.shiftDate,
+ shiftStartTime: data.shiftStartTime,
+ shiftEndTime: data.shiftEndTime,
+ shiftLocation: data.shiftLocation,
+ shiftDescription: data.shiftDescription,
+ currentVolunteers: data.currentVolunteers,
+ maxVolunteers: data.maxVolunteers,
+ shiftStatus: data.shiftStatus,
+ });
+ break;
+ }
+ },
+ {
+ connection: { url: env.REDIS_URL },
+ concurrency: 2,
+ },
+ );
+
+ this.worker.on('completed', (job) => {
+ logger.info(`Notification job ${job.id} completed`);
+ });
+
+ this.worker.on('failed', (job, err) => {
+ logger.error(`Notification job ${job?.id} failed: ${err.message}`);
+ });
+
+ logger.info('Notification queue worker started');
+ }
+
+ /** Enqueue an immediate notification job. */
+ async enqueue(data: NotificationJobData): Promise {
+ const job = await this.queue.add(data.type, data);
+ return job.id!;
+ }
+
+ /**
+ * Schedule a shift reminder as a delayed job.
+ * Uses a deterministic jobId so we can cancel it later.
+ */
+ async scheduleShiftReminder(
+ data: VolunteerShiftReminderJob,
+ shiftDatetime: Date,
+ ): Promise {
+ const reminderTime = new Date(shiftDatetime.getTime() - 24 * 60 * 60 * 1000);
+ const delay = reminderTime.getTime() - Date.now();
+
+ if (delay <= 0) {
+ logger.debug('Shift is less than 24h away, skipping reminder scheduling');
+ return null;
+ }
+
+ const jobId = `shift-reminder-${data.recipientEmail}-${shiftDatetime.getTime()}`;
+ const job = await this.queue.add(data.type, data, {
+ delay,
+ jobId,
+ });
+ logger.info(`Scheduled shift reminder jobId=${jobId} delay=${Math.round(delay / 60000)}min`);
+ return job.id!;
+ }
+
+ /** Cancel a pending shift reminder. */
+ async cancelShiftReminder(email: string, shiftDatetime: Date): Promise {
+ const jobId = `shift-reminder-${email}-${shiftDatetime.getTime()}`;
+ try {
+ const job = await this.queue.getJob(jobId);
+ if (job) {
+ await job.remove();
+ logger.info(`Cancelled shift reminder jobId=${jobId}`);
+ }
+ } catch (err) {
+ logger.warn(`Failed to cancel shift reminder jobId=${jobId}:`, err);
+ }
+ }
+
+ async close() {
+ if (this.worker) {
+ await this.worker.close();
+ }
+ await this.queue.close();
+ logger.info('Notification queue closed');
+ }
+}
+
+export const notificationQueueService = new NotificationQueueService();
diff --git a/api/src/services/notification.helper.ts b/api/src/services/notification.helper.ts
new file mode 100644
index 00000000..0130a3a9
--- /dev/null
+++ b/api/src/services/notification.helper.ts
@@ -0,0 +1,33 @@
+import { UserRole, UserStatus } from '@prisma/client';
+import { prisma } from '../config/database';
+import { siteSettingsService } from '../modules/settings/settings.service';
+import { logger } from '../utils/logger';
+
+/**
+ * Fetch email addresses for active admin users with the specified role(s).
+ */
+export async function getAdminEmailsByRole(roles: UserRole[]): Promise {
+ const users = await prisma.user.findMany({
+ where: {
+ role: { in: roles },
+ status: UserStatus.ACTIVE,
+ },
+ select: { email: true },
+ });
+ return users.map((u) => u.email);
+}
+
+/**
+ * Check whether a specific notification toggle is enabled in SiteSettings.
+ * Fail-open: returns true if the field is missing or settings query fails.
+ */
+export async function isNotificationEnabled(key: string): Promise {
+ try {
+ const settings = await siteSettingsService.get();
+ const value = (settings as Record)[key];
+ return value !== false;
+ } catch (err) {
+ logger.warn(`Failed to read notification setting "${key}", defaulting to enabled:`, err);
+ return true;
+ }
+}
diff --git a/api/src/services/rocketchat-webhook.service.ts b/api/src/services/rocketchat-webhook.service.ts
new file mode 100644
index 00000000..726f9e77
--- /dev/null
+++ b/api/src/services/rocketchat-webhook.service.ts
@@ -0,0 +1,78 @@
+import { env } from '../config/env';
+import { logger } from '../utils/logger';
+import { rocketchatClient } from './rocketchat.client';
+
+class RocketChatWebhookService {
+ private get enabled(): boolean {
+ return env.ENABLE_CHAT === 'true';
+ }
+
+ /**
+ * Post a notification to a Rocket.Chat channel.
+ * Silently fails if chat is disabled or RC is unreachable.
+ */
+ private async notify(channel: string, text: string, color?: string): Promise {
+ if (!this.enabled) return;
+ try {
+ await rocketchatClient.postMessage(channel, text, 'Changemaker Bot');
+ } catch (err) {
+ logger.debug(`RC notification to ${channel} failed (non-critical):`, err);
+ }
+ }
+
+ // --- Event Formatters ---
+
+ async onShiftSignup(data: {
+ userName: string;
+ shiftTitle: string;
+ shiftDate: string;
+ }): Promise {
+ const text = `:calendar: **${data.userName}** signed up for shift: *${data.shiftTitle}* (${data.shiftDate})`;
+ await this.notify('#shifts', text, '#27ae60');
+ }
+
+ async onShiftCancellation(data: {
+ userName: string;
+ shiftTitle: string;
+ shiftDate: string;
+ }): Promise {
+ const text = `:x: **${data.userName}** cancelled signup for shift: *${data.shiftTitle}* (${data.shiftDate})`;
+ await this.notify('#shifts', text, '#e74c3c');
+ }
+
+ async onCanvassSessionCompleted(data: {
+ userName: string;
+ visitCount: number;
+ cutName?: string;
+ }): Promise {
+ const location = data.cutName ? ` in ${data.cutName}` : '';
+ const text = `:door: **${data.userName}** completed ${data.visitCount} visits${location}`;
+ await this.notify('#canvassing', text, '#3498db');
+ }
+
+ async onCampaignResponseSubmitted(data: {
+ campaignTitle: string;
+ representativeName: string;
+ }): Promise {
+ const text = `:mega: New response submitted for campaign *${data.campaignTitle}* from **${data.representativeName}**`;
+ await this.notify('#campaigns', text, '#9b59b6');
+ }
+
+ /**
+ * Ensure default notification channels exist in Rocket.Chat.
+ * Called during service startup.
+ */
+ async setupChannels(): Promise {
+ if (!this.enabled) return;
+ try {
+ await rocketchatClient.ensureChannel('shifts', 'Shift coordination and updates');
+ await rocketchatClient.ensureChannel('canvassing', 'Canvass activity and updates');
+ await rocketchatClient.ensureChannel('campaigns', 'Campaign activity and responses');
+ logger.info('RC notification channels verified');
+ } catch (err) {
+ logger.warn('RC channel setup failed (will retry on next notification):', err);
+ }
+ }
+}
+
+export const rocketchatWebhookService = new RocketChatWebhookService();
diff --git a/api/src/services/rocketchat.client.ts b/api/src/services/rocketchat.client.ts
new file mode 100644
index 00000000..dda06100
--- /dev/null
+++ b/api/src/services/rocketchat.client.ts
@@ -0,0 +1,331 @@
+import { env } from '../config/env';
+import { logger } from '../utils/logger';
+
+// --- Types ---
+
+export interface RCUser {
+ _id: string;
+ username: string;
+ name: string;
+ emails: { address: string; verified: boolean }[];
+ roles: string[];
+ active: boolean;
+}
+
+export interface RCLoginResponse {
+ status: string;
+ data: {
+ userId: string;
+ authToken: string;
+ me: RCUser;
+ };
+}
+
+export interface RCUserCreateResponse {
+ user: RCUser;
+ success: boolean;
+}
+
+export interface RCUserTokenResponse {
+ data: {
+ userId: string;
+ authToken: string;
+ };
+ success: boolean;
+}
+
+export interface RCInfoResponse {
+ info: {
+ version: string;
+ };
+ success: boolean;
+}
+
+export interface RCChannelCreateResponse {
+ channel: {
+ _id: string;
+ name: string;
+ };
+ success: boolean;
+}
+
+// --- Client ---
+
+class RocketChatClient {
+ private adminToken: string | null = null;
+ private adminUserId: string | null = null;
+ private tokenExpiresAt = 0;
+
+ private get baseUrl(): string {
+ return env.ROCKETCHAT_URL;
+ }
+
+ private get hasCredentials(): boolean {
+ return !!env.ROCKETCHAT_ADMIN_USER &&
+ !!env.ROCKETCHAT_ADMIN_PASSWORD;
+ }
+
+ /**
+ * Make an authenticated request to Rocket.Chat REST API
+ */
+ private async request(
+ method: string,
+ path: string,
+ body?: unknown,
+ skipAuth = false,
+ ): Promise {
+ const url = `${this.baseUrl}/api/v1${path}`;
+ const headers: Record = {
+ 'Content-Type': 'application/json',
+ };
+
+ if (!skipAuth) {
+ await this.ensureAdminAuth();
+ if (this.adminToken && this.adminUserId) {
+ headers['X-Auth-Token'] = this.adminToken;
+ headers['X-User-Id'] = this.adminUserId;
+ }
+ }
+
+ const res = await fetch(url, {
+ method,
+ headers,
+ body: body ? JSON.stringify(body) : undefined,
+ });
+
+ const data = await res.json() as T & { success?: boolean; error?: string };
+
+ if (!res.ok || data.success === false) {
+ const msg = data.error || `RC API error ${res.status}`;
+ throw new Error(msg);
+ }
+
+ return data;
+ }
+
+ // --- Auth ---
+
+ /**
+ * Authenticate as admin, cache token for 1 hour
+ */
+ async ensureAdminAuth(): Promise {
+ if (this.adminToken && Date.now() < this.tokenExpiresAt) return;
+
+ const url = `${this.baseUrl}/api/v1/login`;
+ const res = await fetch(url, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ user: env.ROCKETCHAT_ADMIN_USER,
+ password: env.ROCKETCHAT_ADMIN_PASSWORD,
+ }),
+ });
+
+ const data = await res.json() as RCLoginResponse;
+ if (!res.ok || data.status !== 'success') {
+ throw new Error('Failed to authenticate with Rocket.Chat admin');
+ }
+
+ this.adminToken = data.data.authToken;
+ this.adminUserId = data.data.userId;
+ // Cache for 1 hour
+ this.tokenExpiresAt = Date.now() + 60 * 60 * 1000;
+ logger.debug('Rocket.Chat admin auth refreshed');
+ }
+
+ // --- Health ---
+
+ async healthCheck(): Promise {
+ if (!this.hasCredentials) return false;
+ try {
+ const url = `${this.baseUrl}/api/info`;
+ const res = await fetch(url, { method: 'GET', signal: AbortSignal.timeout(5000) });
+ return res.ok;
+ } catch {
+ return false;
+ }
+ }
+
+ // --- Channel History ---
+
+ /**
+ * Get recent messages from a channel by name
+ */
+ async getChannelHistory(channelName: string, count = 5): Promise> {
+ try {
+ const data = await this.request<{
+ messages: Array<{
+ _id: string;
+ msg: string;
+ u: { username: string };
+ ts: string;
+ bot?: { i: string };
+ alias?: string;
+ }>;
+ success: boolean;
+ }>('GET', `/channels.history?roomName=${encodeURIComponent(channelName)}&count=${count}`);
+ return data.messages || [];
+ } catch {
+ return [];
+ }
+ }
+
+ // --- User Management ---
+
+ /**
+ * Find a Rocket.Chat user by email address
+ */
+ async findUserByEmail(email: string): Promise {
+ try {
+ const data = await this.request<{ users: RCUser[]; success: boolean }>(
+ 'GET',
+ `/users.list?query=${encodeURIComponent(email)}&count=1`,
+ );
+ const match = data.users?.find(u =>
+ u.emails?.some(e => e.address.toLowerCase() === email.toLowerCase()),
+ );
+ return match || null;
+ } catch (err) {
+ logger.warn('RC findUserByEmail failed:', err);
+ return null;
+ }
+ }
+
+ /**
+ * Create a new Rocket.Chat user
+ */
+ async createUser(data: {
+ email: string;
+ name: string;
+ username: string;
+ password: string;
+ roles?: string[];
+ }): Promise {
+ const res = await this.request('POST', '/users.create', {
+ email: data.email,
+ name: data.name,
+ username: data.username,
+ password: data.password,
+ roles: data.roles || ['user'],
+ verified: true,
+ joinDefaultChannels: true,
+ requirePasswordChange: false,
+ sendWelcomeEmail: false,
+ });
+ return res.user;
+ }
+
+ /**
+ * Update an existing Rocket.Chat user's roles and name
+ */
+ async updateUser(userId: string, data: { name?: string; roles?: string[] }): Promise {
+ await this.request('POST', '/users.update', {
+ userId,
+ data,
+ });
+ }
+
+ /**
+ * Set user active/inactive status
+ */
+ async setUserActive(userId: string, active: boolean): Promise {
+ await this.request('POST', '/users.setActiveStatus', {
+ userId,
+ activeStatus: active,
+ });
+ }
+
+ /**
+ * Generate a one-time login token for a user (SSO)
+ * Requires CREATE_TOKENS_FOR_USERS=true on the RC instance
+ */
+ async createUserToken(userId: string): Promise<{ authToken: string; userId: string }> {
+ const res = await this.request('POST', '/users.createToken', {
+ userId,
+ });
+ return res.data;
+ }
+
+ // --- Channels ---
+
+ /**
+ * Create a channel (idempotent — returns existing if name taken)
+ */
+ async ensureChannel(name: string, topic?: string): Promise {
+ try {
+ const res = await this.request('POST', '/channels.create', {
+ name,
+ readOnly: false,
+ });
+ if (topic) {
+ await this.request('POST', '/channels.setTopic', {
+ roomId: res.channel._id,
+ topic,
+ });
+ }
+ return res.channel._id;
+ } catch (err) {
+ // Channel already exists — look it up
+ if (err instanceof Error && (err.message.includes('already in use') || err.message.includes('duplicate-channel-name') || err.message.includes('exists'))) {
+ const info = await this.request<{ channel: { _id: string }; success: boolean }>(
+ 'GET',
+ `/channels.info?roomName=${encodeURIComponent(name)}`,
+ );
+ return info.channel._id;
+ }
+ throw err;
+ }
+ }
+
+ // --- Webhooks ---
+
+ /**
+ * Post a message to an incoming webhook URL
+ */
+ async postWebhook(webhookUrl: string, payload: {
+ text?: string;
+ channel?: string;
+ alias?: string;
+ emoji?: string;
+ attachments?: Array<{
+ title?: string;
+ text?: string;
+ color?: string;
+ fields?: Array<{ title: string; value: string; short?: boolean }>;
+ }>;
+ }): Promise {
+ try {
+ await fetch(webhookUrl, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify(payload),
+ });
+ } catch (err) {
+ logger.warn('RC webhook post failed:', err);
+ }
+ }
+
+ /**
+ * Post a message to a channel using the REST API (no webhook needed)
+ */
+ async postMessage(channel: string, text: string, alias?: string): Promise {
+ try {
+ await this.request('POST', '/chat.postMessage', {
+ channel,
+ text,
+ alias: alias || 'Changemaker Bot',
+ });
+ } catch (err) {
+ logger.warn(`RC postMessage to ${channel} failed:`, err);
+ }
+ }
+}
+
+export const rocketchatClient = new RocketChatClient();
diff --git a/api/src/templates/email/admin-response-submitted-alert.html b/api/src/templates/email/admin-response-submitted-alert.html
new file mode 100644
index 00000000..d6462e8c
--- /dev/null
+++ b/api/src/templates/email/admin-response-submitted-alert.html
@@ -0,0 +1,112 @@
+
+
+
+
+ New Response Submitted — {{ORGANIZATION_NAME}}
+
+
+
+
+
+
+
+
A new response has been submitted to the response wall and is awaiting moderation:
+
+
+
+ Campaign: {{CAMPAIGN_TITLE}}
+
+
+ Representative: {{REPRESENTATIVE_NAME}}
+
+
+ Response Type: {{RESPONSE_TYPE}}
+
+
+ Submitted By: {{SUBMITTER_NAME}}
+
+
+
+
+
+
+
+
+
+
+
+
A volunteer has cancelled their shift signup:
+
+
+
+ Shift: {{SHIFT_TITLE}}
+
+
+ Date: {{SHIFT_DATE}}
+
+
+ Volunteer: {{VOLUNTEER_NAME}}
+
+
+ Email: {{VOLUNTEER_EMAIL}}
+
+
+ Source: {{CANCELLATION_SOURCE}}
+
+
+
+
+
+
+
+
+
+
+
+
A volunteer has signed up for a shift:
+
+
+
+ Shift: {{SHIFT_TITLE}}
+
+
+ Date: {{SHIFT_DATE}}
+
+
+ Volunteer: {{VOLUNTEER_NAME}}
+
+
+ Email: {{VOLUNTEER_EMAIL}}
+
+
+ Source: {{SIGNUP_SOURCE}}
+
+
+
+
+
+
+
+
+
+
+
+
A resident has requested a yard sign during canvassing:
+
+
+
+ Address: {{ADDRESS}}
+
+
+ Sign Size: {{SIGN_SIZE}}
+
+
+ Canvasser: {{VOLUNTEER_NAME}}
+
+
+ Shift: {{SHIFT_TITLE}}
+
+
+
+
+
+
+
+
+
+
+
+
Hi {{VOLUNTEER_NAME}},
+
Your shift signup has been cancelled. Here are the details:
+
+
+
+ Shift: {{SHIFT_TITLE}}
+
+
+ Date: {{SHIFT_DATE}}
+
+
+ Time: {{SHIFT_TIME}}
+
+
+
+
If this was a mistake, you can sign up again:
+
+
+
+
+
+
+
+
+
+
Great work, {{VOLUNTEER_NAME}}! Here's a summary of your canvassing session:
+
+
+
+ Area: {{CUT_NAME}}
+
+
+ Date: {{SESSION_DATE}}
+
+
+
+
+
+
{{VISIT_COUNT}}
+
Doors Visited
+
+
+
{{DURATION_MINUTES}}
+
Minutes
+
+
+
{{DISTANCE_KM}}
+
km Walked
+
+
+
+ {{OUTCOME_BREAKDOWN}}
+
+
+
+
+
+- :material-chat:{ .lg .middle } **Rocket.Chat**
+
+ ---
+
+ Self-hosted team chat for volunteer coordination. Supports channels, direct messaging, threads, and file sharing. Embeddable in the admin dashboard via iframe. Enable with `ENABLE_CHAT=true`.
+
+ **Port:** `3000` (internal) · **Container:** `rocketchat-changemaker` · **Subdomain:** `chat.DOMAIN`
+
+ [:octicons-arrow-right-24: Rocket.Chat Docs](https://docs.rocket.chat/){ target="_blank" }
+
+- :material-calendar-multiple:{ .lg .middle } **Gancio**
+
+ ---
+
+ Self-hosted event management platform. Automatic shift-to-event sync (when `GANCIO_SYNC_ENABLED=true`) publishes shifts as public events. Uses the shared PostgreSQL database. Embeddable calendar widget available for MkDocs pages.
+
+ **Port:** `8092` · **Container:** `gancio-changemaker` · **Subdomain:** `events.DOMAIN`
+
+ [:octicons-arrow-right-24: Gancio Docs](https://gancio.org/){ target="_blank" }
+
---
@@ -254,7 +292,7 @@ docker compose --profile monitoring up -d
Metrics visualization with 3 auto-provisioned dashboards: API Overview, Infrastructure, and Campaign Activity. Supports custom dashboards and alerting.
- **Port:** `3001` · **Container:** `grafana-changemaker` · **Subdomain:** `grafana.DOMAIN`
+ **Port:** `3005` · **Container:** `grafana-changemaker` · **Subdomain:** `grafana.DOMAIN`
[:octicons-arrow-right-24: Grafana Docs](https://grafana.com/docs/grafana/latest/){ target="_blank" }
@@ -274,7 +312,7 @@ docker compose --profile monitoring up -d
Container resource metrics. Exposes CPU, memory, network, and filesystem usage per container for Prometheus to scrape.
- **Port:** `8080` · **Container:** `cadvisor-changemaker`
+ **Port:** `8086` · **Container:** `cadvisor-changemaker`
[:octicons-arrow-right-24: cAdvisor GitHub](https://github.com/google/cadvisor){ target="_blank" }
@@ -327,7 +365,7 @@ All services at a glance with their default ports and subdomains.
| Listmonk | 9001 | `listmonk.` | default |
| MailHog | 8025 | `mail.` | default |
| MkDocs (dev) | 4003 | `docs.` | default |
-| MkDocs (static) | 4001 | *(root)* | default |
+| MkDocs (static) | 4004 | *(root)* | default |
| Code Server | 8888 | `code.` | default |
| NocoDB | 8091 | `db.` | default |
| n8n | 5678 | `n8n.` | default |
@@ -335,11 +373,14 @@ All services at a glance with their default ports and subdomains.
| Mini QR | 8089 | `qr.` | default |
| Homepage | 3010 | `home.` | default |
| Excalidraw | 8090 | `draw.` | default |
+| Vaultwarden | 8445 | `vault.` | default |
+| Rocket.Chat | — | `chat.` | default |
+| Gancio | 8092 | `events.` | default |
| Newt (tunnel) | — | — | default |
| Prometheus | 9090 | — | `monitoring` |
-| Grafana | 3001 | `grafana.` | `monitoring` |
+| Grafana | 3005 | `grafana.` | `monitoring` |
| Alertmanager | 9093 | — | `monitoring` |
-| cAdvisor | 8080 | — | `monitoring` |
+| cAdvisor | 8086 | — | `monitoring` |
| Node Exporter | 9100 | — | `monitoring` |
| Redis Exporter | 9121 | — | `monitoring` |
| Gotify | 8889 | — | `monitoring` |
diff --git a/mkdocs/docs/hooks/__pycache__/env_config_hook.cpython-311.pyc b/mkdocs/docs/hooks/__pycache__/env_config_hook.cpython-311.pyc
index c9fee608..13e9fdb5 100644
Binary files a/mkdocs/docs/hooks/__pycache__/env_config_hook.cpython-311.pyc and b/mkdocs/docs/hooks/__pycache__/env_config_hook.cpython-311.pyc differ
diff --git a/mkdocs/docs/hooks/env_config_hook.py b/mkdocs/docs/hooks/env_config_hook.py
index c38bdfe9..66296be6 100644
--- a/mkdocs/docs/hooks/env_config_hook.py
+++ b/mkdocs/docs/hooks/env_config_hook.py
@@ -28,6 +28,8 @@ def on_config(config: Dict[str, Any]) -> Dict[str, Any]:
admin_port = os.environ.get('ADMIN_PORT', '3000')
admin_url = os.environ.get('ADMIN_URL', '')
base_domain = os.environ.get('BASE_DOMAIN', '')
+ gancio_url = os.environ.get('GANCIO_URL', 'http://localhost:8092')
+ gancio_port = os.environ.get('GANCIO_PORT', '8092')
if base_domain and not base_domain.startswith('http'):
base_domain = f'https://{base_domain}'
@@ -43,6 +45,10 @@ def on_config(config: Dict[str, Any]) -> Dict[str, Any]:
if is_docker_hostname(media_api_url):
media_api_url = f'http://localhost:{media_api_port}'
+ # Resolve Gancio URL — must be browser-accessible
+ if is_docker_hostname(gancio_url):
+ gancio_url = f'http://localhost:{gancio_port}'
+
# Resolve payment API URL — must be browser-accessible
if api_url and not is_docker_hostname(api_url):
payment_api_url = api_url
@@ -69,6 +75,7 @@ def on_config(config: Dict[str, Any]) -> Dict[str, Any]:
window.PUBLIC_URL = '{public_url}';
window.PAYMENT_API_URL = '{payment_api_url}';
window.APP_URL = '{app_url}';
+ window.GANCIO_URL = '{gancio_url}';
window.VIDEO_PLAYER_DEBUG = {str(os.environ.get('VIDEO_PLAYER_DEBUG', 'false')).lower()};
console.log('[EnvConfig] Loaded from environment:', {{
@@ -76,6 +83,7 @@ def on_config(config: Dict[str, Any]) -> Dict[str, Any]:
publicUrl: window.PUBLIC_URL,
paymentApiUrl: window.PAYMENT_API_URL,
appUrl: window.APP_URL,
+ gancioUrl: window.GANCIO_URL,
debug: window.VIDEO_PLAYER_DEBUG
}});
}})();
@@ -109,6 +117,7 @@ def on_config(config: Dict[str, Any]) -> Dict[str, Any]:
logger.info(f" PUBLIC_URL: {public_url}")
logger.info(f" PAYMENT_API_URL: {payment_api_url}")
logger.info(f" APP_URL: {app_url}")
+ logger.info(f" GANCIO_URL: {gancio_url}")
else:
logger.info(f"✓ Env config unchanged, skipping write")
diff --git a/mkdocs/docs/overrides/lander.html b/mkdocs/docs/overrides/lander.html
index 1005672d..b72295ca 100644
--- a/mkdocs/docs/overrides/lander.html
+++ b/mkdocs/docs/overrides/lander.html
@@ -39,6 +39,7 @@
--branch-data: #22D3EE;
--branch-devops: #FBBF24;
--branch-sovereignty: #F87171;
+ --branch-fundraising: #EC4899;
/* Surfaces — dark */
--bg-deep: #0F172A;
@@ -887,6 +888,7 @@
.branch-icon.data { background: rgba(34, 211, 238, 0.15); border: 1px solid rgba(34, 211, 238, 0.3); }
.branch-icon.devops { background: rgba(251, 191, 36, 0.15); border: 1px solid rgba(251, 191, 36, 0.3); }
.branch-icon.sovereignty { background: rgba(248, 113, 113, 0.15); border: 1px solid rgba(248, 113, 113, 0.3); }
+ .branch-icon.fundraising { background: rgba(236, 72, 153, 0.15); border: 1px solid rgba(236, 72, 153, 0.3); }
.branch-title h3 {
font-size: 1.35rem;
@@ -935,6 +937,7 @@
.branch-data .feature-node { border-top: 2px solid var(--branch-data); }
.branch-devops .feature-node { border-top: 2px solid var(--branch-devops); }
.branch-sovereignty .feature-node { border-top: 2px solid var(--branch-sovereignty); }
+ .branch-fundraising .feature-node { border-top: 2px solid var(--branch-fundraising); }
.branch-comm .feature-node:hover { border-color: var(--branch-comm); box-shadow: 0 0 20px rgba(192,132,252,0.2); }
.branch-map .feature-node:hover { border-color: var(--branch-map); box-shadow: 0 0 20px rgba(52,211,153,0.2); }
@@ -942,6 +945,7 @@
.branch-data .feature-node:hover { border-color: var(--branch-data); box-shadow: 0 0 20px rgba(34,211,238,0.2); }
.branch-devops .feature-node:hover { border-color: var(--branch-devops); box-shadow: 0 0 20px rgba(251,191,36,0.2); }
.branch-sovereignty .feature-node:hover { border-color: var(--branch-sovereignty); box-shadow: 0 0 20px rgba(248,113,113,0.2); }
+ .branch-fundraising .feature-node:hover { border-color: var(--branch-fundraising); box-shadow: 0 0 20px rgba(236,72,153,0.2); }
/* Branch-specific node icon tinting */
.branch-comm .node-icon { background: rgba(192,132,252,0.12); }
@@ -950,6 +954,7 @@
.branch-data .node-icon { background: rgba(34,211,238,0.12); }
.branch-devops .node-icon { background: rgba(251,191,36,0.12); }
.branch-sovereignty .node-icon { background: rgba(248,113,113,0.12); }
+ .branch-fundraising .node-icon { background: rgba(236,72,153,0.12); }
.node-header {
display: flex;
@@ -1555,7 +1560,7 @@
-
+
@@ -1563,7 +1568,7 @@
-
+
@@ -1661,13 +1666,13 @@
Self-Hosted Campaign Infrastructure
Grow Power.
Don't Rent It.
- Complete political independence on your own infrastructure. Own every byte of data, control every system.
+ A deeply integrated and opinionated collection of free and open source services and production ready applications for growing political movements. Campaigns, canvassing, fundraising, team chat, and media — all on your own infrastructure.
No corporate surveillance. No foreign interference. No monthly ransoms. Free and open source.
@@ -1698,7 +1703,7 @@
Self-Hosted
-
26+
+
30+
Integrated Tools
@@ -1760,7 +1765,7 @@
@@ -1805,6 +1810,22 @@
Public response collection with moderation, upvoting, and verification. Showcase supporter voices on your campaigns.
ModerationUpvotingVerification
+
+
+
Self-hosted team chat with SSO integration. Automatic channel notifications for shift signups, canvass sessions, and campaign responses.
+
SSOChannelsSlack alternative
+
+
+
+
Async notification queue for admin alerts and volunteer feedback. Shift reminders, session summaries, and signup confirmations.
+
BullMQRemindersSummaries
+
Full VS Code in the browser. Edit configuration, templates, and code from anywhere without SSH.
VS CodeBrowser IDEExtensions
+
+
+
Collaborative diagramming and whiteboard tool. Plan canvassing routes, sketch campaign strategies, and brainstorm as a team.
+
CollaborativeDiagramsReal-time
+
PostgreSQL dumps, Listmonk data, uploads archive, and optional S3 upload. One-command backup script.
PostgreSQLS3 optionalScripted
+
+
+
Self-hosted Bitwarden-compatible password manager. Secure credential sharing for your team with real-time sync and browser extensions.
+
BitwardenTeam sharingEncrypted
+
+
+
+
+
+
Accept one-time donations with configurable suggested amounts, anonymous giving, and automatic tax receipts via email.
+
StripeAnonymousReceipts
+
+
+
+
Recurring revenue with tiered plans, monthly and yearly billing, and automatic renewal management. Replace Patreon.
+
RecurringTiersMRR tracking
+
+
+
+
Sell digital products, event tickets, and merchandise. Inventory management, download delivery, and capacity limits.
+
Digital goodsEventsInventory
+
+
+
+
Revenue analytics with subscriber counts, MRR tracking, donation history, and CSV exports for accounting.
+
AnalyticsCSV exportRefunds
+
+
+
+
Promote donations, products, and subscriptions within the media gallery. Visibility targeting, scheduling, and click analytics.
+
TargetingSchedulingCTR tracking
+
+
+