Better handling of phase manipulation

Author: jmgasper

app.js

@@ -37,19 +37,6 @@ process.on("unhandledRejection", (reason, promise) => {
   } catch (_) {}
 });
 
-// Allow on-demand diagnostic reports (e.g., docker/ecs kill -s SIGUSR2 <container>)
-process.on("SIGUSR2", () => {
-  try {
-    if (process.report && typeof process.report.writeReport === "function") {
-      const reportPath = process.report.writeReport();
-      if (reportPath) logger.warn(`SIGUSR2 received. Diagnostic report: ${reportPath}`);
-    } else {
-      logger.warn("SIGUSR2 received, but process.report is not available.");
-    }
-  } catch (err) {
-    logger.error("Error generating diagnostic report on SIGUSR2:", err);
-  }
-});
 const interceptor = require("express-interceptor");
 const fileUpload = require("express-fileupload");
 const YAML = require("yamljs");

config/default.js

@@ -53,6 +53,7 @@ module.exports = {
   TERMS_API_URL: process.env.TERMS_API_URL || "http://localhost:4000/v5/terms",
   CUSTOMER_PAYMENTS_URL:
     process.env.CUSTOMER_PAYMENTS_URL || "https://api.topcoder-dev.com/v5/customer-payments",
+  FINANCE_API_URL: process.env.FINANCE_API_URL || "http://localhost:8080",
   CHALLENGE_MIGRATION_APP_URL:
     process.env.CHALLENGE_MIGRATION_APP_URL || "https://api.topcoder.com/v5/challenge-migration",
   // copilot resource role ids allowed to upload attachment

src/common/helper.js

@@ -461,6 +461,41 @@ async function cancelPayment(paymentId) {
   }
 }
 
+/**
+ * Generate payments for challenge resources via finance API
+ * @param {String|Number} challengeId the challenge id
+ * @returns {Boolean} true if the request succeeds, false otherwise
+ */
+async function generateChallengePayments(challengeId) {
+  if (!config.FINANCE_API_URL) {
+    logger.warn("helper.generateChallengePayments: FINANCE_API_URL not configured");
+    return false;
+  }
+
+  const token = await m2mHelper.getM2MToken();
+  const url = `${config.FINANCE_API_URL}/challenges/${challengeId}`;
+  logger.debug(`helper.generateChallengePayments: POST ${url}`);
+
+  try {
+    const res = await axios.post(
+      url,
+      {},
+      {
+        headers: { Authorization: `Bearer ${token}` },
+      }
+    );
+    logger.debug(`helper.generateChallengePayments: response status ${res.status}`);
+    return res.status >= 200 && res.status < 300;
+  } catch (err) {
+    logger.debug(
+      `helper.generateChallengePayments: error for challenge ${challengeId} - status ${
+        _.get(err, "response.status", "n/a")
+      }: ${err.message}`
+    );
+    return false;
+  }
+}
+
 /**
  * Cancel project
  * @param {String} projectId the project id
@@ -1496,6 +1531,7 @@ module.exports = {
   getProjectPayment,
   capturePayment,
   cancelPayment,
+  generateChallengePayments,
   sendSelfServiceNotification,
   getMemberByHandle,
   getMembersByHandles,

src/services/ChallengePhaseService.js

@@ -4,13 +4,62 @@
 const _ = require("lodash");
 const Joi = require("joi");
 const moment = require("moment");
+const { Prisma } = require("@prisma/client");
+const config = require("config");
 const helper = require("../common/helper");
 const logger = require("../common/logger");
 const errors = require("../common/errors");
 const constants = require("../../app-constants");
+const { getReviewClient } = require("../common/review-prisma");
 
 const { getClient } = require("../common/prisma");
 const prisma = getClient();
+const PENDING_REVIEW_STATUSES = Object.freeze(["PENDING", "IN_PROGRESS", "DRAFT", "SUBMITTED"]);
+
+async function hasPendingScorecardsForPhase(challengePhaseId) {
+  if (!config.REVIEW_DB_URL) {
+    logger.debug(
+      `Skipping pending scorecard check for phase ${challengePhaseId} because REVIEW_DB_URL is not configured`
+    );
+    return false;
+  }
+
+  const reviewPrisma = getReviewClient();
+  const reviewSchema = config.REVIEW_DB_SCHEMA;
+  const reviewTable = Prisma.raw(`"${reviewSchema}"."review"`);
+  const statusText = Prisma.raw(`"status"::text`);
+
+  const pendingStatusClause =
+    PENDING_REVIEW_STATUSES.length > 0
+      ? Prisma.sql`${statusText} IN (${Prisma.join(
+          PENDING_REVIEW_STATUSES.map((status) => Prisma.sql`${status}`)
+        )})`
+      : Prisma.sql`FALSE`;
+
+  let rows;
+  try {
+    rows = await reviewPrisma.$queryRaw(
+      Prisma.sql`
+        SELECT COUNT(*)::int AS count
+        FROM ${reviewTable}
+        WHERE "phaseId" = ${challengePhaseId}
+          AND (
+            "status" IS NULL
+            OR ${pendingStatusClause}
+          )
+      `
+    );
+  } catch (err) {
+    logger.error(
+      `Failed to check pending scorecards for phase ${challengePhaseId}: ${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 } });
@@ -147,8 +196,41 @@ async function partiallyUpdateChallengePhase(currentUser, challengeId, id, data)
     }
   }
 
+  const isClosingPhase =
+    "isOpen" in data && data["isOpen"] === false && Boolean(challengePhase.isOpen);
+  const isReopeningPhase =
+    "isOpen" in data && data["isOpen"] === true && !challengePhase.isOpen;
+  if (isClosingPhase) {
+    const pendingScorecards = await hasPendingScorecardsForPhase(challengePhase.id);
+    if (pendingScorecards) {
+      const phaseName = challengePhase.name || "phase";
+      throw new errors.ForbiddenError(
+        `Cannot close ${phaseName} because there are still pending scorecards`
+      );
+    }
+  }
+  if (isReopeningPhase) {
+    data.actualEndDate = null;
+  }
+
   // Update ChallengePhase
   data.updatedBy = String(currentUser.userId);
+  if (!_.isNil(data.duration)) {
+    const startInput = !_.isNil(data.scheduledStartDate)
+      ? data.scheduledStartDate
+      : !_.isNil(challengePhase.scheduledStartDate)
+      ? challengePhase.scheduledStartDate
+      : null;
+    if (startInput) {
+      const startDate = new Date(startInput);
+      if (!Number.isNaN(startDate.getTime())) {
+        const recalculatedScheduledEndDate = new Date(
+          startDate.getTime() + Number(data.duration) * 1000
+        );
+        data.scheduledEndDate = recalculatedScheduledEndDate;
+      }
+    }
+  }
   const dataToUpdate = _.omit(data, "constraints");
   const result = await prisma.$transaction(async (tx) => {
     const result = await tx.challengePhase.update({

src/services/ChallengeService.js

@@ -1918,6 +1918,63 @@ function validateTask(currentUser, challenge, data, challengeResources) {
   }
 }
 
+function prepareTaskCompletionData(challenge, challengeResources, data) {
+  const isTask = _.get(challenge, "legacy.pureV5Task");
+  const isCompleteTask =
+    data.status === ChallengeStatusEnum.COMPLETED &&
+    challenge.status !== ChallengeStatusEnum.COMPLETED;
+
+  if (!isTask || !isCompleteTask) {
+    return null;
+  }
+
+  const submitters = _.filter(
+    challengeResources,
+    (resource) => resource.roleId === config.SUBMITTER_ROLE_ID
+  );
+
+  if (!submitters || submitters.length === 0) {
+    throw new errors.BadRequestError("Task has no submitter resource");
+  }
+
+  if (!data.winners || data.winners.length === 0) {
+    const submitter = submitters[0];
+    data.winners = [
+      {
+        userId: parseInt(submitter.memberId, 10),
+        handle: submitter.memberHandle,
+        placement: 1,
+        type: PrizeSetTypeEnum.PLACEMENT,
+      },
+    ];
+  }
+
+  const completionTime = new Date().toISOString();
+  const startTime = challenge.startDate || completionTime;
+
+  const updatedPhases = _.map(challenge.phases || [], (phase) => ({
+    id: phase.id,
+    phaseId: phase.phaseId,
+    name: phase.name,
+    description: phase.description,
+    duration: phase.duration,
+    scheduledStartDate: phase.scheduledStartDate,
+    scheduledEndDate: phase.scheduledEndDate,
+    predecessor: phase.predecessor,
+    constraints: _.cloneDeep(phase.constraints),
+    actualStartDate: startTime,
+    actualEndDate: completionTime,
+    isOpen: false,
+  }));
+
+  data.phases = updatedPhases;
+
+  return {
+    shouldTriggerPayments: true,
+    completionTime,
+  };
+}
+
 /**
  * Update challenge.
  * @param {Object} currentUser the user who perform operation
@@ -2000,6 +2057,7 @@ async function updateChallenge(currentUser, challengeId, data, options = {}) {
   );
   logger.debug(`updateChallenge(${challengeId}): payload validation complete`);
   validateTask(currentUser, challenge, data, challengeResources);
+  const taskCompletionInfo = prepareTaskCompletionData(challenge, challengeResources, data);
 
   let sendActivationEmail = false;
   let sendSubmittedEmail = false;
@@ -2512,6 +2570,19 @@ async function updateChallenge(currentUser, challengeId, data, options = {}) {
       include: includeReturnFields,
     });
   });
+  if (taskCompletionInfo && taskCompletionInfo.shouldTriggerPayments) {
+    logger.info(`Triggering payment generation for Task challenge ${challengeId}`);
+    try {
+      const paymentSuccess = await helper.generateChallengePayments(challengeId);
+      if (!paymentSuccess) {
+        logger.warn(`Failed to generate payments for Task challenge ${challengeId}`);
+      }
+    } catch (err) {
+      logger.error(
+        `Error generating payments for Task challenge ${challengeId}: ${err.message}`
+      );
+    }
+  }
   // Re-fetch the challenge outside the transaction to ensure we publish
   // only after the commit succeeds and using the committed snapshot.
   if (emitEvent) {