Florida Emergency Alerts: Real-Time Notifications with Node & Express

// Import required modules
const express = require('express');
const router = express.Router();

const EmergencyAlert = require('../models/EmergencyAlert');
const NotificationService = require('../services/NotificationService');
const GeolocationService = require('../services/GeolocationService');

const validation = [
  body('alertType').isIn(['hurricane', 'flood', 'tornado']),
  body('message').isLength({ min: 10, max: 500 }),
  body('targetAreas').isArray({ min: 1 })
];

router.post('/alerts', validation, async (req, res) => {
  const { alertType, message, targetAreas } = req.body;
  
  // Create new alert
  const alert = new EmergencyAlert({
    type: alertType,
    message,
    targetAreas,
    createdBy: req.user.id
  });

  // Find recipients in target areas
  const recipients = await GeolocationService
    .getRecipientsInAreas(targetAreas);
    
  alert.recipientCount = recipients.length;
  await alert.save();

  // Send alerts via multiple channels
  const result = await NotificationService.sendMassAlert({
    alertId: alert._id,
    message,
    recipients,
    channels: ['sms', 'email', 'push']
  });

  res.status(201).json({
    success: true,
    alertId: alert._id,
    recipientCount: recipients.length,
    estimatedDelivery: '< 3 minutes'
  });
});

router.get('/alerts/status/:id', async (req, res) => {
  const alert = await EmergencyAlert
    .findById(req.params.id)
    .populate('createdBy');
    
  const stats = await NotificationService
    .getDeliveryStats(alert._id);
});

// NotificationService.js imports
const twilio = require('twilio');
const sgMail = require('@sendgrid/mail');
const admin = require('firebase-admin');

const Queue = require('bull');
const Redis = require('ioredis');

// Initialize notification queues
this.smsQueue = new Queue('SMS notifications');
this.emailQueue = new Queue('Email notifications');

async sendMassAlert({ alertId, message, recipients, channels }) {
  const startTime = Date.now();
  const stats = { total: recipients.length, sms: 0, email: 0 };
  
  // Batch recipients for parallel processing
  const batches = this.chunkArray(recipients, 1000);

  const promises = [];
  
  for (const batch of batches) {
    if (channels.includes('sms')) {
      promises.push(this.queueSMSBatch(alertId, message, batch));
    }
    if (channels.includes('email')) {
      promises.push(this.queueEmailBatch(alertId, message, batch));
    }
  }

  // Execute all batches concurrently
  const results = await Promise.allSettled(promises);
  
  const processingTime = Date.now() - startTime;
  const estimatedDelivery = Math.ceil(processingTime / 1000) + 120;
  
  return { stats, estimatedDelivery };

async queueSMSBatch(alertId, message, recipients) {
  const jobs = recipients
    .filter(recipient => recipient.phone)
    .map(recipient => ({
      alertId, message, phone: recipient.phone
    }));
    
  await this.smsQueue.addBulk(jobs);

this.smsQueue.process(10, async (job) => {
  const { message, phone } = job.data;
  
  const result = await this.twilioClient.messages.create({
    body: message,
    from: process.env.TWILIO_PHONE,
    to: phone
  });
});

this.emailQueue.process(15, async (job) => {
  const { message, email } = job.data;
  
  const emailData = {
    to: email,
    from: process.env.SENDGRID_FROM_EMAIL,
    subject: 'FLORIDA EMERGENCY ALERT',
    text: message
  };
  
  await sgMail.send(emailData);
});

// cluster.js - Node.js clustering setup
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;
const express = require('express');

if (cluster.isMaster) {
  console.log(`Starting ${numCPUs} workers`);
  
  // Health monitoring for worker processes
  const workerHealth = new Map();
}

  // Fork workers with emergency priority
  for (let i = 0; i < numCPUs; i++) {
    const worker = cluster.fork({
      WORKER_ID: i,
      EMERGENCY_MODE: process.env.NODE_ENV === 'production'
    });

  // Auto-restart failed workers
  cluster.on('exit', (worker, code, signal) => {
    console.error(`Worker ${worker.process.pid} died`);
    
    // Emergency restart with priority
    const newWorker = cluster.fork({
      EMERGENCY_MODE: true
    });
  });

  // Health check every 10 seconds
  setInterval(() => {
    const now = Date.now();
    for (const [pid, health] of workerHealth.entries()) {
      if (now - health.lastHeartbeat > 30000) {
        process.kill(pid, 'SIGTERM');
      }
    }
  }, 10000);

} else {
  // Worker process setup
  const app = express();
  const redis = new Redis.Cluster([
    { host: process.env.REDIS_HOST_1, port: 7000 },
    { host: process.env.REDIS_HOST_2, port: 7000 }
  ]);

  // Emergency-specific rate limiting
  const emergencyLimit = require('express-rate-limit')({
    windowMs: 1 * 60 * 1000, // 1 minute
    max: (req) => {
      if (req.user?.role === 'emergency_official') return 100;
      return 5; // Regular users
    }
  });

// GeolocationService.js - Emergency targeting
const turf = require('@turf/turf');

class GeolocationService {
  constructor() {
    this.floridaCounties = require('../data/florida-counties.json');
    this.evacuationZones = require('../data/evacuation-zones.json');
  }

  async getRecipientsInAreas(targetAreas) {
    const recipients = [];
    
    for (const area of targetAreas) {
      switch (area.type) {
        case 'county':
          const countyUsers = await this.getRecipientsByCounty(area.name);
          recipients.push(...countyUsers);
          break;
      }
    }
    
    return recipients;
  }