Close marathon match endpoint,

Author: jmgasper

config/default.js

@@ -44,6 +44,7 @@ module.exports = {
   SUBMISSIONS_API_URL:
     process.env.SUBMISSIONS_API_URL || "https://api.topcoder-dev.com/v5/submissions",
   MEMBERS_API_URL: process.env.MEMBERS_API_URL || "https://api.topcoder-dev.com/v6/members",
+  REVIEW_SUMMATIONS_API_URL: process.env.REVIEW_SUMMATIONS_API_URL || "https://api.topcoder-dev.com/v6/reviewSummations",
   RESOURCES_API_URL: process.env.RESOURCES_API_URL || "http://localhost:4000/v5/resources",
   // TODO: change this to localhost
   RESOURCE_ROLES_API_URL:

mock-api/app.js

@@ -8,6 +8,7 @@ const config = require('config')
 const winston = require('winston')
 const _ = require('lodash')
 const prisma = require('../src/common/prisma').getClient()
+const uuid = require('uuid/v4')
 
 const app = express()
 app.set('port', config.PORT)
@@ -82,6 +83,19 @@ app.get('/v5/resources', (req, res) => {
     memberId: '12345678',
     memberHandle: 'thomaskranitsas',
     roleId: '732339e7-8e30-49d7-9198-cccf9451e221'
+  }, {
+    // additional submitter resource
+    id: '22ba038e-48da-487b-96e8-8d3b99b6d184',
+    challengeId,
+    memberId: '9876543',
+    memberHandle: 'tonyj',
+    roleId: '732339e7-8e30-49d7-9198-cccf9451e221'
+  }, {
+    id: '22ba038e-48da-487b-96e8-8d3b99b6d185',
+    challengeId,
+    memberId: '3456789',
+    memberHandle: 'nathanael',
+    roleId: '732339e7-8e30-49d7-9198-cccf9451e221'
   }]
 
   let ret
@@ -277,6 +291,77 @@ app.post('/v5/bus/events', (req, res) => {
   res.status(200).json({})
 })
 
+app.get('/v6/reviewSummations', (req, res) => {
+  const { challengeId } = req.query
+  const page = Number(req.query.page || 1)
+  const perPage = Number(req.query.perPage || 100)
+
+  if (!challengeId) {
+    res.status(400).json({ message: 'challengeId query parameter is required' })
+    return
+  }
+
+  if (page > 1) {
+    res.json({
+      data: [],
+      meta: {
+        page,
+        perPage,
+        totalPages: 1
+      }
+    })
+    return
+  }
+
+  const data = [
+    {
+      id: uuid(),
+      challengeId,
+      submitterId: '12345678',
+      submitterHandle: 'thomaskranitsas',
+      aggregateScore: 95.5,
+      isFinal: true,
+      createdAt: '2024-02-01T10:00:00.000Z'
+    },
+    {
+      id: uuid(),
+      challengeId,
+      submitterId: '9876543',
+      submitterHandle: 'tonyj',
+      aggregateScore: 92.1,
+      isFinal: true,
+      createdAt: '2024-02-01T11:00:00.000Z'
+    },
+    {
+      id: uuid(),
+      challengeId,
+      submitterId: '3456789',
+      submitterHandle: 'nathanael',
+      aggregateScore: 87.3,
+      isFinal: true,
+      createdAt: '2024-02-01T12:00:00.000Z'
+    },
+    {
+      id: uuid(),
+      challengeId,
+      submitterId: '5555555',
+      submitterHandle: 'spectator',
+      aggregateScore: 90.0,
+      isFinal: false,
+      createdAt: '2024-02-01T13:00:00.000Z'
+    }
+  ]
+
+  res.json({
+    data,
+    meta: {
+      page,
+      perPage,
+      totalPages: 1
+    }
+  })
+})
+
 app.post('/v5/auth0', (req, res) => {
   winston.info('Received Auth0 request')
   // return config/test.js#M2M_FULL_ACCESS_TOKEN

src/common/helper.js

@@ -1305,6 +1305,36 @@ async function getChallengeSubmissions(challengeId) {
   return allSubmissions;
 }
 
+/**
+ * Get review summations for a challenge
+ * @param {String} challengeId the challenge ID
+ * @returns {Promise<Array>}
+ */
+async function getReviewSummations(challengeId) {
+  const token = await m2mHelper.getM2MToken();
+  let allReviewSummations = [];
+  let page = 1;
+  while (true) {
+    const result = await axios.get(`${config.REVIEW_SUMMATIONS_API_URL}?challengeId=${challengeId}`, {
+      headers: { Authorization: `Bearer ${token}` },
+      params: {
+        page,
+        perPage: 500,
+      },
+    });
+    const reviewSummations = result.data.data || [];
+    if (reviewSummations.length === 0) {
+      break;
+    }
+    allReviewSummations = allReviewSummations.concat(reviewSummations);
+    page += 1;
+    if (result.data.meta.totalPages && page > result.data.meta.totalPages) {
+      break;
+    }
+  }
+  return allReviewSummations;
+}
+
 /**
  * Get member by ID
  * @param {String} userId the user ID
@@ -1530,6 +1560,7 @@ module.exports = {
   getProjectIdByRoundId,
   getGroupById,
   getChallengeSubmissions,
+  getReviewSummations,
   getMemberById,
   createSelfServiceProject,
   activateProject,

src/controllers/ChallengeController.js

@@ -125,6 +125,19 @@ async function advancePhase(req, res) {
   res.send(await service.advancePhase(req.authUser, req.params.challengeId, req.body));
 }
 
+/**
+ * Close marathon match challenge and determine winners
+ * @param {Object} req the request
+ * @param {Object} res the response
+ */
+async function closeMarathonMatch(req, res) {
+  logger.debug(
+    `closeMarathonMatch User: ${JSON.stringify(req.authUser)} - ChallengeID: ${req.params.challengeId}`
+  );
+  const result = await service.closeMarathonMatch(req.authUser, req.params.challengeId);
+  res.send(result);
+}
+
 /**
  * Get default reviewers for a typeId + trackId
  * @param {Object} req the request
@@ -154,6 +167,7 @@ module.exports = {
   getChallengeStatistics,
   sendNotifications,
   advancePhase,
+  closeMarathonMatch,
   getDefaultReviewers,
   setDefaultReviewers,
 };

src/routes.js

@@ -120,6 +120,15 @@ module.exports = {
       scopes: [UPDATE, ALL],
     },
   },
+  "/challenges/:challengeId/close-marathon-match": {
+    post: {
+      controller: "ChallengeController",
+      method: "closeMarathonMatch",
+      auth: "jwt",
+      access: [constants.UserRoles.Admin],
+      scopes: [UPDATE, ALL],
+    },
+  },
   "/challenges/:challengeId/statistics": {
     get: {
       controller: "ChallengeController",

src/services/ChallengeService.js

@@ -2089,6 +2089,17 @@ async function updateChallenge(currentUser, challengeId, data, options = {}) {
     }
   }
 
+  // Treat incoming `reviews` payloads as an alias for `reviewers`
+  if (!_.isNil(data.reviews)) {
+    if (!Array.isArray(data.reviews)) {
+      throw new BadRequestError("reviews must be an array");
+    }
+    if (_.isNil(data.reviewers)) {
+      data.reviewers = _.cloneDeep(data.reviews);
+    }
+    delete data.reviews;
+  }
+
   // Remove fields from data that are not allowed to be updated and that match the existing challenge
   data = sanitizeData(sanitizeChallenge(data), challenge);
   logger.debug(`Sanitized Data: ${JSON.stringify(data)}`);
@@ -3555,6 +3566,96 @@ async function advancePhase(currentUser, challengeId, data) {
   };
 }
 
+async function closeMarathonMatch(currentUser, challengeId) {
+  logger.info(`Close Marathon Match Request - ${challengeId}`);
+  const machineOrAdmin = currentUser && (currentUser.isMachine || hasAdminRole(currentUser));
+  if (!machineOrAdmin) {
+    throw new errors.ForbiddenError(
+      `Admin role or an M2M token is required to close the marathon match.`
+    );
+  }
+
+  const challenge = await prisma.challenge.findUnique({
+    where: { id: challengeId },
+    include: includeReturnFields,
+  });
+
+  if (_.isNil(challenge) || _.isNil(challenge.id)) {
+    throw new errors.NotFoundError(`Challenge with id: ${challengeId} doesn't exist.`);
+  }
+
+  if (!challenge.type || challenge.type.name !== "Marathon Match") {
+    throw new errors.BadRequestError(
+      `Challenge with id: ${challengeId} is not a Marathon Match challenge.`
+    );
+  }
+
+  const reviewSummations = await helper.getReviewSummations(challengeId);
+  const finalSummations = (reviewSummations || []).filter((summation) => summation.isFinal === true);
+
+  const orderedSummations = _.orderBy(
+    finalSummations,
+    ["aggregateScore", "createdAt"],
+    ["desc", "asc"]
+  );
+
+  const winners = orderedSummations.map((summation, index) => {
+    const parsedUserId = Number(summation.submitterId);
+    if (!Number.isFinite(parsedUserId) || !Number.isInteger(parsedUserId)) {
+      throw new errors.BadRequestError(
+        `Invalid submitterId ${summation.submitterId} for review summation winner`
+      );
+    }
+
+    return {
+      userId: parsedUserId,
+      handle: summation.submitterHandle,
+      placement: index + 1,
+      type: PrizeSetTypeEnum.PLACEMENT,
+    };
+  });
+
+  if (winners.length > 0) {
+    const challengeResources = await helper.getChallengeResources(challengeId);
+    const submitterResources = challengeResources.filter(
+      (resource) => resource.roleId === config.SUBMITTER_ROLE_ID
+    );
+    const missingResources = winners.filter(
+      (winner) =>
+        !submitterResources.some(
+          (resource) => _.toString(resource.memberId) === _.toString(winner.userId)
+        )
+    );
+    if (missingResources.length > 0) {
+      throw new errors.BadRequestError(
+        `Submitter resources are required to close Marathon Match challenge ${challengeId}. Missing submitter resources for userIds: ${missingResources
+          .map((winner) => winner.userId)
+          .join(", ")}`
+      );
+    }
+  }
+
+  const closedAt = new Date().toISOString();
+  const updatedPhases = (challenge.phases || []).map((phase) => ({
+    ...phase,
+    isOpen: false,
+    actualEndDate: closedAt,
+  }));
+
+  const updatedChallenge = await updateChallenge(
+    currentUser,
+    challengeId,
+    {
+      winners,
+      phases: updatedPhases,
+      status: ChallengeStatusEnum.COMPLETED,
+    },
+    { emitEvent: true }
+  );
+
+  return updatedChallenge;
+}
+
 advancePhase.schema = {
   currentUser: Joi.any(),
   challengeId: Joi.id(),
@@ -3566,6 +3667,11 @@ advancePhase.schema = {
     .required(),
 };
 
+closeMarathonMatch.schema = {
+  currentUser: Joi.any(),
+  challengeId: Joi.id(),
+};
+
 async function indexChallengeAndPostToKafka(updatedChallenge, track, type) {
   const prizeType = challengeHelper.validatePrizeSetsAndGetPrizeType(updatedChallenge.prizeSets);
 
@@ -3610,6 +3716,7 @@ module.exports = {
   getChallengeStatistics,
   sendNotifications,
   advancePhase,
+  closeMarathonMatch,
   getDefaultReviewers,
   setDefaultReviewers,
   indexChallengeAndPostToKafka,