Implement Monthly Reminder Service

package.json

@@ -56,6 +56,7 @@
     "@types/jsonwebtoken": "^9.0.2",
     "@types/multer": "^1.4.11",
     "@types/node": "^20.1.4",
+    "@types/node-cron": "^3.0.11",
     "@types/nodemailer": "^6.4.15",
     "@types/passport": "^1.0.12",
     "@types/passport-google-oauth20": "^2.0.14",

src/app.ts

@@ -18,7 +18,6 @@ import mentorRouter from './routes/mentor/mentor.route'
 import profileRouter from './routes/profile/profile.route'
 import path from 'path'
 import countryRouter from './routes/country/country.route'
-
 const app = express()
 const staticFolder = 'uploads'
 export const certificatesDir = path.join(__dirname, 'certificates')

src/controllers/admin/email.controller.ts

@@ -4,6 +4,10 @@ import { type ApiResponse } from '../../types'
 import type Email from '../../entities/email.entity'
 import { ProfileTypes } from '../../enums'
 import { sendEmail } from '../../services/admin/email.service'
+import { MonthlyReminderService } from '../../services/admin/reminder.service'
+import { dataSource } from '../../configs/dbConfig'
+import { MonthlyReminder } from '../../entities/monthlyReminders.entity'
+import Mentee from '../../entities/mentee.entity'
 
 export const sendEmailController = async (
   req: Request,
@@ -30,3 +34,21 @@ export const sendEmailController = async (
     throw err
   }
 }
+
+const reminderService = new MonthlyReminderService(
+  dataSource.getRepository(MonthlyReminder),
+  dataSource.getRepository(Mentee)
+)
+
+export const processEmailReminderHandler = async (
+  req: Request,
+  res: Response
+): Promise<void> => {
+  try {
+    const { statusCode, message } = await reminderService.processReminders()
+    res.status(statusCode).json({ message })
+  } catch (err) {
+    console.error('Error enabling reminder', err)
+    res.status(500).json({ message: 'Error enabling reminder' })
+  }
+}

src/entities/mentee.entity.ts

@@ -5,6 +5,7 @@ import { MenteeApplicationStatus, StatusUpdatedBy } from '../enums'
 import BaseEntity from './baseEntity'
 import { UUID } from 'typeorm/driver/mongodb/bson.typings'
 import MonthlyCheckIn from './checkin.entity'
+import { MonthlyReminder } from './monthlyReminders.entity'
 
 @Entity('mentee')
 class Mentee extends BaseEntity {
@@ -39,19 +40,24 @@ class Mentee extends BaseEntity {
   @OneToMany(() => MonthlyCheckIn, (checkIn) => checkIn.mentee)
   checkIns?: MonthlyCheckIn[]
 
+  @OneToMany(() => MonthlyReminder, (reminder) => reminder.mentee)
+  reminders?: MonthlyReminder[]
+
   constructor(
     state: MenteeApplicationStatus,
     application: Record<string, unknown>,
     profile: profileEntity,
     mentor: Mentor,
-    checkIns?: MonthlyCheckIn[]
+    checkIns?: MonthlyCheckIn[],
+    reminders?: MonthlyReminder[]
   ) {
     super()
     this.state = state || MenteeApplicationStatus.PENDING
     this.application = application
     this.profile = profile
     this.mentor = mentor
     this.checkIns = checkIns
+    this.reminders = reminders
   }
 }
 

src/entities/monthlyReminders.entity.ts

@@ -0,0 +1,29 @@
+import { Column, Entity, ManyToOne } from 'typeorm'
+import BaseEntity from './baseEntity'
+import { ReminderStatus } from '../enums'
+import Mentee from './mentee.entity'
+
+@Entity('monthly_reminders')
+export class MonthlyReminder extends BaseEntity {
+  @ManyToOne(() => Mentee, (mentee) => mentee.reminders)
+  mentee!: Mentee
+
+  @Column({
+    type: 'enum',
+    enum: ReminderStatus,
+    default: ReminderStatus.PENDING
+  })
+  status!: ReminderStatus
+
+  @Column({ type: 'text', nullable: true })
+  lastError!: string
+
+  @Column({ type: 'int', default: 0 })
+  remindersSent!: number
+
+  @Column({ type: 'timestamp', nullable: true })
+  nextReminderDate!: Date | null
+
+  @Column({ type: 'timestamp', nullable: true })
+  lastSentDate!: Date | null
+}

src/enums/index.ts

@@ -27,3 +27,12 @@ export enum StatusUpdatedBy {
   ADMIN = 'admin',
   MENTOR = 'mentor'
 }
+
+export enum ReminderStatus {
+  PENDING = 'pending',
+  SENDING = 'sending',
+  COMPLETED = 'completed',
+  FAILED = 'failed',
+  SENT = 'sent',
+  SCHEDULED = 'scheduled'
+}

src/migrations/1730893956260-MonthlyReminder.ts

@@ -0,0 +1,32 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MonthlyReminder1730893956260 implements MigrationInterface {
+    name = 'MonthlyReminder1730893956260'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "monthly_reminders" RENAME COLUMN "sentAt" TO "nextReminderDate"`);
+        await queryRunner.query(`ALTER TABLE "mentee" DROP COLUMN "last_monthlycheck_send_at"`);
+        await queryRunner.query(`ALTER TYPE "public"."monthly_reminders_status_enum" RENAME TO "monthly_reminders_status_enum_old"`);
+        await queryRunner.query(`CREATE TYPE "public"."monthly_reminders_status_enum" AS ENUM('pending', 'sending', 'completed', 'failed', 'sent', 'scheduled')`);
+        await queryRunner.query(`ALTER TABLE "monthly_reminders" ALTER COLUMN "status" DROP DEFAULT`);
+        await queryRunner.query(`ALTER TABLE "monthly_reminders" ALTER COLUMN "status" TYPE "public"."monthly_reminders_status_enum" USING "status"::"text"::"public"."monthly_reminders_status_enum"`);
+        await queryRunner.query(`ALTER TABLE "monthly_reminders" ALTER COLUMN "status" SET DEFAULT 'pending'`);
+        await queryRunner.query(`DROP TYPE "public"."monthly_reminders_status_enum_old"`);
+        await queryRunner.query(`ALTER TYPE "public"."reminder_attempts_status_enum" RENAME TO "reminder_attempts_status_enum_old"`);
+        await queryRunner.query(`CREATE TYPE "public"."reminder_attempts_status_enum" AS ENUM('pending', 'sending', 'completed', 'failed', 'sent', 'scheduled')`);
+        await queryRunner.query(`DROP TYPE "public"."reminder_attempts_status_enum_old"`);
+        await queryRunner.query(`CREATE TYPE "public"."reminder_attempts_status_enum" AS ENUM('pending', 'sending', 'completed', 'failed', 'sent', 'scheduled')`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TYPE "public"."monthly_reminders_status_enum_old" AS ENUM('pending', 'sending', 'completed', 'failed', 'done', 'scheduled', 'sent', 'waiting', 'processing')`);
+        await queryRunner.query(`ALTER TABLE "monthly_reminders" ALTER COLUMN "status" DROP DEFAULT`);
+        await queryRunner.query(`ALTER TABLE "monthly_reminders" ALTER COLUMN "status" TYPE "public"."monthly_reminders_status_enum_old" USING "status"::"text"::"public"."monthly_reminders_status_enum_old"`);
+        await queryRunner.query(`ALTER TABLE "monthly_reminders" ALTER COLUMN "status" SET DEFAULT 'pending'`);
+        await queryRunner.query(`DROP TYPE "public"."monthly_reminders_status_enum"`);
+        await queryRunner.query(`ALTER TYPE "public"."monthly_reminders_status_enum_old" RENAME TO "monthly_reminders_status_enum"`);
+        await queryRunner.query(`ALTER TABLE "mentee" ADD "last_monthlycheck_send_at" TIMESTAMP`);
+        await queryRunner.query(`ALTER TABLE "monthly_reminders" RENAME COLUMN "nextReminderDate" TO "sentAt"`);
+    }
+
+}

src/routes/admin/admin.route.ts

@@ -3,12 +3,14 @@ import userRouter from './user/user.route'
 import mentorRouter from './mentor/mentor.route'
 import categoryRouter from './category/category.route'
 import menteeRouter from './mentee/mentee.route'
+import reminderRouter from './remainder/remainder.route'
 
 const adminRouter = express()
 
 adminRouter.use('/users', userRouter)
 adminRouter.use('/mentors', mentorRouter)
 adminRouter.use('/mentees', menteeRouter)
 adminRouter.use('/categories', categoryRouter)
+adminRouter.use('/reminders', reminderRouter)
 
 export default adminRouter

src/routes/admin/remainder/remainder.route.ts

@@ -0,0 +1,8 @@
+import express from 'express'
+import { processEmailReminderHandler } from '../../../controllers/admin/email.controller'
+
+const reminderRouter = express.Router()
+
+reminderRouter.get('/process', processEmailReminderHandler)
+
+export default reminderRouter

src/services/admin/mentee.service.ts

@@ -163,6 +163,7 @@ export const updateStatus = async (
           certificate_id: content?.uniqueId
         }
       )
+
       return {
         statusCode: 200,
         message: 'Mentee application state successfully updated'

src/services/admin/reminder.service.ts

@@ -0,0 +1,163 @@
+import { type Repository } from 'typeorm'
+import { MonthlyReminder } from '../../entities/monthlyReminders.entity'
+import type Mentee from '../../entities/mentee.entity'
+import { MenteeApplicationStatus, ReminderStatus } from '../../enums'
+import { getReminderEmailContent } from '../../utils'
+import { sendEmail } from './email.service'
+
+export class MonthlyReminderService {
+  constructor(
+    private readonly reminderRepo: Repository<MonthlyReminder>,
+    private readonly menteeRepo: Repository<Mentee>
+  ) {}
+
+  async processReminders(): Promise<{
+    statusCode: number
+    message: string
+  }> {
+    // Schedule new reminders
+    try {
+      await this.scheduleNewReminder()
+
+      const today = new Date()
+      const todayDateString = today.toDateString()
+      console.log(todayDateString)
+
+      const pendingReminders = await this.reminderRepo
+        .createQueryBuilder('reminder')
+        .leftJoinAndSelect('reminder.mentee', 'mentee')
+        .leftJoinAndSelect('mentee.profile', 'profile')
+        .where('reminder.remindersSent <= :maxReminders', { maxReminders: 6 })
+        .andWhere('reminder.status != :status', {
+          status: ReminderStatus.COMPLETED
+        })
+        .andWhere(
+          "(reminder.lastSentDate IS NULL OR DATE_PART('month', reminder.lastSentDate) != DATE_PART('month', CURRENT_DATE))"
+        )
+        .getMany()
+
+      if (pendingReminders.length === 0) {
+        return {
+          statusCode: 200,
+          message: 'No reminders to process'
+        }
+      }
+
+      const remindersToSend = pendingReminders.filter(
+        (reminder) =>
+          reminder.nextReminderDate &&
+          new Date(reminder?.nextReminderDate).toDateString() ===
+            todayDateString
+      )
+
+      console.log(remindersToSend)
+
+      if (remindersToSend.length === 0) {
+        return {
+          statusCode: 200,
+          message: 'No reminders to process today'
+        }
+      }
+
+      for (const reminder of remindersToSend) {
+        try {
+          reminder.status = ReminderStatus.SENDING
+          await this.reminderRepo.save(reminder)
+
+          // Send email
+          const emailContent = getReminderEmailContent(
+            reminder.mentee.profile.first_name
+          )
+
+          await sendEmail(
+            reminder.mentee.profile.primary_email,
+            emailContent.subject,
+            emailContent.message
+          )
+
+          // Update reminder status
+          reminder.remindersSent += 1
+          reminder.lastSentDate = new Date()
+          reminder.status =
+            reminder.remindersSent >= 6
+              ? ReminderStatus.COMPLETED
+              : ReminderStatus.SCHEDULED
+
+          // Calculate next reminder date if not completed
+
+          if (reminder.status !== ReminderStatus.COMPLETED) {
+            reminder.nextReminderDate = await this.calculateNextReminderDate(
+              today
+            )
+          }
+          await this.reminderRepo.save(reminder)
+        } catch (error) {
+          reminder.status = ReminderStatus.FAILED
+          await this.reminderRepo.save(reminder)
+          console.error(
+            `Failed to process reminder for mentee ${reminder.mentee.uuid}:`,
+            error
+          )
+        }
+      }
+
+      return {
+        statusCode: 200,
+        message: `Processed ${pendingReminders.length} reminders`
+      }
+    } catch (error) {
+      console.error('Error processing reminders:', error)
+      return {
+        statusCode: 500,
+        message: 'Failed to process reminders'
+      }
+    }
+  }
+
+  private async calculateNextReminderDate(currentDate: Date): Promise<Date> {
+    const nextDate = new Date(currentDate)
+    nextDate.setDate(nextDate.getDate() + 25)
+    return nextDate
+  }
+
+  private async scheduleNewReminder(): Promise<void> {
+    const today = new Date()
+
+    const newMentees = await this.menteeRepo
+      .createQueryBuilder('mentee')
+      .leftJoinAndSelect('mentee.profile', 'profile')
+      .where('mentee.state = :state', {
+        state: MenteeApplicationStatus.APPROVED
+      })
+      .andWhere((qb) => {
+        const subQuery = qb
+          .subQuery()
+          .select('reminder.mentee.uuid')
+          .from(MonthlyReminder, 'reminder')
+          .getQuery()
+        return 'mentee.uuid NOT IN ' + subQuery
+      })
+      .getMany()
+
+    console.log(newMentees)
+
+    if (newMentees.length > 0) {
+      const reminders = await Promise.all(
+        newMentees.map(async (mentee) => {
+          const reminder = new MonthlyReminder()
+          reminder.mentee = mentee
+          reminder.remindersSent = 0
+          reminder.status = ReminderStatus.SCHEDULED
+          reminder.lastSentDate = null
+          reminder.nextReminderDate = await this.calculateNextReminderDate(
+            today
+          )
+          return reminder
+        })
+      )
+
+      await this.reminderRepo.save(reminders)
+      console.log(`Scheduled ${reminders.length} new reminders`)
+    }
+  }
+}

src/services/mentee.service.ts

@@ -10,7 +10,6 @@ import {
   capitalizeFirstLetter
 } from '../utils'
 import { sendEmail } from './admin/email.service'
-
 export const addMentee = async (
   user: Profile,
   application: Record<string, unknown>,