Implement Automatic remainder sending email service

package.json

@@ -28,11 +28,13 @@
     "body-parser": "^1.20.2",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",
+    "date-fns": "^4.1.0",
     "dotenv": "^16.3.1",
     "ejs": "^3.1.10",
     "express": "^4.18.2",
     "jsonwebtoken": "^9.0.2",
     "multer": "^1.4.5-lts.1",
+    "node-cron": "^3.0.3",
     "nodemailer": "^6.9.13",
     "passport": "^0.6.0",
     "passport-google-oauth20": "^2.0.0",
@@ -56,6 +58,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

@@ -1,6 +1,7 @@
 import bodyParser from 'body-parser'
 import cookieParser from 'cookie-parser'
 import cors from 'cors'
+import cron from 'node-cron'
 import type { Express } from 'express'
 import express from 'express'
 import fs from 'fs'
@@ -18,7 +19,7 @@ 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'
-
+import { EmailReminderService } from './services/admin/reminder.service'
 const app = express()
 const staticFolder = 'uploads'
 export const certificatesDir = path.join(__dirname, 'certificates')
@@ -59,6 +60,19 @@ if (!fs.existsSync(certificatesDir)) {
   fs.mkdirSync(certificatesDir)
 }
 
+const sqlReminderService = new EmailReminderService()
+
+// Setup periodic processing
+setInterval(async () => {
+  await sqlReminderService.processReminders()
+}, 60000) // Check every minute
+
+// Schedule new reminders daily
+cron.schedule('* * * * *', async () => {
+  console.log('Scheduling daily reminders')
+  await sqlReminderService.scheduleReminders()
+})
+
 export const startServer = async (port: number): Promise<Express> => {
   try {
     await dataSource.initialize()

src/controllers/admin/email.controller.ts

@@ -30,3 +30,15 @@ export const sendEmailController = async (
     throw err
   }
 }
+
+export const enableEmailReminderHandler = async (
+  req: Request,
+  res: Response
+): Promise<void> => {
+  try {
+    res.status(200).json({ message: 'Reminder enabled' })
+  } catch (err) {
+    console.error('Error enabling reminder', err)
+    res.status(500).json({ message: 'Error enabling reminder' })
+  }
+}

src/entities/failedReminders.entity.ts

@@ -0,0 +1,21 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm'
+import BaseEntity from './baseEntity'
+import Mentee from './mentee.entity'
+
+@Entity('failed_reminders')
+class FailedReminders extends BaseEntity {
+  @Column({ type: 'text' })
+  error: string
+
+  @ManyToOne(() => Mentee, (mentee) => mentee.failedReminders)
+  @JoinColumn({ name: 'menteeId' })
+  mentee: Mentee
+
+  constructor(error: string, mentee: Mentee) {
+    super()
+    this.error = error
+    this.mentee = mentee
+  }
+}
+
+export default FailedReminders

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 FailedReminders from './failedReminders.entity'
 
 @Entity('mentee')
 class Mentee extends BaseEntity {
@@ -21,6 +22,9 @@ class Mentee extends BaseEntity {
   @Column({ type: 'timestamp', nullable: true })
   status_updated_date!: Date
 
+  @Column({ type: 'timestamp', nullable: true })
+  last_monthlycheck_reminder_date!: Date
+
   @Column({ type: 'json' })
   application: Record<string, unknown>
 
@@ -39,19 +43,24 @@ class Mentee extends BaseEntity {
   @OneToMany(() => MonthlyCheckIn, (checkIn) => checkIn.mentee)
   checkIns?: MonthlyCheckIn[]
 
+  @OneToMany(() => FailedReminders, (failedReminder) => failedReminder.mentee)
+  failedReminders?: FailedReminders[]
+
   constructor(
     state: MenteeApplicationStatus,
     application: Record<string, unknown>,
     profile: profileEntity,
     mentor: Mentor,
-    checkIns?: MonthlyCheckIn[]
+    checkIns?: MonthlyCheckIn[],
+    failedReminders?: FailedReminders[]
   ) {
     super()
     this.state = state || MenteeApplicationStatus.PENDING
     this.application = application
     this.profile = profile
     this.mentor = mentor
     this.checkIns = checkIns
+    this.failedReminders = failedReminders
   }
 }
 

src/entities/mentee_reminder_configs.entity.ts

@@ -0,0 +1,51 @@
+import { Entity, Column, OneToOne, OneToMany, JoinColumn, Index } from 'typeorm'
+import BaseEntity from './baseEntity'
+import Mentee from './mentee.entity'
+import ReminderAttempt from './reminder_attempts.entity'
+
+@Entity('mentee_reminder_configs')
+class MenteeReminderConfig extends BaseEntity {
+  @Column({ type: 'uuid', primary: true })
+  @Index({ unique: true }) // Add unique constraint
+  menteeId!: string
+
+  @Column({ type: 'varchar', length: 255 })
+  email!: string
+
+  @Column({ type: 'varchar', length: 255 })
+  firstName!: string
+
+  @Column({ type: 'timestamp', nullable: true })
+  firstReminderSentAt?: Date
+
+  @Column({ type: 'int', default: 0 })
+  currentSequence!: number
+
+  @Column({ type: 'timestamp', nullable: true })
+  lastReminderSentAt?: Date
+
+  @Column({ type: 'timestamp' })
+  nextReminderDue!: Date
+
+  @Column({ type: 'boolean', default: false })
+  isComplete!: boolean
+
+  @OneToOne(() => Mentee)
+  @JoinColumn({ name: 'menteeId' })
+  mentee!: Mentee
+
+  @OneToMany(() => ReminderAttempt, (attempt) => attempt.reminderConfig)
+  attempts?: ReminderAttempt[]
+
+  constructor(menteeId: string, email: string, firstName: string) {
+    super()
+    this.menteeId = menteeId
+    this.email = email
+    this.firstName = firstName
+    this.currentSequence = 0
+    this.nextReminderDue = new Date()
+    this.isComplete = false
+  }
+}
+
+export default MenteeReminderConfig

src/entities/reminder_attempts.entity.ts

@@ -0,0 +1,49 @@
+import { ReminderStatus } from '../enums'
+import BaseEntity from './baseEntity'
+import { Column, Entity, JoinColumn, ManyToOne } from 'typeorm'
+import MenteeReminderConfig from './mentee_reminder_configs.entity'
+
+@Entity('reminder_attempts')
+class ReminderAttempt extends BaseEntity {
+  @Column({ type: 'uuid' }) // Changed to uuid to match parent table
+  menteeId!: string
+
+  @Column({
+    type: 'enum',
+    enum: ReminderStatus,
+    default: ReminderStatus.PENDING
+  })
+  status!: ReminderStatus
+
+  @Column({ type: 'int' })
+  sequence!: number
+
+  @Column({ default: 0 })
+  retryCount!: number
+
+  @Column({ type: 'timestamp', nullable: true })
+  processedAt?: Date
+
+  @Column({ type: 'timestamp' })
+  nextRetryAt!: Date
+
+  @Column({ type: 'text', nullable: true })
+  errorMessage?: string
+
+  @ManyToOne(() => MenteeReminderConfig, (config) => config.attempts, {
+    onDelete: 'CASCADE'
+  })
+  @JoinColumn({ name: 'menteeId', referencedColumnName: 'menteeId' })
+  reminderConfig?: MenteeReminderConfig
+
+  constructor(menteeId: string, sequence: number) {
+    super()
+    this.menteeId = menteeId
+    this.sequence = sequence
+    this.status = ReminderStatus.PENDING
+    this.retryCount = 0
+    this.nextRetryAt = new Date()
+  }
+}
+
+export default ReminderAttempt

src/enums/index.ts

@@ -27,3 +27,11 @@ export enum StatusUpdatedBy {
   ADMIN = 'admin',
   MENTOR = 'mentor'
 }
+
+export enum ReminderStatus {
+  PENDING = 'pending',
+  PROCESSING = 'processing',
+  COMPLETE = 'complete',
+  FAILED = 'failed',
+  DONE = 'done'
+}

src/migrations/1730033358494-reminder_config.ts

@@ -0,0 +1,22 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class ReminderConfig1730033358494 implements MigrationInterface {
+    name = 'ReminderConfig1730033358494'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TABLE "reminder_attempts" ("uuid" uuid NOT NULL DEFAULT uuid_generate_v4(), "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "menteeId" uuid NOT NULL, "status" "public"."reminder_attempts_status_enum" NOT NULL DEFAULT 'pending', "sequence" integer NOT NULL, "retryCount" integer NOT NULL DEFAULT '0', "processedAt" TIMESTAMP, "nextRetryAt" TIMESTAMP NOT NULL, "errorMessage" text, CONSTRAINT "PK_c5ba5d688c6a78a67c786f5cb2b" PRIMARY KEY ("uuid"))`);
+        await queryRunner.query(`CREATE TABLE "mentee_reminder_configs" ("uuid" uuid NOT NULL DEFAULT uuid_generate_v4(), "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "menteeId" uuid NOT NULL, "email" character varying(255) NOT NULL, "firstName" character varying(255) NOT NULL, "firstReminderSentAt" TIMESTAMP, "currentSequence" integer NOT NULL DEFAULT '0', "lastReminderSentAt" TIMESTAMP, "nextReminderDue" TIMESTAMP NOT NULL, "isComplete" boolean NOT NULL DEFAULT false, CONSTRAINT "PK_ce2ebbc0fd11a8e0e1c35f06108" PRIMARY KEY ("uuid", "menteeId"))`);
+        await queryRunner.query(`CREATE UNIQUE INDEX "IDX_19e37bcbcb83cf968be2ffe4e6" ON "mentee_reminder_configs" ("menteeId") `);
+        await queryRunner.query(`ALTER TABLE "reminder_attempts" ADD CONSTRAINT "FK_5d0f136c64e679dd74878f496c6" FOREIGN KEY ("menteeId") REFERENCES "mentee_reminder_configs"("menteeId") ON DELETE CASCADE ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "mentee_reminder_configs" ADD CONSTRAINT "FK_19e37bcbcb83cf968be2ffe4e69" FOREIGN KEY ("menteeId") REFERENCES "mentee"("uuid") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "mentee_reminder_configs" DROP CONSTRAINT "FK_19e37bcbcb83cf968be2ffe4e69"`);
+        await queryRunner.query(`ALTER TABLE "reminder_attempts" DROP CONSTRAINT "FK_5d0f136c64e679dd74878f496c6"`);
+        await queryRunner.query(`DROP INDEX "public"."IDX_19e37bcbcb83cf968be2ffe4e6"`);
+        await queryRunner.query(`DROP TABLE "mentee_reminder_configs"`);
+        await queryRunner.query(`DROP TABLE "reminder_attempts"`);
+    }
+
+}

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('/enable', reminderRouter)
 
 export default adminRouter

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

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