feat: only show contact on shelter public routes on authorized roles

Author: kelvinsb

src/decorators/UserDecorator/index.ts

@@ -0,0 +1,3 @@
+import { UserDecorator } from './user.decorator';
+
+export { UserDecorator };

src/guards/utils.ts

@@ -41,4 +41,4 @@ async function isRightSessionRole(
   return false;
 }
 
-export { canActivate };
+export { canActivate, isRightSessionRole };

src/shelter/shelter.controller.ts

@@ -15,6 +15,8 @@ import { ApiTags } from '@nestjs/swagger';
 import { ShelterService } from './shelter.service';
 import { ServerResponse } from '../utils';
 import { StaffGuard } from '@/guards/staff.guard';
+import { ApplyUser } from '@/guards/apply-user.guard';
+import { UserDecorator } from '@/decorators/UserDecorator';
 
 @ApiTags('Abrigos')
 @Controller('shelters')
@@ -35,9 +37,10 @@ export class ShelterController {
   }
 
   @Get(':id')
-  async show(@Param('id') id: string) {
+  @UseGuards(ApplyUser)
+  async show(@UserDecorator() user: any, @Param('id') id: string) {
     try {
-      const data = await this.shelterService.show(id);
+      const data = await this.shelterService.show(id, user);
       return new ServerResponse(200, 'Successfully get shelter', data);
     } catch (err: any) {
       this.logger.error(`Failed to get shelter: ${err}`);

src/shelter/shelter.service.ts

@@ -1,20 +1,28 @@
 import { z } from 'zod';
 import { Injectable } from '@nestjs/common';
-import { Prisma } from '@prisma/client';
+import * as qs from 'qs';
+import { Prisma, AccessLevel } from '@prisma/client';
 import { DefaultArgs } from '@prisma/client/runtime/library';
+
 import { PrismaService } from '../prisma/prisma.service';
 import {
-  ComplexSearchSchema,
   CreateShelterSchema,
   FullUpdateShelterSchema,
   UpdateShelterSchema,
-} from './types';
-import { SeachQueryProps } from '@/decorators/search-query/types';
-import { SupplyPriority } from 'src/supply/types';
+} from './types/types';
+import { SearchSchema } from '../types';
+import { ShelterSearch, parseTagResponse } from './ShelterSearch';
+import { SupplyPriority } from '../supply/types';
+import { IFilterFormProps } from './types/search.types';
+import { isRightSessionRole } from '@/guards/utils';
 
 @Injectable()
 export class ShelterService {
-  constructor(private readonly prismaService: PrismaService) {}
+  private voluntaryIds: string[] = [];
+
+  constructor(private readonly prismaService: PrismaService) {
+    this.loadVoluntaryIds();
+  }
 
   async store(body: z.infer<typeof CreateShelterSchema>) {
     const payload = CreateShelterSchema.parse(body);
@@ -53,7 +61,13 @@ export class ShelterService {
     });
   }
 
-  async show(id: string) {
+  async show(id: string, user: any) {
+    const isLogged = await isRightSessionRole(
+      [AccessLevel.User, AccessLevel.Staff],
+      user?.sessionId,
+      user?.userId,
+    );
+
     const data = await this.prismaService.shelter.findFirst({
       where: {
         id,
@@ -65,7 +79,7 @@ export class ShelterService {
         pix: true,
         shelteredPeople: true,
         capacity: true,
-        contact: true,
+        contact: isLogged,
         petFriendly: true,
         prioritySum: true,
         latitude: true,
@@ -74,6 +88,7 @@ export class ShelterService {
         shelterSupplies: {
           select: {
             priority: true,
+            quantity: true,
             supply: {
               select: {
                 id: true,
@@ -99,229 +114,82 @@ export class ShelterService {
     return data;
   }
 
-  async index(props: SeachQueryProps) {
-    const { handleSearch } = props;
-
-    return await handleSearch<Prisma.ShelterSelect<DefaultArgs>>(
-      this.prismaService.shelter,
-      {
-        select: {
-          id: true,
-          name: true,
-          pix: true,
-          address: true,
-          capacity: true,
-          contact: true,
-          petFriendly: true,
-          shelteredPeople: true,
-          prioritySum: true,
-          verified: true,
-          latitude: true,
-          longitude: true,
-          createdAt: true,
-          updatedAt: true,
-          shelterSupplies: {
-            where: {
-              priority: {
-                gt: SupplyPriority.UnderControl,
-              },
-            },
-            select: {
-              priority: true,
-              supply: {
-                select: {
-                  id: true,
-                  name: true,
-                  supplyCategory: {
-                    select: {
-                      id: true,
-                      name: true,
-                    },
-                  },
-                  createdAt: true,
-                  updatedAt: true,
-                },
-              },
-            },
-          },
-        },
-      },
-    );
-  }
-
-  async search(props: z.infer<typeof ComplexSearchSchema>) {
-    const payload = ComplexSearchSchema.parse({
-      ...props,
-      supplyCategories:
-        typeof props['supplyCategories[]'] === 'string'
-          ? [props['supplyCategories[]']]
-          : props['supplyCategories[]'],
-      supplies:
-        typeof props['supplies[]'] === 'string'
-          ? [props['supplies[]']]
-          : props['supplies[]'],
-    });
-
-    const shelterStatusFilter = this.addShelterStatusFilter(payload);
-    const where = this.mountWhereFilter(payload);
-    const take = payload.perPage;
-    const skip = payload.perPage * (payload.page - 1);
-
-    if (shelterStatusFilter.length > 0) {
-      where['AND'].push({
-        OR: shelterStatusFilter,
-      });
-    }
-
-    const count = await this.prismaService.shelter.count({
-      where: where,
-    });
-
-    const results = await this.prismaService.shelter.findMany({
-      where: where,
-      orderBy: {
-        prioritySum: 'desc',
-      },
+  async index(query: any) {
+    const {
+      order,
+      orderBy,
+      page,
+      perPage,
+      search: searchQuery,
+    } = SearchSchema.parse(query);
+    const queryData = qs.parse(searchQuery) as unknown as IFilterFormProps;
+    const { query: where } = new ShelterSearch(this.prismaService, queryData);
+    const count = await this.prismaService.shelter.count({ where });
+
+    const take = perPage;
+    const skip = perPage * (page - 1);
+
+    const whereData: Prisma.ShelterFindManyArgs<DefaultArgs> = {
       take,
       skip,
+      orderBy: { [orderBy]: order },
+      where,
+    };
+
+    const results = await this.prismaService.shelter.findMany({
+      ...whereData,
       select: {
         id: true,
         name: true,
         pix: true,
         address: true,
         capacity: true,
         contact: true,
-        verified: true,
         petFriendly: true,
         shelteredPeople: true,
         prioritySum: true,
+        verified: true,
         latitude: true,
         longitude: true,
         createdAt: true,
         updatedAt: true,
         shelterSupplies: {
           where: {
             priority: {
-              gt: SupplyPriority.UnderControl,
+              notIn: [SupplyPriority.UnderControl],
             },
           },
-          select: {
-            priority: true,
-            supply: {
-              select: {
-                id: true,
-                name: true,
-                supplyCategory: {
-                  select: {
-                    id: true,
-                    name: true,
-                  },
-                },
-                createdAt: true,
-                updatedAt: true,
-              },
-            },
+          orderBy: {
+            updatedAt: 'desc',
+          },
+          include: {
+            supply: true,
           },
         },
       },
     });
-    return { perPage: payload.perPage, page: payload.page, count, results };
-  }
 
-  private mountWhereFilter(payload: z.infer<typeof ComplexSearchSchema>) {
-    const filter: any = {
-      AND: [
-        {
-          OR: [
-            { address: { contains: payload.search, mode: 'insensitive' } },
-            { name: { contains: payload.search, mode: 'insensitive' } },
-          ],
-        },
-      ],
-    };
+    const parsed = parseTagResponse(queryData, results, this.voluntaryIds);
 
-    const shelterSuppliesFilter = {
-      shelterSupplies: {
-        some: {},
-      },
+    return {
+      page,
+      perPage,
+      count,
+      results: parsed,
     };
-
-    if (payload.priority) {
-      shelterSuppliesFilter.shelterSupplies.some['priority'] = parseInt(
-        payload.priority,
-      );
-    }
-
-    if (payload?.supplyCategories && payload?.supplyCategories.length !== 0) {
-      shelterSuppliesFilter.shelterSupplies.some['supply'] = {
-        supplyCategoryId: {
-          in: payload.supplyCategories,
-        },
-      };
-    }
-
-    if (payload?.supplies && payload?.supplies.length !== 0) {
-      shelterSuppliesFilter.shelterSupplies.some['supplyId'] = {
-        in: payload.supplies,
-      };
-    }
-
-    if (Object.keys(shelterSuppliesFilter.shelterSupplies.some).length !== 0) {
-      filter['AND'].push(shelterSuppliesFilter);
-    }
-
-    return filter;
   }
 
-  private addShelterStatusFilter(payload: z.infer<typeof ComplexSearchSchema>) {
-    const shelterStatusFilter: any = [];
-
-    if (payload.filterAvailableShelter) {
-      shelterStatusFilter.push({
-        AND: [
-          {
-            capacity: {
-              gt: this.prismaService.shelter.fields.shelteredPeople,
-            },
+  loadVoluntaryIds() {
+    this.prismaService.supplyCategory
+      .findMany({
+        where: {
+          name: {
+            in: ['Especialistas e Profissionais', 'Voluntariado'],
           },
-          {
-            capacity: { not: null },
-          },
-          {
-            shelteredPeople: { not: null },
-          },
-        ],
-      });
-    }
-
-    if (payload.filterUnavailableShelter) {
-      shelterStatusFilter.push({
-        AND: [
-          {
-            capacity: {
-              lte: this.prismaService.shelter.fields.shelteredPeople,
-            },
-          },
-          {
-            capacity: { not: null },
-          },
-          {
-            shelteredPeople: { not: null },
-          },
-        ],
-      });
-    }
-
-    if (payload.waitingShelterAvailability) {
-      shelterStatusFilter.push({
-        capacity: null,
-      });
-
-      shelterStatusFilter.push({
-        shelteredPeople: null,
+        },
+      })
+      .then((resp) => {
+        this.voluntaryIds.push(...resp.map((s) => s.id));
       });
-    }
-
-    return shelterStatusFilter;
   }
 }