this._router.get(
      "/quotation",
      verifyRoles([rolesStr.SUPERVISOR, rolesStr["BRANCH STATISTICIAN"]]),
      this._controller.getQuotations
    ); the above route handler is used by both supervisor and branch statistician roles to fetch quotations.  And the below code is the function used to fetch quotations to the route  async getQuotations(req: Request, res: Response, next: NextFunction) {
    try {
      const query: any = req.query;
      const regionCodeOrCodes = await getRegionCodeOrCodes(req.user!);
      const regionalStatusFilter =
        getQuestionnaireRegionalStatusFilter(regionCodeOrCodes);
      const questionnaire = await prisma.questionnaire.findFirst({
        orderBy: [{ startDate: "desc" }],
        where: {
          designatedRole: rolesNum["DATA COLLECTOR"],
          approved: true,
          disabled: false,
          endDate: {
            gte: addDays(new Date(), -5),
          },
          startDate: {
            lte: new Date(),
          },
          isDraft: false,
        },
        include: {
          questionnaireItems: {
            where: {
              disabled: false,
            },
            include: {
              quotations: {
                where: {
                  status: {
                    not: QuotationStatus.SUPERVISOR_APPROVED,
                  },
                },
              },
              item: {
                include: {
                  translation: true,
                  itemMeasurements: true,
                },
              },
            },
          },
          questionnaireRegionStatus: {
            where: regionalStatusFilter,
          },
        },
      });

      const datacollectors = await prisma.user.findMany({
        where:
          req.user?.role === rolesNum.SUPERVISOR
            ? {
                supervisorId: req.user?.id,
              }
            : { marketplace: { branchCode: req.user?.branchCode } },
      });

      if (
        req.user?.role === rolesNum.SUPERVISOR &&
        (!datacollectors || datacollectors.length < 1)
      ) {
        return res
          .status(httpStatusCodes.NOT_FOUND)
          .json(
            new ResponseJSON(
              "Supervisor is not assigned any data collectors",
              true,
              httpStatusCodes.NOT_FOUND
            )
          );
      }

      if (!questionnaire) {
        return res
          .status(httpStatusCodes.NOT_FOUND)
          .json(
            new ResponseJSON(
              "Not Questionnaires active right now",
              true,
              httpStatusCodes.NOT_FOUND
            )
          );
      }
      // if (
      //   req.user?.role === rolesNum["BRANCH STATISTICIAN"] ||
      //   questionnaire.questionnaireRegionStatus === QuotationStatus.SUPERVISOR_APPROVED
      // ) {
      //   return res
      //     .status(httpStatusCodes.UNAUTHORIZED)
      //     .json(
      //       new ResponseJSON(
      //         "This user is not allowed to update this quotation",
      //         true,
      //         httpStatusCodes.UNAUTHORIZED
      //       )
      //     );
      // }
      const result = await prisma.quotation.findMany({
        where: {
          questionnaireId: questionnaire?.id,
          collectorId: {
            in: datacollectors.map((el) => el.id),
          },
          ...query,
        },
        include: {
          collector: {
            select: {
              fullName: true,
              id: true,
              marketplaceCode: true,
            },
          },
          quotes: {
            include: {
              quoteComments: true,
            },
          },
          unfoundQuotes: {
            include: {
              quoteComments: true,
            },
          },
        },
      });
      return res
        .status(httpStatusCodes.OK)
        .json(new ResponseJSON("Success", false, httpStatusCodes.OK, result));
    } catch (error: any) {
      console.log("Error --- ", error);
      next(
        apiErrorHandler(
          error,
          req,
          errorMessages.INTERNAL_SERVER,
          httpStatusCodes.INTERNAL_SERVER
        )
      );
    }
  }  And the  schemas ascociated with the above queries are enum QuotationStatus {
  PENDING
  SUPERVISOR_APPROVED
  STATISTICIAN_APPROVED
  BRANCH_APPROVED
  REJECTED
}  model Quotation {
  id                 Int                     @id @default(autoincrement())
  status             QuotationStatus         @default(PENDING)
  creationStatus     QuotationCreationStatus @default(COLLECTED)
  approverId         Int?
  approver           User?                   @relation("approver", fields: [approverId], references: [id])
  marketplaceCode    Int
  marketplace        Marketplace             @relation(fields: [marketplaceCode], references: [code])
  collectorId        Int
  collector          User                    @relation("collector", fields: [collectorId], references: [id])
  questionnaireId    Int
  itemCode           Int
  questionnaireItem  QuestionnaireItem       @relation(fields: [questionnaireId, itemCode], references: [questionnaireId, itemCode])
  branchApproverId   Int?
  branchApprover     User?                   @relation("branchApprover", fields: [branchApproverId], references: [id])
  quotes             Quote[]
  unfoundQuotes      UnfoundQuote[]
  cleanedQuotes      CleanedQuote[]
  interpolatedQuotes InterpolatedQuote[]
  // quoteMean          QuotesMean?
  updatedAt          DateTime                @updatedAt
  createdAt          DateTime                @default(now())

  @@unique([questionnaireId, itemCode, marketplaceCode])
} model QuestionnaireItem {
  minPrice        Float
  maxPrice        Float
  itemCode        Int
  item            Item          @relation(fields: [itemCode], references: [code])
  questionnaireId Int
  questionnaire   Questionnaire @relation(fields: [questionnaireId], references: [id], onDelete: Cascade)
  disabled        Boolean       @default(false)
  quotations      Quotation[]
  updatedAt       DateTime      @updatedAt
  createdAt       DateTime      @default(now())

  @@id([questionnaireId, itemCode])
} based on all these informations update the getQuotaions function to fetch only quotaitons that have been SUPERVISOR_APPROVED  by supervisor for branch statistician role