feat: added decay shelter supply behaviour (#172)

- Adicionado o decaimento das prioridades dos suprimentos para
incentivar o usuário a atualizar os dados e para evitar dados
desatualizados na base.

Foi utilizado os seguintes critérios:

- Caso o suprimento seja de prioridade `Urgent` (máxima) e não é
atualizado a mais de 12 horas, ele é atualizado para o status de
`Needing`.

- Caso o suprimento seja de prioridade `Needing` ou `Remaining` e não é
atualizado a mais de 48 horas, sua prioridade é atualizada para sob
controle.

Além disso é salvo todos os logs do shelter supplies conforme já
implementado nos endpoints de update.

--

Foi escolhido a estratégia de aproveitar o retorno da lista de abrigo e
de abrigos únicos para obter a lista de suprimentos ao invés de rodar um
schedule que sempre percorre inteiramente o banco de dados. Dessa forma
essas atualizações serão por demanda.

src/interceptors/interceptors/shelter-supply-history/shelter-supply-history.interceptor.ts

@@ -8,15 +8,15 @@ import { Observable } from 'rxjs';
 
 import { ShelterSupplyHistoryAction } from './types';
 import { handler } from './utils';
-import { prisma } from '../../../prisma/prisma.service';
+import { PrismaService } from '../../../prisma/prisma.service';
 
 @Injectable()
 export class ShelterSupplyHistoryInterceptor implements NestInterceptor {
   constructor(private readonly action: ShelterSupplyHistoryAction) {}
 
   intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
     const request = context.switchToHttp().getRequest();
-    handler(prisma, this.action, request);
+    handler(PrismaService.getInstance(), this.action, request);
     return next.handle();
   }
 }

src/interceptors/interceptors/shelter-supply-history/utils.ts

@@ -14,15 +14,14 @@ import { ShelterSupplyHistoryAction, UserIdentity } from './types';
 import { getSessionData } from '@/utils/utils';
 
 function registerSupplyLog(
-  prismaService: PrismaService,
   body: z.infer<typeof CreateSupplyHistorySchema>,
-  user: UserIdentity,
+  user: UserIdentity = {},
 ) {
   const fn = async () => {
     const { shelterId, supplyId, ...rest } =
       CreateSupplyHistorySchema.parse(body);
 
-    const prev = await prismaService.supplyHistory.findFirst({
+    const prev = await PrismaService.getInstance().supplyHistory.findFirst({
       where: {
         shelterId,
         supplyId,
@@ -32,7 +31,7 @@ function registerSupplyLog(
       },
     });
 
-    await prismaService.supplyHistory.create({
+    await PrismaService.getInstance().supplyHistory.create({
       data: {
         shelterId,
         supplyId,
@@ -57,23 +56,20 @@ function registerSupplyLog(
 }
 
 function registerCreateSupplyLog(
-  prismaService: PrismaService,
   body: z.infer<typeof CreateShelterSupplySchema>,
   user: UserIdentity,
 ) {
   const payload = CreateShelterSupplySchema.parse(body);
-  registerSupplyLog(prismaService, payload, user);
+  registerSupplyLog(payload, user);
 }
 
 function registerUpdateSupplyLog(
-  prismaService: PrismaService,
   body: z.infer<typeof UpdateShelterSupplySchema>,
   user: UserIdentity,
 ) {
   const payload = UpdateShelterSupplySchema.parse(body);
 
   registerSupplyLog(
-    prismaService,
     {
       shelterId: payload.where.shelterId,
       supplyId: payload.where.supplyId,
@@ -85,15 +81,13 @@ function registerUpdateSupplyLog(
 }
 
 function registerUpdateManySupplyLog(
-  prismaService: PrismaService,
   body: z.infer<typeof UpdateManyShelterSupplySchema>,
   user: UserIdentity,
 ) {
   const { ids, shelterId } = UpdateManyShelterSupplySchema.parse(body);
 
   ids.forEach((id) =>
     registerSupplyLog(
-      prismaService,
       {
         shelterId,
         supplyId: id,
@@ -124,11 +118,10 @@ function handler(
 
   switch (action) {
     case ShelterSupplyHistoryAction.Create:
-      registerCreateSupplyLog(prismaService, request.body as any, user);
+      registerCreateSupplyLog(request.body as any, user);
       break;
     case ShelterSupplyHistoryAction.Update:
       registerUpdateSupplyLog(
-        prismaService,
         {
           data: request.body as any,
           where: request.params as any,
@@ -138,7 +131,6 @@ function handler(
       break;
     case ShelterSupplyHistoryAction.UpdateMany:
       registerUpdateManySupplyLog(
-        prismaService,
         {
           shelterId: (request.params as any).shelterId,
           ids: (request.body as any).ids,
@@ -149,4 +141,4 @@ function handler(
   }
 }
 
-export { handler };
+export { handler, registerSupplyLog };

src/prisma/prisma.service.ts

@@ -39,5 +39,3 @@ export class PrismaService
     });
   }
 }
-
-export const prisma = PrismaService.getInstance();

src/shelter/shelter.service.ts

@@ -1,7 +1,7 @@
-import { Injectable, OnModuleInit } from '@nestjs/common';
-import { Prisma } from '@prisma/client';
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { Prisma, ShelterSupply } from '@prisma/client';
 import { DefaultArgs } from '@prisma/client/runtime/library';
-import { subDays } from 'date-fns';
+import { millisecondsToHours, subDays } from 'date-fns';
 import * as qs from 'qs';
 import { z } from 'zod';
 
@@ -13,11 +13,14 @@ import { ShelterSearchPropsSchema } from './types/search.types';
 import {
   CreateShelterSchema,
   FullUpdateShelterSchema,
+  IShelterSupplyDecay,
   UpdateShelterSchema,
 } from './types/types';
+import { registerSupplyLog } from '@/interceptors/interceptors/shelter-supply-history/utils';
 
 @Injectable()
 export class ShelterService implements OnModuleInit {
+  private logger = new Logger(ShelterService.name);
   private voluntaryIds: string[] = [];
 
   constructor(private readonly prismaService: PrismaService) {}
@@ -93,6 +96,10 @@ export class ShelterService implements OnModuleInit {
           select: {
             priority: true,
             quantity: true,
+            supplyId: true,
+            shelterId: true,
+            createdAt: true,
+            updatedAt: true,
             supply: {
               select: {
                 id: true,
@@ -115,6 +122,8 @@ export class ShelterService implements OnModuleInit {
       },
     });
 
+    if (data) this.decayShelterSupply(data.shelterSupplies);
+
     return data;
   }
 
@@ -181,6 +190,8 @@ export class ShelterService implements OnModuleInit {
       },
     });
 
+    this.decayShelterSupply(results.flatMap((r) => r.shelterSupplies));
+
     const parsed = parseTagResponse(queryData, results, this.voluntaryIds);
 
     return {
@@ -228,4 +239,100 @@ export class ShelterService implements OnModuleInit {
         this.voluntaryIds.push(...resp.map((s) => s.id));
       });
   }
+
+  private parseShelterSupply(
+    shelterSupply: ShelterSupply,
+  ): IShelterSupplyDecay {
+    return {
+      shelterId: shelterSupply.shelterId,
+      supplyId: shelterSupply.supplyId,
+      priority: shelterSupply.priority,
+      createdAt: new Date(shelterSupply.createdAt).getTime(),
+      updatedAt: shelterSupply.updatedAt
+        ? new Date(shelterSupply.updatedAt).getTime()
+        : 0,
+    };
+  }
+
+  private canDecayShelterSupply(
+    shelterSupply: IShelterSupplyDecay,
+    priorities: SupplyPriority[],
+    timeInHoursToDecay: number,
+  ): boolean {
+    return (
+      priorities.includes(shelterSupply.priority) &&
+      millisecondsToHours(
+        new Date().getTime() -
+          Math.max(shelterSupply.createdAt, shelterSupply.updatedAt),
+      ) > timeInHoursToDecay
+    );
+  }
+
+  private async handleDecayShelterSupply(
+    shelterSupplies: IShelterSupplyDecay[],
+    newPriority: SupplyPriority,
+  ) {
+    const shelterIds: Set<string> = new Set();
+    shelterSupplies.forEach((s) => shelterIds.add(s.shelterId));
+
+    await this.prismaService.$transaction([
+      this.prismaService.shelter.updateMany({
+        where: {
+          id: {
+            in: Array.from(shelterIds),
+          },
+        },
+        data: {
+          updatedAt: new Date().toISOString(),
+        },
+      }),
+      ...shelterSupplies.map((s) =>
+        this.prismaService.shelterSupply.update({
+          where: {
+            shelterId_supplyId: {
+              shelterId: s.shelterId,
+              supplyId: s.supplyId,
+            },
+          },
+          data: {
+            priority: newPriority,
+            updatedAt: new Date().toISOString(),
+          },
+        }),
+      ),
+    ]);
+
+    shelterSupplies.forEach((s) => {
+      registerSupplyLog({
+        shelterId: s.shelterId,
+        supplyId: s.supplyId,
+        priority: newPriority,
+      });
+    });
+  }
+
+  private async decayShelterSupply(shelterSupplies: ShelterSupply[]) {
+    this.handleDecayShelterSupply(
+      shelterSupplies
+        .map(this.parseShelterSupply)
+        .filter((f) =>
+          this.canDecayShelterSupply(f, [SupplyPriority.Urgent], 12),
+        ),
+
+      SupplyPriority.Needing,
+    );
+
+    this.handleDecayShelterSupply(
+      shelterSupplies
+        .map(this.parseShelterSupply)
+        .filter((f) =>
+          this.canDecayShelterSupply(
+            f,
+            [SupplyPriority.Needing, SupplyPriority.Remaining],
+            48,
+          ),
+        ),
+      SupplyPriority.UnderControl,
+    );
+  }
 }

src/shelter/types/types.ts

@@ -49,6 +49,14 @@ const FullUpdateShelterSchema = ShelterSchema.omit({
   .partial()
   .transform((args) => removeEmptyStrings<typeof args>(args));
 
+export interface IShelterSupplyDecay {
+  shelterId: string;
+  supplyId: string;
+  priority: number;
+  createdAt: number;
+  updatedAt: number;
+}
+
 export {
   ShelterSchema,
   CreateShelterSchema,