Based on the follwoing schemas 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 UnfoundQuote {
  id            Int                @id @default(autoincrement())
  reason        String
  quotationId   Int
  quotation     Quotation          @relation(fields: [quotationId], references: [id])
  quoteComments QuotationComment[]
  updatedAt     DateTime           @updatedAt
  createdAt     DateTime           @default(now())
} update the following function  //---------- Edit Quote reason ----------
  async editQuoteReason(req: Request, res: Response, next: NextFunction) {
    try {
      const updatedQuote: UnfoundQuote = req.body;
      const quotationId = parseInt(req.params.quotaionId);
      const quotation = await prisma.quotation.findUnique({
        where: {
          id: quotationId,
          status: QuotationStatus.PENDING,
        },
        include: {
          quotes: true,
          questionnaireItem: true,
          unfoundQuotes: true,
        },
      });
      const questionnaire = await prisma.questionnaire.findUnique({
        where: { id: quotation.questionnaireId },
      });
      if (
        !quotation ||
        quotation.collectorId !== req.user?.id ||
        !questionnaire
      ) {
        console.log('User is: ', req.user, ' Quotation is: ', quotation);
        return res
          .status(httpStatusCodes.NOT_FOUND)
          .json(
            new ResponseJSON('Quote not found', true, httpStatusCodes.NOT_FOUND)
          );
      }
      if (
        questionnaire.endDate.getTime() <= addDays(new Date(), -10).getTime() ||
        ([
          QuotationStatus.BRANCH_APPROVED,
          QuotationStatus.STATISTICIAN_APPROVED,
          QuotationStatus.SUPERVISOR_APPROVED,
        ].includes(quote.quotation.status as any) &&
          req.user.role === rolesNum['DATA COLLECTOR'])
      ) {
        return res
          .status(httpStatusCodes.UNAUTHORIZED)
          .json(
            new ResponseJSON(
              'Quote is Already Approved',
              true,
              httpStatusCodes.UNAUTHORIZED
            )
          );
      }
      if (quotation.collectorId != req.user.id) {
        return res
          .status(httpStatusCodes.UNAUTHORIZED)
          .json(
            new ResponseJSON(
              errorMessages.UNAUTHORIZED,
              true,
              httpStatusCodes.UNAUTHORIZED
            )
          );
      }
      updatedQuote.updatedAt = new Date();
      const result = await prisma.$transaction([
        prisma.quote.update({
          where: {
            id: quotationId,
          },
          data: updatedQuote,
        }),
        prisma.quotation.update({
          where: { id: quotationId },
          data: {
            status: QuotationStatus.PENDING,
          },
        }),
        prisma.quotationComment.deleteMany({
          where: {
            commenterId: req.user.id,
            quotationId: quotationId,
          },
        }),
      ]);
      return res
        .status(httpStatusCodes.OK)
        .json(
          new ResponseJSON(
            'Quote reason edited',
            false,
            httpStatusCodes.OK,
            result[0]
          )
        );
    } catch (error) {
      console.error('Error--- ', error);
      next(
        apiErrorHandler(
          error,
          req,
          errorMessages.INTERNAL_SERVER,
          httpStatusCodes.INTERNAL_SERVER
        )
      );
    }
  } to find status that has PENDING and update the reason