refactor: challenge interfaces

Author: rakibansary

package.json

@@ -24,7 +24,7 @@
     "lodash": "^4.17.21",
     "moment": "^2.29.4",
     "source-map-support": "^0.5.21",
-    "topcoder-interface": "github:topcoder-platform/plat-interface-definition#v0.0.13",
+    "topcoder-interface": "github:topcoder-platform/plat-interface-definition#v0.0.14",
     "uuidv4": "^6.2.13"
   },
   "devDependencies": {

src/config/constants.ts

@@ -16,8 +16,48 @@ export const ProjectCategories = {
 };
 
 export const ResourceRoleTypeIds = {
-  IterativeReviewer: 21,
+  Submitter: 1,
+  PrimaryScreener: 2,
+  Screener: 3,
   Reviewer: 4,
+  Approver: 10,
+  Designer: 11,
+  Observer: 12,
+  Manager: 13,
+  Copilot: 14,
+  ClientManager: 15,
+  PostMortemReviewer: 16,
   SpecificationSubmitter: 17,
   SpecificationReviewer: 18,
+  CheckpointScreener: 19,
+  CheckpointReviewer: 20,
+  IterativeReviewer: 21,
+};
+
+export const ResourceInfoTypeIds = {
+  ExternalReferenceId: 1,
+  Handle: 2,
+  Email: 3,
+  Rating: 4,
+  Reliability: 5,
+  RegistrationDate: 6,
+  Payment: 7,
+  PaymentStatus: 8,
+  ScreeningScore: 9,
+  InitialScore: 10,
+  FinalScore: 11,
+  Placement: 12,
+  AppealsCompletedEarly: 13,
+  SVNPermissionAdded: 14,
+  ManualPayments: 15,
 };
+
+export type ResourceInfoTypeIds = keyof typeof ResourceInfoTypeIds;
+
+export const ObserverResourceInfoToAdd: ResourceInfoTypeIds[] = [
+  "ExternalReferenceId",
+  "Handle",
+  "RegistrationDate",
+  "PaymentStatus",
+  "AppealsCompletedEarly",
+];

src/domain/LegacyChallenge.ts

@@ -2,16 +2,19 @@ import {
   Operator as RelationalOperator,
   QueryBuilder,
 } from "@topcoder-framework/client-relational";
-import { Operator, CheckExistsResult } from "@topcoder-framework/lib-common";
+import { CheckExistsResult, CreateResult, Operator } from "@topcoder-framework/lib-common";
 import _ from "lodash";
 import moment from "moment";
 import {
   PhaseStatusIds,
   PhaseTypeIds,
   ProjectCategories,
+  ResourceInfoTypeIds,
   ResourceRoleTypeIds,
 } from "../config/constants";
+import ChallengeHelper from "../helper/ChallengeHelper";
 import { queryRunner } from "../helper/QueryRunner";
+import UserHelper from "../helper/UserHelper";
 import {
   CloseChallengeInput,
   CreateChallengeInput,
@@ -20,12 +23,14 @@ import {
   UpdateChallengeInput,
 } from "../models/domain-layer/legacy/challenge";
 import { ProjectSchema } from "../schema/project/Project";
-import LegacyPhaseDomain from "./Phase";
+import LegacyPhaseDomain from "./LegacyPhase";
 import LegacyPrizeDomain from "./Prize";
 import LegacyProjectInfoDomain from "./ProjectInfo";
 import LegacyResourceDomain from "./Resource";
 import LegacyReviewDomain from "./Review";
 
+const TCWEBSERVICE: number = 22838965;
+
 class LegacyChallengeDomain {
   public async activateChallenge(input: LegacyChallengeId) {
     // update challenge status
@@ -394,6 +399,151 @@ class LegacyChallengeDomain {
     }
   }
 
+  public async create(input: CreateChallengeInput): Promise<CreateResult> {
+    const transaction = queryRunner.beginTransaction();
+
+    // insert record in project
+    const createProjectQuery = ChallengeHelper.getChallengeCreateQuery(
+      {
+        projectCategoryId: input.projectCategoryId,
+        projectStatusId: input.projectStatusId,
+        tcDirectProjectId: input.tcDirectProjectId,
+      },
+      TCWEBSERVICE
+    );
+
+    const createQueryResult = await transaction.add(createProjectQuery);
+
+    if (createQueryResult instanceof Error) {
+      transaction.rollback();
+      throw createQueryResult;
+    }
+
+    const projectId = createQueryResult.lastInsertId!;
+
+    // insert record(s) in prize
+    const createPrizeQueries = ChallengeHelper.getPrizeCreateQueries(
+      projectId,
+      input.winnerPrizes,
+      TCWEBSERVICE
+    );
+
+    for (const q of createPrizeQueries) {
+      await transaction.add(q);
+    }
+
+    // insert record(s) in project_info
+    const createProjectInfoQueries = ChallengeHelper.getChallengeInfoCreateQueries(
+      projectId,
+      input.projectInfo,
+      TCWEBSERVICE
+    );
+
+    for (const q of createProjectInfoQueries) {
+      await transaction.add(q);
+    }
+
+    // insert record(s) in project_phase
+    for (const phase of input.phases) {
+      const createPhaseQuery = ChallengeHelper.getPhaseCreateQuery(projectId, phase, TCWEBSERVICE);
+      const createPhaseResult = await transaction.add(createPhaseQuery);
+      if (createPhaseResult instanceof Error) {
+        transaction.rollback();
+        throw createPhaseResult;
+      }
+      const projectPhaseId = createPhaseResult.lastInsertId!;
+      // insert record(s) into phase_criteria
+      const createPhaseCriteriaQueries = ChallengeHelper.getPhaseCriteriaCreateQueries(
+        projectPhaseId,
+        phase.phaseCriteria,
+        TCWEBSERVICE
+      );
+      for (const q of createPhaseCriteriaQueries) {
+        await transaction.add(q);
+      }
+    }
+
+    const getObserversToAddQuery = ChallengeHelper.getDirectProjectListUserQuery(
+      input.tcDirectProjectId
+    );
+    const getObserversToAddResult = await transaction.add(getObserversToAddQuery);
+    if (getObserversToAddResult instanceof Error) {
+      transaction.rollback();
+      throw getObserversToAddResult;
+    }
+
+    const adminsToAdd = getObserversToAddResult?.rows
+      ?.map((o) => ({
+        userId: o["user_id"],
+        handle: o["handle"],
+        role: ResourceRoleTypeIds.Observer,
+      }))
+      .concat([
+        { userId: 22770213, handle: "Applications", role: ResourceRoleTypeIds.Manager },
+        { userId: TCWEBSERVICE, handle: "tcwebservice", role: ResourceRoleTypeIds.Manager },
+      ]);
+
+    const copilot = input.copilot;
+
+    if (copilot != null) {
+      const getCopilotHandleQuery = UserHelper.getUserHandleQuery(copilot.userId);
+      const getCopilotHandleResult = await transaction.add(getCopilotHandleQuery);
+      if (getCopilotHandleResult instanceof Error || getCopilotHandleResult.rows?.length != 1) {
+        transaction.rollback();
+        throw getCopilotHandleResult;
+      }
+      adminsToAdd?.push({
+        userId: copilot.userId,
+        handle: getCopilotHandleResult.rows[0].handleLower,
+        role: ResourceRoleTypeIds.Copilot,
+      });
+    }
+
+    for (const { userId, handle, role } of adminsToAdd!) {
+      const createResourceQuery = ChallengeHelper.getResourceCreateQuery(
+        projectId,
+        userId,
+        role,
+        undefined,
+        TCWEBSERVICE
+      );
+      const result = await transaction.add(createResourceQuery);
+      if (result instanceof Error) {
+        transaction.rollback();
+        throw result;
+      }
+      const resourceId = result.lastInsertId!;
+      const createResourceInfoQueries = ChallengeHelper.getObserverResourceInfoCreateQueries(
+        resourceId,
+        userId,
+        handle,
+        TCWEBSERVICE
+      );
+
+      for (const q of createResourceInfoQueries) {
+        await transaction.add(q);
+      }
+      if (role === ResourceRoleTypeIds.Copilot && copilot != null) {
+        const createCopilotResourceInfoQuery = ChallengeHelper.getResourceInfoCreateQuery(
+          resourceId,
+          ResourceInfoTypeIds.Payment,
+          "" + copilot.fee,
+          TCWEBSERVICE
+        );
+        await transaction.add(createCopilotResourceInfoQuery);
+      }
+    }
+
+    transaction.commit();
+
+    return {
+      kind: {
+        $case: "integerId",
+        integerId: projectId,
+      },
+    };
+  }
+
   public async update(input: UpdateChallengeInput) {
     await queryRunner.run(
       new QueryBuilder(ProjectSchema)
@@ -426,7 +576,7 @@ class LegacyChallengeDomain {
     return LegacyChallenge.fromPartial(rows[0] as LegacyChallenge);
   }
 
-  public async checkChallengeExists(legacyChallengeId: number): Promise<CheckExistsResult> {
+  public async checkExists(legacyChallengeId: number): Promise<CheckExistsResult> {
     const { projectId } = ProjectSchema.columns;
 
     const query = new QueryBuilder(ProjectSchema)
@@ -446,30 +596,6 @@ class LegacyChallengeDomain {
       exists: rows?.length == 1,
     };
   }
-
-  public async createLegacyChallenge(input: CreateChallengeInput): Promise<number> {
-    const transaction = queryRunner.beginTransaction();
-
-    const createLegacyChallengeQuery = new QueryBuilder(ProjectSchema)
-      .insert({
-        projectStatusId: input.projectStatusId,
-        projectCategoryId: input.projectCategoryId,
-        tcDirectProjectId: input.tcDirectProjectId,
-      })
-      .build();
-
-    const createLegacyChallengeQueryResult = await transaction.add(createLegacyChallengeQuery);
-    if (createLegacyChallengeQueryResult instanceof Error) {
-      transaction.rollback();
-      return Promise.reject({
-        message: "Failed to create legacy challenge",
-      });
-    }
-
-    const { lastInsertId: legacyChallengeId } = createLegacyChallengeQueryResult;
-
-    return Promise.resolve(legacyChallengeId!);
-  }
 }
 
 export default new LegacyChallengeDomain();

src/domain/LegacyChallengePayment.ts

@@ -9,7 +9,7 @@ import {
   LegacyChallengePayment,
   LegacyChallengePaymentList,
   UpdateLegacyChallengePaymentInput,
-} from "../../dist/models/domain-layer/legacy/challenge_payment";
+} from "../models/domain-layer/legacy/challenge_payment";
 import { ProjectPaymentSchema } from "../schema/project_payment/ProjectPayment";
 
 class LegacyPaymentDomain {

src/domain/Phase.ts renamed to src/domain/LegacyPhase.ts

@@ -9,7 +9,7 @@ import {
   ProjectRoleTermsOfUseXref,
   ProjectRoleTermsOfUseXrefList,
 } from "../models/domain-layer/legacy/term";
-import { ProjectRoleTermsOfUseXrefSchema } from "../schema/term/Term";
+import { ProjectRoleTermsOfUseXrefSchema } from "../schema/Term/Term";
 
 class LegacyTermDomain {
   public async getProjectRoleTermsOfUseXrefs(