Developer Portal

# Install web-push globally
npm install -g web-push

# Generate VAPID key pair
web-push generate-vapid-keys

# Add to Manus Settings → Secrets:
# VAPID_PUBLIC_KEY=BPxr...
# VAPID_PRIVATE_KEY=nD2x...
# VAPID_SUBJECT=mailto:[email protected]

// server/pushNotification.ts
import webpush from 'web-push';
import { env } from './_core/env';

webpush.setVapidDetails(
  env.VAPID_SUBJECT,
  env.VAPID_PUBLIC_KEY,
  env.VAPID_PRIVATE_KEY
);

export async function sendPush(subscription: PushSubscription, payload: {
  title: string; body: string; url?: string;
}) {
  return webpush.sendNotification(subscription, JSON.stringify(payload));
}

// drizzle/schema.ts — add:
export const pushSubscriptions = mysqlTable('push_subscriptions', {
  id: int('id').primaryKey().autoincrement(),
  userId: int('user_id').notNull(),
  endpoint: text('endpoint').notNull(),
  p256dh: text('p256dh').notNull(),
  auth: text('auth').notNull(),
  createdAt: timestamp('created_at').defaultNow(),
});
// Then run: pnpm db:push

// server/routers.ts — add to notificationRouter:
subscribe: protectedProcedure
  .input(z.object({
    endpoint: z.string(),
    keys: z.object({ p256dh: z.string(), auth: z.string() })
  }))
  .mutation(async ({ ctx, input }) => {
    // Save subscription to pushSubscriptions table
    // Return success
  }),
unsubscribe: protectedProcedure.mutation(async ({ ctx }) => {
  // Delete subscription for ctx.user.id
}),

// client/public/sw.js
self.addEventListener('push', (event) => {
  const data = event.data.json();
  event.waitUntil(
    self.registration.showNotification(data.title, {
      body: data.body,
      icon: '/favicon.ico',
      data: { url: data.url }
    })
  );
});

self.addEventListener('notificationclick', (event) => {
  event.notification.close();
  if (event.notification.data.url) {
    event.waitUntil(clients.openWindow(event.notification.data.url));
  }
});

# Go to: https://developers.facebook.com/apps/
# Click "Create App" → "Consumer" type
# App name: ForACity
# Add product: "Facebook Login"
# Settings → Basic:
#   App ID: (copy this)
#   App Secret: (copy this)

# In Facebook App → Facebook Login → Settings:
# Valid OAuth Redirect URIs:
https://foracity.com/api/facebook/callback
https://www.foracity.com/api/facebook/callback
https://levineact-cozcqk6f.manus.space/api/facebook/callback

# In Manus Settings → Secrets, add:
FACEBOOK_APP_ID=your_app_id_here
FACEBOOK_APP_SECRET=your_app_secret_here

# 1. Log in to ForACity
# 2. Go to your profile or settings
# 3. Click "Connect Facebook"
# 4. Authorize the app
# 5. Verify: profile photo syncs, friends appear
# 6. Test sharing a feed post to Facebook

// server/jobs/netfileSync.ts
import { fetchNetFileTransactions } from '../netfile';
import { getOfficers, createContribution } from '../db';
import { notifyOwner } from '../_core/notification';

export async function runNetFileSync() {
  const officers = await getOfficers({ jurisdictionId: 1 }); // Escondido
  for (const officer of officers) {
    if (!officer.netfileFilerId) continue;
    const txns = await fetchNetFileTransactions(officer.netfileFilerId);
    // Filter new transactions since last sync
    // Insert into contributions table
    // Check for $500+ threshold
  }
  await notifyOwner({ title: 'NetFile Sync Complete', content: '...' });
}

// Trigger via cron or admin button

// In the sync loop, after inserting contribution:
if (contribution.amount >= 250) {
  // Run conflict detection for this officer
  await detectConflicts(officer.id);
  // Create admin alert
  await createNotification({
    userId: adminUserId,
    type: 'conflict_alert',
    title: `High contribution: $${amount} to ${officer.name}`,
    body: `From ${contributorName}. Levine Act threshold exceeded.`,
  });
}

// After processing significant contributions:
await createFeedPost({
  postType: 'contribution',
  title: `New contribution: $${amount} to ${officer.name}`,
  body: `${contributorName} contributed $${amount}...`,
  jurisdictionId: officer.jurisdictionId,
  officerId: officer.id,
});

// The NetFile sync status indicator already exists in
// AdminDashboard.tsx and AdminNetFile.tsx
// Just need to update the lastSync timestamp after each run:
await updateNetFileSyncStatus(officerId, {
  lastSync: new Date(),
  recordCount: newRecords,
  status: 'success',
});

// ArcGIS FeatureServer endpoints for San Diego County:
// City Council Districts (already working):
// https://services2.arcgis.com/eJcVbjTyyZIzZ5Ye/arcgis/rest/services/CouncilDistricts/FeatureServer/0

// State Assembly Districts:
// https://services.arcgis.com/P3ePLMYs2RVChkJx/arcgis/rest/services/USA_118th_Congressional_Districts/FeatureServer/0

// State Senate Districts:
// https://services2.arcgis.com/[org]/arcgis/rest/services/CA_State_Senate_Districts/FeatureServer/0

// Congressional Districts:
// https://services.arcgis.com/P3ePLMYs2RVChkJx/arcgis/rest/services/USA_118th_Congressional_Districts/FeatureServer/0

// Query pattern (point-in-polygon):
const url = `${featureServerUrl}/query?` + new URLSearchParams({
  geometry: `${lng},${lat}`,
  geometryType: 'esriGeometryPoint',
  spatialRel: 'esriSpatialRelIntersects',
  outFields: '*',
  f: 'json',
});

// server/routers.ts — update address.lookup:
// Currently uses database lookup for sphere of influence
// Replace with real GIS queries:

async function queryDistrictFromGIS(lat: number, lng: number, featureServerUrl: string) {
  const res = await fetch(`${featureServerUrl}/query?` + new URLSearchParams({
    geometry: `${lng},${lat}`,
    geometryType: 'esriGeometryPoint',
    spatialRel: 'esriSpatialRelIntersects',
    outFields: '*',
    f: 'json',
  }));
  const data = await res.json();
  return data.features?.[0]?.attributes;
}

// Call for each level:
const [assembly, senate, congress, supervisor] = await Promise.all([
  queryDistrictFromGIS(lat, lng, ASSEMBLY_URL),
  queryDistrictFromGIS(lat, lng, SENATE_URL),
  queryDistrictFromGIS(lat, lng, CONGRESS_URL),
  queryDistrictFromGIS(lat, lng, SUPERVISOR_URL),
]);

// Option 1: In-memory cache (simple)
const districtCache = new Map<string, { data: any; expires: number }>();

function getCachedDistrict(key: string) {
  const cached = districtCache.get(key);
  if (cached && cached.expires > Date.now()) return cached.data;
  return null;
}

// Option 2: Database cache table
export const districtCache = mysqlTable('district_cache', {
  id: int('id').primaryKey().autoincrement(),
  lat: decimal('lat', { precision: 10, scale: 7 }),
  lng: decimal('lng', { precision: 10, scale: 7 }),
  districtType: varchar('district_type', { length: 50 }),
  districtData: json('district_data'),
  expiresAt: timestamp('expires_at'),
});

// client/src/pages/AddressLookup.tsx
// Use the Google Maps component from client/src/components/Map.tsx
import { MapView } from '@/components/Map';

// In the results section, add a map:
<MapView
  onMapReady={(map, google) => {
    // Add district boundary polygons
    const districtLayer = new google.maps.Data();
    districtLayer.loadGeoJson(districtGeoJsonUrl);
    districtLayer.setStyle({
      fillColor: '#CF8A2E',
      fillOpacity: 0.15,
      strokeColor: '#CF8A2E',
      strokeWeight: 2,
    });
    districtLayer.setMap(map);
    
    // Add marker for searched address
    new google.maps.Marker({
      position: { lat, lng },
      map,
      title: 'Your Address',
    });
  }}
/>

// Option 1: Use Manus notifyOwner for admin alerts (already works)
// Option 2: Add SendGrid/Resend for user emails:

// server/emailService.ts
import { Resend } from 'resend';
const resend = new Resend(process.env.RESEND_API_KEY);

export async function sendReminder(to: string, meeting: Meeting) {
  await resend.emails.send({
    from: 'ForACity <[email protected]>',
    to,
    subject: `Reminder: ${meeting.title} tomorrow`,
    html: `<h2>${meeting.title}</h2>
           <p>${meeting.location} at ${formatTime(meeting.date)}</p>
           <a href="https://foracity.com/meetings/${meeting.id}">View Details</a>`,
  });
}

// Env var needed: RESEND_API_KEY

// server/jobs/meetingReminders.ts
export async function checkAndSendReminders() {
  const now = Date.now();
  const oneDayFromNow = now + 24 * 60 * 60 * 1000;
  const oneHourFromNow = now + 60 * 60 * 1000;
  
  // Find meetings happening in ~24h or ~1h
  const meetings = await getUpcomingMeetings();
  for (const meeting of meetings) {
    const timeUntil = meeting.date - now;
    if (timeUntil < oneDayFromNow && timeUntil > oneDayFromNow - 300000) {
      // Send 24h reminder to all RSVPs
      const rsvps = await getRsvpsForMeeting(meeting.id);
      for (const rsvp of rsvps) {
        await sendReminder(rsvp.user.email, meeting);
      }
    }
  }
}

// After a meeting's date has passed, auto-generate summary:
// This already works via the AI meeting summary feature.
// Just need to trigger it automatically:

// In the scheduled job:
const pastMeetings = await getPastMeetingsWithoutSummary();
for (const meeting of pastMeetings) {
  if (!meeting.aiSummary && meeting.agendaItems) {
    // Trigger the existing generateSummary route
    await generateMeetingSummary(meeting.id);
    // This already auto-posts to feed (implemented)
  }
}

# In Manus Management UI:
# Settings → Domains → Add Domain
# Enter: escondido.foracity.com
# Follow DNS instructions to point to Manus

// client/src/App.tsx — already has subdomain detection
// Just add escondido.foracity.com to the routing logic:

const hostname = window.location.hostname;
if (hostname === 'escondido.foracity.com') {
  // Auto-redirect to /admin
  return <Redirect to="/admin" />;
}