fix linting in files

Author: sombraSoft

src/shelter/shelter.service.ts

@@ -1,27 +1,20 @@
 import { z } from 'zod';
 import { Injectable } from '@nestjs/common';
-import * as qs from 'qs';
 import { Prisma } from '@prisma/client';
 import { DefaultArgs } from '@prisma/client/runtime/library';
-
 import { PrismaService } from '../prisma/prisma.service';
 import {
+  ComplexSearchSchema,
   CreateShelterSchema,
   FullUpdateShelterSchema,
   UpdateShelterSchema,
-} from './types/types';
-import { SearchSchema } from '../types';
-import { ShelterSearch, parseTagResponse } from './ShelterSearch';
-import { SupplyPriority } from '../supply/types';
-import { IFilterFormProps } from './types/search.types';
+} from './types';
+import { SeachQueryProps } from '@/decorators/search-query/types';
+import { SupplyPriority } from 'src/supply/types';
 
 @Injectable()
 export class ShelterService {
-  private voluntaryIds: string[] = [];
-
-  constructor(private readonly prismaService: PrismaService) {
-    this.loadVoluntaryIds();
-  }
+  constructor(private readonly prismaService: PrismaService) {}
 
   async store(body: z.infer<typeof CreateShelterSchema>) {
     const payload = CreateShelterSchema.parse(body);
@@ -84,7 +77,6 @@ export class ShelterService {
           },
           select: {
             priority: true,
-            quantity: true,
             supply: {
               select: {
                 id: true,
@@ -110,82 +102,229 @@ export class ShelterService {
     return data;
   }
 
-  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,
-    };
+  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({
-      ...whereData,
+      where: where,
+      orderBy: {
+        prioritySum: 'desc',
+      },
+      take,
+      skip,
       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: {
-              notIn: [SupplyPriority.UnderControl],
+              gt: SupplyPriority.UnderControl,
             },
           },
-          orderBy: {
-            updatedAt: 'desc',
-          },
-          include: {
-            supply: true,
+          select: {
+            priority: true,
+            supply: {
+              select: {
+                id: true,
+                name: true,
+                supplyCategory: {
+                  select: {
+                    id: true,
+                    name: true,
+                  },
+                },
+                createdAt: true,
+                updatedAt: true,
+              },
+            },
           },
         },
       },
     });
+    return { perPage: payload.perPage, page: payload.page, count, results };
+  }
 
-    const parsed = parseTagResponse(queryData, results, this.voluntaryIds);
+  private mountWhereFilter(payload: z.infer<typeof ComplexSearchSchema>) {
+    const filter: any = {
+      AND: [
+        {
+          OR: [
+            { address: { contains: payload.search, mode: 'insensitive' } },
+            { name: { contains: payload.search, mode: 'insensitive' } },
+          ],
+        },
+      ],
+    };
 
-    return {
-      page,
-      perPage,
-      count,
-      results: parsed,
+    const shelterSuppliesFilter = {
+      shelterSupplies: {
+        some: {},
+      },
     };
+
+    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;
   }
 
-  loadVoluntaryIds() {
-    this.prismaService.supplyCategory
-      .findMany({
-        where: {
-          name: {
-            in: ['Especialistas e Profissionais', 'Voluntariado'],
+  private addShelterStatusFilter(payload: z.infer<typeof ComplexSearchSchema>) {
+    const shelterStatusFilter: any = [];
+
+    if (payload.filterAvailableShelter) {
+      shelterStatusFilter.push({
+        AND: [
+          {
+            capacity: {
+              gt: this.prismaService.shelter.fields.shelteredPeople,
+            },
           },
-        },
-      })
-      .then((resp) => {
-        this.voluntaryIds.push(...resp.map((s) => s.id));
+          {
+            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,
+      });
+    }
+
+    return shelterStatusFilter;
   }
 }