Updates for manual phase manipulation

Author: jmgasper

src/services/ChallengePhaseService.js

@@ -62,6 +62,61 @@ async function hasPendingScorecardsForPhase(challengePhaseId) {
   return Number(count) > 0;
 }
 
+async function hasCompletedReviewsForPhase(challengePhaseIdOrIds) {
+  if (!config.REVIEW_DB_URL) {
+    logger.debug(
+      `Skipping completed review check for phase ${challengePhaseIdOrIds} because REVIEW_DB_URL is not configured`
+    );
+    return false;
+  }
+
+  const phaseIds = Array.isArray(challengePhaseIdOrIds)
+    ? challengePhaseIdOrIds.filter((id) => !_.isNil(id))
+    : [challengePhaseIdOrIds];
+
+  if (phaseIds.length === 0) {
+    return false;
+  }
+
+  const reviewPrisma = getReviewClient();
+  const reviewSchema = config.REVIEW_DB_SCHEMA;
+  const reviewTable = Prisma.raw(`"${reviewSchema}"."review"`);
+  const statusText = Prisma.raw(`"status"::text`);
+  const completedStatuses = ["IN_PROGRESS", "COMPLETED"];
+
+  const phaseIdClause =
+    phaseIds.length === 1
+      ? Prisma.sql`"phaseId" = ${phaseIds[0]}`
+      : Prisma.sql`"phaseId" IN (${Prisma.join(
+          phaseIds.map((phaseId) => Prisma.sql`${phaseId}`)
+        )})`;
+
+  const completedStatusClause = Prisma.sql`${statusText} IN (${Prisma.join(
+    completedStatuses.map((status) => Prisma.sql`${status}`)
+  )})`;
+
+  let rows;
+  try {
+    rows = await reviewPrisma.$queryRaw(
+      Prisma.sql`
+        SELECT COUNT(*)::int AS count
+        FROM ${reviewTable}
+        WHERE ${phaseIdClause}
+          AND ${completedStatusClause}
+      `
+    );
+  } catch (err) {
+    logger.error(
+      `Failed to check completed reviews for phase(s) ${phaseIds.join(", ")}: ${err.message}`,
+      err
+    );
+    throw err;
+  }
+
+  const [{ count = 0 } = {}] = rows || [];
+  return Number(count) > 0;
+}
+
 async function checkChallengeExists(challengeId) {
   const challenge = await prisma.challenge.findUnique({ where: { id: challengeId } });
   if (!challenge) {
@@ -230,8 +285,47 @@ async function partiallyUpdateChallengePhase(currentUser, challengeId, id, data)
         `Cannot close ${phaseName} because there are still pending scorecards`
       );
     }
+    if (!("actualEndDate" in data) || _.isNil(data.actualEndDate)) {
+      data.actualEndDate = new Date();
+    }
   }
   if (isReopeningPhase) {
+    const phaseName = challengePhase.name;
+    if (phaseName === "Submission" || phaseName === "Registration") {
+      const hasCompletedReviews = await hasCompletedReviewsForPhase(challengePhase.id);
+      if (hasCompletedReviews) {
+        throw new errors.ForbiddenError(
+          "Cannot reopen Submission/Registration phase because reviews are already in progress or completed"
+        );
+      }
+    }
+
+    if (phaseName === "Checkpoint Submission") {
+      const checkpointPhases = await prisma.challengePhase.findMany({
+        where: {
+          challengeId: challengePhase.challengeId,
+          name: { in: ["Checkpoint Screening", "Checkpoint Review"] },
+        },
+        select: { id: true },
+      });
+      const checkpointPhaseIds = checkpointPhases.map((cp) => cp.id);
+      if (checkpointPhaseIds.length > 0) {
+        const hasCheckpointReviews = await hasCompletedReviewsForPhase(checkpointPhaseIds);
+        if (hasCheckpointReviews) {
+          throw new errors.ForbiddenError(
+            "Cannot reopen Checkpoint Submission phase because Checkpoint Screening or Checkpoint Review reviews are already in progress or completed"
+          );
+        }
+      }
+    }
+
+    const hasActualStartDate = !_.isNil(challengePhase.actualStartDate);
+    const hasActualEndDate = !_.isNil(challengePhase.actualEndDate);
+    if (hasActualStartDate) {
+      data.actualStartDate = challengePhase.actualStartDate;
+    } else if (!("actualStartDate" in data) || _.isNil(data.actualStartDate)) {
+      data.actualStartDate = new Date();
+    }
     data.actualEndDate = null;
   }
 

test/unit/ChallengePhaseService.test.js

@@ -153,18 +153,44 @@ describe('challenge phase service unit tests', () => {
       should.equal(new Date(challengePhase.scheduledEndDate).toISOString(), expectedScheduledEndDate)
     })
 
-    it('partially update challenge phase - reopening clears actual end date', async () => {
+    it('partially update challenge phase - closing sets actual end date', async () => {
+      await prisma.challengePhase.update({
+        where: { id: data.challengePhase1Id },
+        data: { isOpen: true, actualStartDate: new Date(), actualEndDate: null }
+      })
+
+      const before = new Date()
+      const challengePhase = await service.partiallyUpdateChallengePhase(authUser, data.challenge.id, data.challengePhase1Id, {
+        isOpen: false
+      })
+      const after = new Date()
+
+      should.equal(challengePhase.isOpen, false)
+      should.exist(challengePhase.actualEndDate)
+      const actualEndMs = new Date(challengePhase.actualEndDate).getTime()
+      actualEndMs.should.be.at.least(before.getTime())
+      actualEndMs.should.be.at.most(after.getTime())
+    })
+
+    it('partially update challenge phase - reopening clears actual end date and sets start date', async () => {
       const previousEndDate = new Date()
       await prisma.challengePhase.update({
         where: { id: data.challengePhase1Id },
         data: { isOpen: false, actualEndDate: previousEndDate }
       })
 
+      const before = new Date()
       const challengePhase = await service.partiallyUpdateChallengePhase(authUser, data.challenge.id, data.challengePhase1Id, {
         isOpen: true
       })
+      const after = new Date()
+
       should.equal(challengePhase.isOpen, true)
       should.equal(challengePhase.actualEndDate, null)
+      should.exist(challengePhase.actualStartDate)
+      const actualStartMs = new Date(challengePhase.actualStartDate).getTime()
+      actualStartMs.should.be.at.least(before.getTime())
+      actualStartMs.should.be.at.most(after.getTime())
     })
 
     it('partially update challenge phase - not found', async () => {