Merge branch 'develop' of github.com:topcoder-platform/challenge-api-v6 into PM-4684_challenge-approval-flow

Author: vas3a

src/phase-management/PhaseAdvancer.js

@@ -395,7 +395,7 @@ class PhaseAdvancer {
             OR (r."legacySubmissionId" IS NOT NULL AND s."legacySubmissionId" = r."legacySubmissionId")
           )
         WHERE s."challengeId" = ${challengeId}
-          AND r."status" = ${"COMPLETED"}
+          AND r."status"::text = ${"COMPLETED"}
       `
     );
 

src/services/ChallengePhaseService.js

@@ -479,11 +479,14 @@ async function hasPendingEscalationRequestsForChallenge(challengeId) {
 /**
  * Load a challenge for challenge-scoped phase operations.
  * @param {String} challengeId the challenge id
- * @returns {Object} the challenge with the given id
+ * @returns {Object} the challenge with the given id and type metadata
  * @throws {NotFoundError} when the challenge does not exist
  */
 async function getChallengeForPhaseAccess(challengeId) {
-  const challenge = await prisma.challenge.findUnique({ where: { id: challengeId } });
+  const challenge = await prisma.challenge.findUnique({
+    where: { id: challengeId },
+    include: { type: true },
+  });
   if (!challenge) {
     throw new errors.NotFoundError(`Challenge with id: ${challengeId} doesn't exist`);
   }
@@ -511,13 +514,34 @@ async function postChallengeUpdatedNotification(challengeId) {
   }
 }
 
-async function ensureRequiredResourcesBeforeOpeningPhase(challengeId, phaseName) {
+/**
+ * Check whether a challenge is the Marathon Match challenge type.
+ * @param {Object} challenge challenge data loaded with its type relation
+ * @returns {Boolean} true when the challenge type name is Marathon Match
+ */
+function isMarathonMatchChallengeType(challenge) {
+  const typeName = _.get(challenge, "type.name");
+  return _.toLower(_.trim(typeName || "")) === "marathon match";
+}
+
+/**
+ * Ensure a challenge has the configured resource role before a phase opens.
+ * @param {Object} challenge challenge data loaded with its type relation
+ * @param {String} phaseName phase name being opened
+ * @throws {BadRequestError} when the challenge is missing the required resource role
+ */
+async function ensureRequiredResourcesBeforeOpeningPhase(challenge, phaseName) {
   const normalizedPhaseName = _.toLower(_.trim(phaseName || ""));
   const requiredRoleName = PHASE_RESOURCE_ROLE_REQUIREMENTS[normalizedPhaseName];
   if (!requiredRoleName) {
     return;
   }
 
+  if (normalizedPhaseName === "review" && isMarathonMatchChallengeType(challenge)) {
+    return;
+  }
+
+  const challengeId = challenge.id;
   const challengeResources = await helper.getChallengeResources(challengeId);
   const requiredRoleNameLower = _.toLower(requiredRoleName);
   const hasRequiredRoleByName = (challengeResources || []).some((resource) => {
@@ -693,7 +717,7 @@ async function partiallyUpdateChallengePhase(currentUser, challengeId, id, data)
 
   if (isOpeningPhase) {
     const phaseName = data.name || challengePhase.name;
-    await ensureRequiredResourcesBeforeOpeningPhase(challengeId, phaseName);
+    await ensureRequiredResourcesBeforeOpeningPhase(challenge, phaseName);
 
     // Check if this is the Appeals phase
     const normalizedPhaseName = normalizePhaseName(phaseName);

src/services/ChallengeService.js

@@ -51,6 +51,7 @@ const CHALLENGE_BILLING_LOCK_STATUSES = new Set([
   ChallengeStatusEnum.APPROVED,
   ChallengeStatusEnum.ACTIVE,
 ]);
+
 const CHALLENGE_APPROVAL_STATUS = {
   PENDING_APPROVAL: "PENDING_APPROVAL",
   APPROVED: "APPROVED",
@@ -61,6 +62,8 @@ const CHALLENGE_APPROVAL_ACTION_STATUSES = new Set([
   CHALLENGE_APPROVAL_STATUS.REJECTED,
 ]);
 
+const DEFAULT_ESTIMATED_SUBMISSIONS_COUNT = 2;
+
 // Provide aliases for friendlier sortBy query params
 const sortByAliases = {
   updated: constants.validChallengeParams.Updated,
@@ -199,17 +202,93 @@ function getChallengePrizeSetMemberPaymentAmount(challenge) {
   }, 0);
 }
 
+/**
+ * Reads the first-place placement prize used by reviewer cost estimates.
+ *
+ * @param {object} challenge Challenge model or response object.
+ * @returns {number|undefined} First-place USD placement prize amount, or undefined when unavailable.
+ */
+function getFirstPlacePrizeValue(challenge) {
+  const prizeSets = _.get(challenge, "prizeSets");
+
+  if (!Array.isArray(prizeSets)) {
+    return undefined;
+  }
+
+  const placementPrizeSet = _.find(
+    prizeSets,
+    (prizeSet) => _.toString(_.get(prizeSet, "type")).toUpperCase() === PrizeSetTypeEnum.PLACEMENT,
+  );
+  const firstPrize = _.get(placementPrizeSet, "prizes[0]");
+
+  if (_.toString(_.get(firstPrize, "type")).toUpperCase() !== constants.prizeTypes.USD) {
+    return undefined;
+  }
+
+  const prizeValue = _.toNumber(_.get(firstPrize, "value"));
+
+  return Number.isFinite(prizeValue) ? prizeValue : undefined;
+}
+
+/**
+ * Calculates the estimated member-review payment amount for billing locks.
+ *
+ * The work app shows review cost using a two-submission estimate, so draft
+ * budget locks need the same fixed and coefficient-based reviewer math.
+ *
+ * @param {object} challenge Challenge model or response object.
+ * @returns {number} Estimated member-review payment amount before markup.
+ */
+function getEstimatedReviewerPaymentAmount(challenge) {
+  const reviewers = _.get(challenge, "reviewers");
+
+  if (!Array.isArray(reviewers)) {
+    return 0;
+  }
+
+  const firstPlacePrizeValue = getFirstPlacePrizeValue(challenge);
+
+  if (_.isNil(firstPlacePrizeValue)) {
+    return 0;
+  }
+
+  return reviewers.reduce((total, reviewer) => {
+    if (_.get(reviewer, "isMemberReview") === false) {
+      return total;
+    }
+
+    const fixedAmount = _.toNumber(_.get(reviewer, "fixedAmount"));
+    const baseCoefficient = _.toNumber(_.get(reviewer, "baseCoefficient"));
+    const incrementalCoefficient = _.toNumber(_.get(reviewer, "incrementalCoefficient"));
+    const memberReviewerCount = Math.max(
+      1,
+      Math.trunc(_.toNumber(_.get(reviewer, "memberReviewerCount")) || 1),
+    );
+    const reviewerPayment =
+      (Number.isFinite(fixedAmount) ? fixedAmount : 0) +
+      ((Number.isFinite(baseCoefficient) ? baseCoefficient : 0) +
+        (Number.isFinite(incrementalCoefficient) ? incrementalCoefficient : 0) *
+          DEFAULT_ESTIMATED_SUBMISSIONS_COUNT) *
+        firstPlacePrizeValue;
+
+    return total + reviewerPayment * memberReviewerCount;
+  }, 0);
+}
+
 /**
  * Reads the currently persisted challenge member-payment total.
  *
  * @param {object} challenge Challenge model or response object.
- * @returns {number|undefined} Total USD member-payment amount before markup.
+ * @returns {number|undefined} Total USD member-payment amount before markup,
+ * including estimated member-review cost when prize sets are loaded.
  */
 function getChallengeMemberPaymentAmount(challenge) {
   const prizeSetMemberPaymentAmount = getChallengePrizeSetMemberPaymentAmount(challenge);
 
   if (!_.isNil(prizeSetMemberPaymentAmount)) {
-    return prizeSetMemberPaymentAmount;
+    return Number(
+      (prizeSetMemberPaymentAmount + getEstimatedReviewerPaymentAmount(challenge)).toFixed(2),
+    );
   }
 
   const totalPrizes = _.get(

test/unit/ChallengePhaseService.test.js

@@ -1713,6 +1713,54 @@ describe('challenge phase service unit tests', () => {
       throw new Error('should not reach here')
     })
 
+    it('partially update challenge phase - opens marathon match review phase without reviewer resource', async () => {
+      const reviewPhase = await prisma.phase.create({
+        data: {
+          id: uuid(),
+          name: 'Review',
+          description: 'desc',
+          isOpen: false,
+          duration: 86400,
+          createdBy: 'admin',
+          updatedBy: 'admin'
+        }
+      })
+      const reviewChallengePhaseId = uuid()
+      await prisma.challengePhase.create({
+        data: {
+          id: reviewChallengePhaseId,
+          challengeId: data.marathonMatchChallenge.id,
+          phaseId: reviewPhase.id,
+          name: 'Review',
+          isOpen: false,
+          createdBy: 'admin',
+          updatedBy: 'admin'
+        }
+      })
+
+      const originalGetChallengeResources = helper.getChallengeResources
+      const originalGetResourceRoles = helper.getResourceRoles
+      helper.getChallengeResources = async () => [{ roleId: 'some-other-role-id' }]
+      helper.getResourceRoles = async () => {
+        throw new Error('resource role lookup should not be required for Marathon Match Review')
+      }
+
+      try {
+        const challengePhase = await service.partiallyUpdateChallengePhase(
+          authUser,
+          data.marathonMatchChallenge.id,
+          reviewChallengePhaseId,
+          { isOpen: true }
+        )
+        should.equal(challengePhase.isOpen, true)
+      } finally {
+        helper.getChallengeResources = originalGetChallengeResources
+        helper.getResourceRoles = originalGetResourceRoles
+        await prisma.challengePhase.delete({ where: { id: reviewChallengePhaseId } })
+        await prisma.phase.delete({ where: { id: reviewPhase.id } })
+      }
+    })
+
     it('partially update challenge phase - opens review phase when reviewer resource exists', async () => {
       const reviewPhase = await prisma.phase.create({
         data: {

test/unit/ChallengeService.test.js

@@ -261,9 +261,46 @@ describe("challenge service unit tests", () => {
     it("locks draft challenge budget when the challenge is saved", async () => {
       const challengeData = _.cloneDeep(testChallengeData);
       challengeData.status = ChallengeStatusEnum.DRAFT;
-      challengeData.prizeSets[0].type = PrizeSetTypeEnum.PLACEMENT;
-      challengeData.prizeSets[0].prizes[0].type = constants.prizeTypes.USD;
-      challengeData.prizeSets[0].prizes[0].value = 1000;
+      challengeData.prizeSets = [
+        {
+          type: PrizeSetTypeEnum.PLACEMENT,
+          description: "placement prizes",
+          prizes: [
+            {
+              description: "placement 1",
+              type: constants.prizeTypes.USD,
+              value: 35,
+            },
+            {
+              description: "placement 2",
+              type: constants.prizeTypes.USD,
+              value: 12,
+            },
+          ],
+        },
+        {
+          type: PrizeSetTypeEnum.COPILOT,
+          description: "copilot payment",
+          prizes: [
+            {
+              description: "copilot",
+              type: constants.prizeTypes.USD,
+              value: 10,
+            },
+          ],
+        },
+      ];
+      challengeData.reviewers = [
+        {
+          scorecardId: "scorecard-id",
+          isMemberReview: true,
+          memberReviewerCount: 1,
+          phaseId: data.phase.id,
+          fixedAmount: 16.1,
+          baseCoefficient: 0,
+          incrementalCoefficient: 0,
+        },
+      ];
       const originalGetProjectBillingInformation = projectHelper.getProjectBillingInformation;
 
       projectHelper.getProjectBillingInformation = async () => ({
@@ -284,7 +321,7 @@ describe("challenge service unit tests", () => {
           billingAccountId: "80001012",
           challengeId: result.id,
           markup: 0.1,
-          memberPaymentAmount: 1000,
+          memberPaymentAmount: 73.1,
         });
       } finally {
         projectHelper.getProjectBillingInformation = originalGetProjectBillingInformation;

test/unit/phase-management/PhaseAdvancer.test.js

@@ -2,6 +2,7 @@ const { expect } = require("chai");
 
 const PhaseAdvancer = require("../../../src/phase-management/PhaseAdvancer");
 const { getClient } = require("../../../src/common/prisma");
+const reviewPrisma = require("../../../src/common/review-prisma");
 
 const buildIterativeReviewPhase = () => ({
   id: "phase-iterative-review",
@@ -91,3 +92,80 @@ describe("PhaseAdvancer Iterative Review gating", () => {
     expect(phases[0].isOpen).to.be.true;
   });
 });
+
+describe("PhaseAdvancer review completion queries", () => {
+  const prisma = getClient();
+  const originalFindUnique = prisma.challenge.findUnique;
+  const originalGetReviewClient = reviewPrisma.getReviewClient;
+  const phaseAdvancerPath = require.resolve("../../../src/phase-management/PhaseAdvancer");
+
+  afterEach(() => {
+    prisma.challenge.findUnique = originalFindUnique;
+    reviewPrisma.getReviewClient = originalGetReviewClient;
+    delete require.cache[phaseAdvancerPath];
+  });
+
+  it("casts review status to text before comparing completed reviews", async () => {
+    const capturedQueries = [];
+
+    reviewPrisma.getReviewClient = () => ({
+      $queryRaw: async (query) => {
+        capturedQueries.push(query);
+        return [{ count: 2 }];
+      },
+    });
+
+    delete require.cache[phaseAdvancerPath];
+    const PhaseAdvancerWithMockedReviewClient = require("../../../src/phase-management/PhaseAdvancer");
+    const phaseAdvancer = new PhaseAdvancerWithMockedReviewClient({
+      async getPhaseFacts() {
+        return {};
+      },
+    });
+
+    prisma.challenge.findUnique = async () => ({
+      numOfSubmissions: 1,
+      reviewers: [{ isMemberReview: true, memberReviewerCount: 2 }],
+    });
+
+    const phases = [
+      {
+        id: "phase-review",
+        phaseId: "phase-review",
+        name: "Review",
+        description: "Review phase",
+        duration: 86400,
+        isOpen: true,
+        predecessor: null,
+        scheduledStartDate: new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString(),
+        scheduledEndDate: new Date(Date.now() - 60 * 60 * 1000).toISOString(),
+        actualStartDate: new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString(),
+        actualEndDate: null,
+        constraints: [],
+      },
+    ];
+
+    const result = await phaseAdvancer.advancePhase(
+      "challenge-123",
+      null,
+      phases,
+      "close",
+      "Review"
+    );
+    const [reviewCompletionQuery] = capturedQueries;
+    const queryText = [
+      reviewCompletionQuery.sql,
+      reviewCompletionQuery.text,
+      reviewCompletionQuery.statement,
+      Array.isArray(reviewCompletionQuery.strings)
+        ? reviewCompletionQuery.strings.join("?")
+        : "",
+    ]
+      .filter(Boolean)
+      .join("\n");
+
+    expect(result.success).to.be.true;
+    expect(queryText).to.contain('r."status"::text =');
+    expect(reviewCompletionQuery.values).to.include("COMPLETED");
+  });
+});