Added a cron job to ShelterSupply module to run every 30 minutes to change priority of expired supplies (urgent older than 4 hours)

Author: gustavocs

package-lock.json

@@ -30,6 +30,7 @@
     "@nestjs/passport": "^10.0.3",
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/platform-fastify": "^10.3.8",
+    "@nestjs/schedule": "^4.0.2",
     "@nestjs/swagger": "^7.3.1",
     "@prisma/client": "^5.13.0",
     "bcrypt": "^5.1.1",

package.json

@@ -1,5 +1,6 @@
 import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
 import { APP_INTERCEPTOR } from '@nestjs/core';
+import { ScheduleModule } from '@nestjs/schedule';
 
 import { PrismaModule } from './prisma/prisma.module';
 import { ShelterModule } from './shelter/shelter.module';
@@ -15,6 +16,7 @@ import { ShelterSupplyModule } from './shelter-supply/shelter-supply.module';
 @Module({
   imports: [
     PrismaModule,
+    ScheduleModule.forRoot(),
     UsersModule,
     SessionsModule,
     ShelterModule,

src/app.module.ts

@@ -0,0 +1,3 @@
+const priorityExpiryInterval = 4; // In hours
+
+export { priorityExpiryInterval };

src/shelter-supply/constants.ts

@@ -0,0 +1,63 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { Cron, CronExpression } from '@nestjs/schedule';
+import { PrismaService } from '../prisma/prisma.service';
+import { addHours } from '@/utils';
+import { priorityExpiryInterval } from './constants';
+import { SupplyPriority } from '../supply/types';
+import { ShelterSupplyService } from './shelter-supply.service';
+
+@Injectable()
+export class ShelterSupplyJob {
+  constructor(
+    private readonly prismaService: PrismaService,
+    private readonly shelterSupplyService: ShelterSupplyService,
+  ) {}
+
+  private readonly logger = new Logger(ShelterSupplyJob.name);
+
+  @Cron(CronExpression.EVERY_30_MINUTES)
+  async handleCron() {
+    this.logger.log(`${ShelterSupplyJob.name} running`);
+
+    const expiryDate = addHours(
+      new Date(Date.now()),
+      -priorityExpiryInterval,
+    ).toString();
+
+    const outatedSupplies = await this.prismaService.shelterSupply.findMany({
+      where: {
+        AND: [
+          { priority: SupplyPriority.Urgent },
+          {
+            OR: [
+              {
+                createdAt: {
+                  lte: expiryDate,
+                },
+              },
+              {
+                updatedAt: {
+                  lte: expiryDate,
+                },
+              },
+            ],
+          },
+        ],
+      },
+      select: {
+        supplyId: true,
+        shelterId: true,
+      },
+    });
+
+    outatedSupplies.forEach(async (s) => {
+      const { shelterId, supplyId } = s;
+      await this.shelterSupplyService.update({
+        data: {
+          priority: SupplyPriority.Needing,
+        },
+        where: { shelterId: shelterId, supplyId: supplyId },
+      });
+    });
+  }
+}

src/shelter-supply/shelter-supply.job.ts

@@ -3,10 +3,11 @@ import { Module } from '@nestjs/common';
 import { ShelterSupplyService } from './shelter-supply.service';
 import { ShelterSupplyController } from './shelter-supply.controller';
 import { PrismaModule } from '../prisma/prisma.module';
+import { ShelterSupplyJob } from './shelter-supply.job';
 
 @Module({
   imports: [PrismaModule],
-  providers: [ShelterSupplyService],
+  providers: [ShelterSupplyService, ShelterSupplyJob],
   controllers: [ShelterSupplyController],
 })
 export class ShelterSupplyModule {}

src/shelter-supply/shelter-supply.module.ts

@@ -4,6 +4,7 @@ import {
   getSessionData,
   deepMerge,
   capitalize,
+  addHours,
 } from './utils';
 
 export {
@@ -12,4 +13,5 @@ export {
   removeNotNumbers,
   getSessionData,
   deepMerge,
+  addHours,
 };

src/utils/index.ts

@@ -75,10 +75,82 @@ function deepMerge(target: Record<string, any>, source: Record<string, any>) {
   }
 }
 
+function parseStringToObject(path: string, value: any) {
+  const keys = path.split('.');
+  const currentObj = {};
+  let temp = currentObj;
+
+  keys.forEach((key, index) => {
+    if (index === keys.length - 1) {
+      temp[key] = value;
+    } else {
+      temp[key] = {};
+      temp = temp[key];
+    }
+  });
+
+  return currentObj;
+}
+
+function getSearchWhere(search: string, or?: boolean) {
+  const where = {};
+  if (search !== '') {
+    const terms = search.split(',');
+    const groups: Record<string, { condition: string; mode?: string }[]> =
+      terms.reduce((prev, current) => {
+        const [key, condition, value] = current.split(':');
+        const isBoolean = ['true', 'false'].includes(value);
+        const mode =
+          isBoolean || ['in', 'notIn'].includes(condition)
+            ? undefined
+            : 'insensitive';
+        const parsedValue = isBoolean ? value === 'true' : value;
+
+        return {
+          ...prev,
+          [key]: [
+            ...(prev[key] ?? []),
+            {
+              [condition]: ['in', 'notIn'].includes(condition)
+                ? [parsedValue]
+                : parsedValue,
+              mode,
+            },
+          ],
+        };
+      }, {});
+
+    const parsed = Object.entries(groups).reduce((prev, [key, current]) => {
+      if (current.length > 1) {
+        return {
+          ...prev,
+          AND: current.map((c) => parseStringToObject(key, c)),
+        };
+      } else return deepMerge(prev, parseStringToObject(key, current[0]));
+    }, {});
+    Object.assign(where, parsed);
+  }
+  if (or) {
+    return {
+      OR: Object.entries(where).reduce(
+        (prev, [key, value]) => [...prev, { [key]: value }],
+        [] as any[],
+      ),
+    };
+  } else return where;
+}
+
+function addHours(date: Date, hours: number) {
+  const result = new Date();
+  result.setTime(date.getTime() + hours * 60 * 60 * 1000);
+  return result;
+}
+
 export {
   ServerResponse,
   removeNotNumbers,
   getSessionData,
   deepMerge,
   capitalize,
+  addHours,
 };