feat: add phase management api

.circleci/config.yml

@@ -17,6 +17,7 @@ install_deploysuite: &install_deploysuite
     cp ./../buildscript/master_deploy.sh .
     cp ./../buildscript/buildenv.sh .
     cp ./../buildscript/awsconfiguration.sh .
+
 restore_cache_settings_for_build: &restore_cache_settings_for_build
   key: docker-node-modules-{{ checksum "yarn.lock" }}
 
@@ -32,8 +33,14 @@ builddeploy_steps: &builddeploy_steps
 - run: *install_deploysuite
 - restore_cache: *restore_cache_settings_for_build
 - run:
-    name: "Authenticate with CodeArtifact and build docker image"
-    command: "./awsconfiguration.sh ${CODEARTIFACT_ENV}\nsource awsenvconf\naws codeartifact login --tool npm --repository topcoder-framework --domain topcoder --domain-owner $AWS_ACCOUNT_ID --region $AWS_REGION --namespace @topcoder-framework\ncp ~/.npmrc .\nrm -f awsenvconf            \n./build.sh ${APPNAME}\n"
+    name: "Authenticate with CodeArtifact and build Docker image"
+    command: |
+      ./awsconfiguration.sh ${CODEARTIFACT_ENV}
+      source awsenvconf
+      aws codeartifact login --tool npm --repository topcoder-framework --domain topcoder --domain-owner $AWS_ACCOUNT_ID --region $AWS_REGION --namespace @topcoder-framework
+      cp ~/.npmrc .
+      rm -f awsenvconf
+      ./build.sh ${APPNAME}
 - save_cache: *save_cache_settings
 - deploy:
     name: Running MasterScript.
@@ -83,7 +90,7 @@ workflows:
           branches:
             only:
             - dev
-            - fix/floating-point-arhithmetic
+            - feature/phase-advance
 
     - "build-qa":
         context: org-global

.gitignore

@@ -63,3 +63,5 @@ typings/
 .next
 ecr-login.sh
 .npmrc
+
+test.js

package.json

@@ -53,6 +53,7 @@
     "cors": "^2.7.1",
     "decimal.js": "^10.4.3",
     "deep-equal": "^2.2.0",
+    "dompurify": "^3.0.2",
     "dotenv": "^8.2.0",
     "elasticsearch": "^16.7.3",
     "express": "^4.15.4",
@@ -62,8 +63,11 @@
     "http-aws-es": "^6.0.0",
     "http-status-codes": "^1.3.0",
     "joi": "^14.0.0",
+    "jsdom": "^21.1.2",
+    "json-rules-engine": "^6.1.2",
     "jsonwebtoken": "^8.3.0",
     "lodash": "^4.17.19",
+    "markdown-it": "^13.0.1",
     "moment": "^2.24.0",
     "node-cache": "^5.1.2",
     "swagger-ui-express": "^4.1.3",

src/common/helper.js

@@ -226,13 +226,18 @@ async function deleteFromS3(bucket, key) {
  * @param {String} challengeId the challenge id
  * @returns {Promise<Array>} the challenge resources
  */
-async function getChallengeResources(challengeId) {
+async function getChallengeResources(challengeId, roleId = null) {
   const token = await m2mHelper.getM2MToken();
   const perPage = 100;
   let page = 1;
   let result = [];
   while (true) {
-    const url = `${config.RESOURCES_API_URL}?challengeId=${challengeId}&perPage=${perPage}&page=${page}`;
+    const url = `${
+      config.RESOURCES_API_URL
+    }?challengeId=${challengeId}&perPage=${perPage}&page=${page}${
+      roleId ? `&roleId=${roleId}` : ""
+    }`;
+
     const res = await axios.get(url, {
       headers: { Authorization: `Bearer ${token}` },
     });
@@ -1020,7 +1025,7 @@ async function getGroupById(groupId) {
 /**
  * Get challenge submissions
  * @param {String} challengeId the challenge id
- * @returns {Array} the submission
+ * @returns {Promise<Array>} the submission
  */
 async function getChallengeSubmissions(challengeId) {
   const token = await m2mHelper.getM2MToken();

src/common/phase-helper.js

@@ -20,6 +20,7 @@ const phaseDomain = new PhaseDomain(GRPC_CHALLENGE_SERVER_HOST, GRPC_CHALLENGE_S
 class ChallengePhaseHelper {
   phaseDefinitionMap = {};
   timelineTemplateMap = {};
+
   async populatePhasesForChallengeCreation(phases, startDate, timelineTemplateId) {
     if (_.isUndefined(timelineTemplateId)) {
       throw new errors.BadRequestError(`Invalid timeline template ID: ${timelineTemplateId}`);
@@ -176,7 +177,10 @@ class ChallengePhaseHelper {
 
   handlePhasesAfterCancelling(phases) {
     return _.map(phases, (phase) => {
-      const shouldClosePhase = _.includes(["Registration", "Submission", "Checkpoint Submission"], phase.name);
+      const shouldClosePhase = _.includes(
+        ["Registration", "Submission", "Checkpoint Submission"],
+        phase.name
+      );
       return {
         ...phase,
         isOpen: shouldClosePhase ? false : phase.isOpen,

src/controllers/ChallengeController.js

@@ -116,6 +116,15 @@ async function deleteChallenge(req, res) {
   res.send(result);
 }
 
+/**
+ * Advance phase
+ * @param {Object} req the request
+ * @param {Object} res the response
+ */
+async function advancePhase(req, res) {
+  res.send(await service.advancePhase(req.authUser, req.params.challengeId, req.body));
+}
+
 module.exports = {
   searchChallenges,
   createChallenge,
@@ -124,4 +133,5 @@ module.exports = {
   deleteChallenge,
   getChallengeStatistics,
   sendNotifications,
+  advancePhase,
 };

src/phase-management/PhaseAdvancer.js

@@ -0,0 +1,249 @@
+const config = require("config");
+const { Engine } = require("json-rules-engine");
+
+const rulesJSON = require("./phase-rules.json");
+const errors = require("../common/errors");
+
+const helper = require("../common/helper");
+
+// Helper functions
+
+// TODO: Move these to a common place
+
+const normalizeName = (name) => name.replace(/ /g, "");
+
+const shouldCheckConstraint = (operation, phase, constraintName, rules) => {
+  const normalizedConstraintName = normalizeName(constraintName);
+  return (
+    operation === "close" &&
+    phase.constraints &&
+    rules.constraintRules[phase.name]?.includes(normalizedConstraintName)
+  );
+};
+
+const parseDate = (dateString) => {
+  const date = new Date(dateString).getTime();
+  return isNaN(date) ? null : date;
+};
+
+// End of helper functions
+
+class PhaseAdvancer {
+  #rules = rulesJSON;
+
+  #factGenerators = {
+    Registration: async (challengeId) => ({
+      registrantCount: await this.#getRegistrantCount(challengeId),
+    }),
+    Submission: async (challengeId) => ({
+      submissionCount: await this.#getSubmissionCount(challengeId),
+      hasActiveUnreviewedSubmissions: await this.#hasActiveUnreviewedSubmissions(challengeId),
+    }),
+    Review: async (challengeId) => ({
+      allSubmissionsReviewed: await this.#areAllSubmissionsReviewed(challengeId),
+    }),
+    "Iterative Review": async (challengeId) => ({
+      hasActiveUnreviewedSubmissions: await this.#hasActiveUnreviewedSubmissions(challengeId),
+    }),
+    "Appeals Response": async (challengeId) => ({
+      allAppealsResolved: await this.#areAllAppealsResolved(challengeId),
+    }),
+  };
+
+  async #generateFacts(challengeId, phases, phase, operation) {
+    const facts = {
+      name: phase.name,
+      isOpen: phase.isOpen,
+      isClosed: !phase.isOpen && phase.actualEndDate != null,
+      isPastScheduledStartTime: this.#isPastTime(phase.scheduledStartDate),
+      isPastScheduledEndTime: this.#isPastTime(phase.scheduledEndDate),
+      isPostMortemOpen: phases.find((p) => p.name === "Post-Mortem")?.isOpen,
+      hasPredecessor: phase.predecessorId != null,
+      isPredecessorPhaseClosed:
+        phase.predecessorId != null
+          ? this.#isPastTime(phases.find((p) => p.phaseId === phase.predecessorId)?.actualEndDate)
+          : true,
+      nextPhase: phases.find((p) => p.predecessor === phase.phaseId)?.name,
+    };
+
+    if (operation === "close" && this.#factGenerators[phase.name]) {
+      const additionalFacts = await this.#factGenerators[phase.name](challengeId);
+      Object.assign(facts, additionalFacts);
+    }
+
+    return facts;
+  }
+
+  async advancePhase(challengeId, phases, operation, phaseName) {
+    const phase = phases.find((phase) => phase.name === phaseName);
+
+    if (!phase) {
+      throw new errors.BadRequestError(`Phase ${phaseName} not found`);
+    }
+
+    const essentialRules = this.#rules[`${operation}Rules`][normalizeName(phase.name)]
+      ? this.#rules[`${operation}Rules`][normalizeName(phase.name)].map((rule) => ({
+          name: rule.name,
+          conditions: rule.conditions,
+          event: rule.event,
+        }))
+      : [];
+
+    const constraintRules =
+      phase.constraints
+        ?.filter((constraint) =>
+          shouldCheckConstraint(operation, phase, constraint.name, this.#rules)
+        )
+        .map((constraint) => ({
+          name: `Constraint: ${constraint.name}`,
+          fact: normalizeName(constraint.name),
+          operator: "greaterOrEqual",
+          value: constraint.value,
+        })) || [];
+
+    const rules = [...essentialRules, ...constraintRules];
+    const facts = await this.#generateFacts(challengeId, phases, phase, operation);
+
+    console.log("rules", JSON.stringify(rules, null, 2));
+    console.log("facts", JSON.stringify(facts, null, 2));
+
+    for (const rule of rules) {
+      const ruleExecutionResult = await this.#executeRule(rule, facts);
+
+      if (!ruleExecutionResult.success) {
+        return {
+          success: false,
+          message: `Cannot ${operation} phase ${phase.name} for challenge ${challengeId}`,
+          detail: `Rule ${rule.name} failed`,
+          failureReasons: ruleExecutionResult.failureReasons,
+        };
+      }
+    }
+
+    if (operation === "open") {
+      await this.#open(challengeId, phases, phase);
+    } else if (operation === "close") {
+      await this.#close(challengeId, phases, phase);
+    }
+
+    const next = operation === "close" ? phases.filter((p) => p.predecessor === phase.phaseId) : [];
+
+    return {
+      success: true,
+      message: `Successfully ${operation}d phase ${phase.name} for challenge ${challengeId}`,
+      updatedPhases: phases,
+      next,
+    };
+  }
+
+  async #open(challengeId, phases, phase) {
+    console.log(`Opening phase ${phase.name} for challenge ${challengeId}`);
+
+    phase.isOpen = true;
+    const actualStartDate = new Date();
+    phase.actualStartDate = actualStartDate.toISOString();
+    phase.scheduledEndDate = new Date(
+      actualStartDate.getTime() + phase.duration * 1000
+    ).toISOString();
+
+    const scheduledStartDate = parseDate(phase.scheduledStartDate);
+    const delta = scheduledStartDate - actualStartDate; // in milliseconds
+
+    if (delta !== 0) {
+      this.#updateSubsequentPhases(phases, phase, -delta);
+    }
+
+    console.log(`Updated phases: ${JSON.stringify(phases, null, 2)}`);
+  }
+
+  async #close(challengeId, phases, phase) {
+    console.log(`Closing phase ${phase.name} for challenge ${challengeId}`);
+
+    phase.isOpen = false;
+    const actualEndDate = new Date();
+    phase.actualEndDate = actualEndDate.toISOString();
+
+    const scheduledEndDate = parseDate(phase.scheduledEndDate);
+    const delta = scheduledEndDate - actualEndDate;
+
+    if (delta !== 0) {
+      this.#updateSubsequentPhases(phases, phase, -delta);
+    }
+
+    console.log(`Updated phases: ${JSON.stringify(phases, null, 2)}`);
+  }
+
+  #isPastTime(dateString) {
+    if (dateString == null) {
+      return false;
+    }
+    const date = new Date(dateString);
+    const now = new Date();
+    return date <= now;
+  }
+
+  async #getRegistrantCount(challengeId) {
+    console.log(`Getting registrant count for challenge ${challengeId}`);
+    // TODO: getChallengeResources loops through all pages, which is not necessary here, we can just get the first page and total count from header[X-Total]
+    const submitters = await helper.getChallengeResources(challengeId, config.SUBMITTER_ROLE_ID);
+    return submitters.length;
+  }
+
+  async #getSubmissionCount(challengeId) {
+    console.log(`Getting submission count for challenge ${challengeId}`);
+    // TODO: getChallengeSubmissions loops through all pages, which is not necessary here, we can just get the first page and total count from header[X-Total]
+    const submissions = await helper.getChallengeSubmissions(challengeId);
+    return submissions.length;
+  }
+
+  async #areAllSubmissionsReviewed(challengeId) {
+    console.log(`Getting review count for challenge ${challengeId}`);
+    return Promise.resolve(false);
+  }
+
+  async #areAllAppealsResolved(challengeId) {
+    console.log(`Checking if all appeals are resolved for challenge ${challengeId}`);
+    return Promise.resolve(false);
+  }
+
+  async #hasActiveUnreviewedSubmissions(challengeId) {
+    console.log(`Checking if there are active unreviewed submissions for challenge ${challengeId}`);
+    return Promise.resolve(false);
+  }
+
+  async #executeRule(rule, facts) {
+    const ruleEngine = new Engine();
+    ruleEngine.addRule(rule);
+
+    const result = await ruleEngine.run(facts);
+
+    const failureReasons = result.failureResults.map((failureResult) => ({
+      rule: rule.name,
+      failedConditions: failureResult.conditions.all
+        .filter((condition) => !condition.result)
+        .map((condition) => ({
+          fact: condition.fact,
+          operator: condition.operator,
+          value: condition.value,
+        })),
+    }));
+
+    return {
+      success: result.events.length > 0,
+      failureReasons,
+    };
+  }
+
+  // prettier-ignore
+  #updateSubsequentPhases(phases, currentPhase, delta) {
+    let nextPhase = phases.find((phase) => phase.predecessor === currentPhase.phaseId);
+
+    while (nextPhase) {
+      nextPhase.scheduledStartDate = new Date(new Date(nextPhase.scheduledStartDate).getTime() + delta).toISOString();
+      nextPhase.scheduledEndDate = new Date(new Date(nextPhase.scheduledEndDate).getTime() + delta).toISOString();
+      nextPhase = phases.find((phase) => phase.predecessor === nextPhase.phaseId);
+    }
+  }
+}
+
+module.exports = new PhaseAdvancer();