feat: add custom user symptom support

- Add SymptomType.OTHER enum and customSymptom field to SymptomRecord prisma schema
- Update CreateSymptomDto with validation for customSymptom (string, max 80 chars, optional)
- Implement validation logic in SymptomsService to require customSymptom when using OTHER type, normalize input, and check for duplicate symptoms in last 12 hours
- Fix notification schedulers to only send reminders if user has not logged a BP reading since the cutoff period
- Overhaul ClinicFinderService with improved Overpass API queries, deduplication, distance-based sorting, and better error handling

prisma/schema.prisma

@@ -211,7 +211,7 @@ model BloodPressureReading {
  * 
  * CLINICAL SAFETY:
  * - Enumerated list of pregnancy hypertension warning signs
- * - No free-text symptoms
+ * - Free-text is only allowed with OTHER for user-entered symptoms
  * - No severity levels
  * - Based on clinical guidelines for preeclampsia/eclampsia
  */
@@ -223,6 +223,7 @@ enum SymptomType {
   REDUCED_URINE             // Decreased urine output
   NAUSEA_VOMITING           // Persistent nausea/vomiting
   SHORTNESS_OF_BREATH       // Difficulty breathing
+  OTHER                     // User-entered symptom text stored separately
 }
 
 /**
@@ -242,8 +243,9 @@ enum SymptomType {
 model SymptomRecord {
   id          String      @id @default(uuid())
   userId      String
-  symptomType SymptomType
-  recordedAt  DateTime    @default(now())
+  symptomType   SymptomType
+  customSymptom String?
+  recordedAt    DateTime    @default(now())
   createdAt   DateTime    @default(now())
 
   // Relation to UserAuth

src/clinic-finder/clinic-finder.service.ts

@@ -2,6 +2,18 @@ import { Injectable, Logger } from "@nestjs/common";
 import axios from "axios";
 import { CLINIC_LOCATIONS, ClinicLocation } from "./data/clinics.data";
 
+function distanceKm(lat1: number, lng1: number, lat2: number, lng2: number) {
+  const toRad = (value: number) => (value * Math.PI) / 180;
+  const earthKm = 6371;
+  const dLat = toRad(lat2 - lat1);
+  const dLng = toRad(lng2 - lng1);
+  const a =
+    Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+    Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) *
+      Math.sin(dLng / 2) * Math.sin(dLng / 2);
+  return earthKm * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+
 @Injectable()
 export class ClinicFinderService {
   private readonly logger = new Logger(ClinicFinderService.name);
@@ -10,44 +22,82 @@ export class ClinicFinderService {
   async findNearby(
     lat: number,
     lng: number,
-    radius: number = 5000
+    radius: number = 8000,
   ): Promise<ClinicLocation[]> {
+    if (!Number.isFinite(lat) || !Number.isFinite(lng)) return [];
+
     try {
-      this.logger.log(`Searching for hospitals near ${lat}, ${lng} within ${radius}m using Overpass API`);
-      
+      this.logger.log(
+        `Searching for maternal care near ${lat}, ${lng} within ${radius}m using Overpass API`,
+      );
+
       const query = `
         [out:json][timeout:25];
         (
           node["amenity"="hospital"](around:${radius},${lat},${lng});
           way["amenity"="hospital"](around:${radius},${lat},${lng});
+          relation["amenity"="hospital"](around:${radius},${lat},${lng});
           node["amenity"="clinic"](around:${radius},${lat},${lng});
           way["amenity"="clinic"](around:${radius},${lat},${lng});
+          relation["amenity"="clinic"](around:${radius},${lat},${lng});
+          node["healthcare"~"hospital|clinic|doctor|centre"](around:${radius},${lat},${lng});
+          way["healthcare"~"hospital|clinic|doctor|centre"](around:${radius},${lat},${lng});
+          relation["healthcare"~"hospital|clinic|doctor|centre"](around:${radius},${lat},${lng});
+          node["emergency"="yes"](around:${radius},${lat},${lng});
+          way["emergency"="yes"](around:${radius},${lat},${lng});
+          node["name"~"maternity|maternal|women|obstetric|clinic|hospital", i](around:${radius},${lat},${lng});
+          way["name"~"maternity|maternal|women|obstetric|clinic|hospital", i](around:${radius},${lat},${lng});
         );
-        out center;
+        out center tags;
       `;
 
-      const response = await axios.post(this.overpassUrl, `data=${encodeURIComponent(query)}`);
+      const response = await axios.post(
+        this.overpassUrl,
+        `data=${encodeURIComponent(query)}`,
+        { headers: { "Content-Type": "application/x-www-form-urlencoded" } },
+      );
 
-      if (response.data && response.data.elements) {
-        return response.data.elements.map((element: any) => ({
-          id: element.id.toString(),
-          name: element.tags.name || "Unnamed Hospital",
-          latitude: element.lat || element.center?.lat,
-          longitude: element.lon || element.center?.lon,
-          address: element.tags["addr:street"] 
-            ? `${element.tags["addr:housenumber"] || ""} ${element.tags["addr:street"]}`.trim()
-            : "Address not available",
-          city: element.tags["addr:city"] || "Detected",
-          country: "Nigeria",
-          phone: element.tags.phone || element.tags["contact:phone"] || "Contact via Maps",
-          isEmergency: element.tags.amenity === "hospital",
-        }));
-      }
+      const seen = new Set<string>();
+      return (response.data?.elements || [])
+        .map((element: any) => {
+          const latitude = element.lat || element.center?.lat;
+          const longitude = element.lon || element.center?.lon;
+          if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) return null;
 
-      return [];
+          const tags = element.tags || {};
+          const name = tags.name || tags["official_name"] || "Health facility";
+          const street = tags["addr:street"];
+          const address = street
+            ? `${tags["addr:housenumber"] || ""} ${street}`.trim()
+            : tags["addr:full"] || tags["addr:place"] || "Address not available";
+          const city = tags["addr:city"] || tags["addr:town"] || tags["addr:suburb"] || "Nearby";
+          const key = `${name.toLowerCase()}-${Number(latitude).toFixed(5)}-${Number(longitude).toFixed(5)}`;
+          if (seen.has(key)) return null;
+          seen.add(key);
+
+          return {
+            id: `${element.type || "osm"}-${element.id}`,
+            name,
+            latitude,
+            longitude,
+            address,
+            city,
+            country: tags["addr:country"] || "Nigeria",
+            phone: tags.phone || tags["contact:phone"] || tags["healthcare:phone"],
+            isEmergency: tags.emergency === "yes" || tags.amenity === "hospital",
+          } as ClinicLocation;
+        })
+        .filter(Boolean)
+        .sort(
+          (a: ClinicLocation, b: ClinicLocation) =>
+            distanceKm(lat, lng, a.latitude, a.longitude) -
+            distanceKm(lat, lng, b.latitude, b.longitude),
+        );
     } catch (error: any) {
-      this.logger.error(`Failed to fetch nearby hospitals from Overpass: ${error.message}`);
-      return this.findAll(); // Fallback to seed data on error
+      this.logger.error(
+        `Failed to fetch nearby facilities from Overpass: ${error.message}`,
+      );
+      return [];
     }
   }
 
@@ -57,17 +107,11 @@ export class ClinicFinderService {
 
   findByCity(city: string): ClinicLocation[] {
     const normalized = city.trim().toLowerCase();
-
-    // If city is "Ikeja", include "Lagos" clinics as well, as Ikeja is part of Lagos
-    const isIkeja = normalized === "ikeja";
+    if (!normalized) return [];
 
     return CLINIC_LOCATIONS.filter((clinic) => {
-      const clinicCity = clinic.city.toLowerCase();
-      if (isIkeja) {
-        return clinicCity === "ikeja" || clinicCity === "lagos";
-      }
-      return clinicCity === normalized;
+      const haystack = `${clinic.name} ${clinic.address} ${clinic.city}`.toLowerCase();
+      return haystack.includes(normalized);
     });
   }
 }
-

src/email/email.scheduler.ts

@@ -117,6 +117,13 @@ export class EmailScheduler {
       const lastReading = user.bloodPressureReadings[0];
       if (!lastReading) continue; // Should not happen given the query but safe-guard
 
+      const latestReading = await this.prisma.bloodPressureReading.findFirst({
+        where: { userId: user.id },
+        orderBy: { recordedAt: 'desc' },
+        select: { recordedAt: true },
+      });
+      if (!latestReading || latestReading.recordedAt.getTime() !== lastReading.recordedAt.getTime()) continue;
+
       const diffTime = Math.abs(new Date().getTime() - lastReading.recordedAt.getTime());
       const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
 

src/monitoring-engine/monitoring-scheduler.service.ts

@@ -107,6 +107,15 @@ export class MonitoringSchedulerService {
         continue;
       }
 
+      const latestReading = await this.prisma.bloodPressureReading.findFirst({
+        where: { userId: user.id },
+        orderBy: { recordedAt: "desc" },
+        select: { recordedAt: true },
+      });
+      if (!latestReading || latestReading.recordedAt.getTime() !== lastBpReading.recordedAt.getTime()) {
+        continue;
+      }
+
       if (lastBpReading.recordedAt < sevenDaysAgo) {
         // No BP logged in >7 days -> escalate messaging urgency
         await this.notificationsService.sendPushNotification(

src/notifications/notifications.service.ts

@@ -50,6 +50,20 @@ export class NotificationsService {
     return this.expoInstance;
   }
 
+  private async getLatestBPDate(userId: string): Promise<Date | null> {
+    const latest = await this.prisma.bloodPressureReading.findFirst({
+      where: { userId },
+      orderBy: { recordedAt: "desc" },
+      select: { recordedAt: true },
+    });
+    return latest?.recordedAt || null;
+  }
+
+  private async hasLoggedBPSince(userId: string, cutoff: Date): Promise<boolean> {
+    const latest = await this.getLatestBPDate(userId);
+    return Boolean(latest && latest >= cutoff);
+  }
+
   /**
    * Helper to get user's email
    */
@@ -160,6 +174,7 @@ export class NotificationsService {
 
     for (const user of usersToRemind) {
       try {
+        if (await this.hasLoggedBPSince(user.id, today)) continue;
         const template = MONITORING_TEMPLATES.DAILY_REMINDER;
         await this.prisma.notification.create({
           data: {
@@ -210,6 +225,7 @@ export class NotificationsService {
 
     for (const user of users) {
       try {
+        if (await this.hasLoggedBPSince(user.id, fiveDaysAgo)) continue;
         const template = MONITORING_TEMPLATES.INACTIVITY_REMINDER;
         await this.prisma.notification.create({
           data: {
@@ -288,6 +304,7 @@ export class NotificationsService {
 
     for (const user of users) {
       try {
+        if (await this.hasLoggedBPSince(user.id, fourHoursAgo)) continue;
         const template = MONITORING_TEMPLATES.FOLLOW_UP_REMINDER;
         await this.prisma.notification.create({
           data: {

src/symptoms/dto/create-symptom.dto.ts

@@ -1,4 +1,4 @@
-import { IsEnum, IsOptional, IsDateString } from "class-validator";
+import { IsEnum, IsOptional, IsDateString, IsString, MaxLength } from "class-validator";
 import { SymptomType } from "@prisma/client";
 
 /**
@@ -18,6 +18,11 @@ export class CreateSymptomDto {
   @IsEnum(SymptomType)
   symptomType!: SymptomType;
 
+  @IsOptional()
+  @IsString()
+  @MaxLength(80)
+  customSymptom?: string;
+
   @IsOptional()
   @IsDateString()
   recordedAt?: string;

src/symptoms/symptoms.service.ts

@@ -1,4 +1,4 @@
-import { Injectable, Logger } from "@nestjs/common";
+import { BadRequestException, Injectable, Logger } from "@nestjs/common";
 import { PrismaService } from "../database/prisma.service";
 import { CreateSymptomDto } from "./dto/create-symptom.dto";
 import { SymptomType } from "@prisma/client";
@@ -35,11 +35,27 @@ export class SymptomsService {
    */
   async create(userId: string, createSymptomDto: CreateSymptomDto) {
     const { symptomType, recordedAt } = createSymptomDto;
+    const customSymptom = createSymptomDto.customSymptom?.trim().replace(/\s+/g, " ");
+
+    if (symptomType === SymptomType.OTHER && !customSymptom) {
+      throw new BadRequestException("Please describe the other symptom.");
+    }
+
+    const duplicate = await this.prisma.symptomRecord.findFirst({
+      where: {
+        userId,
+        symptomType,
+        customSymptom: symptomType === SymptomType.OTHER ? customSymptom : null,
+        recordedAt: { gte: new Date(Date.now() - 12 * 60 * 60 * 1000) },
+      },
+    });
+    if (duplicate) return duplicate;
 
     const symptom = await this.prisma.symptomRecord.create({
       data: {
         userId,
         symptomType,
+        customSymptom: symptomType === SymptomType.OTHER ? customSymptom : null,
         recordedAt: recordedAt ? new Date(recordedAt) : new Date(),
       },
     });