feature: legacy challenge definitions

package.json

@@ -16,8 +16,8 @@
   "license": "ISC",
   "dependencies": {
     "@grpc/grpc-js": "^1.7.1",
-    "@topcoder-framework/client-relational": "^0.4.23-ci.0",
-    "@topcoder-framework/lib-common": "^0.4.23-ci.0",
+    "@topcoder-framework/client-relational": "^0.4.24-ci.0",
+    "@topcoder-framework/lib-common": "^0.4.24-ci.0",
     "dayjs": "^1.11.5",
     "dotenv": "^16.0.3",
     "grpc-server-reflection": "^0.1.5",

src/domain/LegacyChallenge.ts

@@ -1,76 +1,75 @@
-import { ColumnType, Operator, QueryRequest } from "@topcoder-framework/client-relational";
-import { Value } from "@topcoder-framework/lib-common";
-import { QueryRunner } from "../common/QueryRunner";
-import { CheckChallengeExistsResponse } from "../models/domain-layer/legacy/challenge";
-import { Project } from "../schema/project/Project";
+import { Operator, QueryBuilder } from "@topcoder-framework/client-relational";
+import { queryRunner } from "../helper/QueryRunner";
+import {
+  CheckChallengeExistsResponse,
+  CreateChallengeInput,
+} from "../models/domain-layer/legacy/challenge";
+import { ProjectSchema } from "../schema/project/Project";
 
 class LegacyChallengeDomain {
   public async checkChallengeExists(
     legacyChallengeId: number
   ): Promise<CheckChallengeExistsResponse> {
-    const challenges = (await new QueryRunner(Project)
-      .select([Project.columns.projectId])
-      .where({
-        key: "project_id",
-        operator: Operator.OPERATOR_EQUAL,
+    const { projectId } = ProjectSchema.columns;
+
+    const query = new QueryBuilder(ProjectSchema)
+      .select(projectId)
+      .where(projectId, Operator.OPERATOR_EQUAL, {
         value: {
-          value: {
-            $case: "intValue",
-            intValue: legacyChallengeId,
-          },
+          $case: "intValue",
+          intValue: legacyChallengeId,
         },
       })
       .limit(1)
-      .offset(0)
-      .exec()) as [
-      {
-        values: {
-          projectId: Value;
-        };
-      }
-    ];
+      .build();
+
+    const { rows } = await queryRunner.run(query);
 
     return {
-      exists: challenges.length == 1,
+      exists: rows?.length == 1,
     };
   }
 
-  public async listAvailableChallengeInfoTypes(key: string): Promise<number> {
-    const queryRequest: QueryRequest = {
-      query: {
-        query: {
-          $case: "select",
-          select: {
-            table: "project_info_type_lu",
-            join: [],
-            column: [
-              {
-                name: "",
-                type: ColumnType.COLUMN_TYPE_INT,
-              },
-            ],
-            where: [
-              {
-                key: "name",
-                operator: Operator.OPERATOR_EQUAL,
-                value: {
-                  value: {
-                    $case: "stringValue",
-                    stringValue: key,
-                  },
-                },
-              },
-            ],
-            groupBy: [],
-            orderBy: [],
-            limit: 1,
-            offset: 0,
-          },
-        },
-      },
-    };
-    return Promise.resolve(10);
+  public async createLegacyChallenge(input: CreateChallengeInput): Promise<number> {
+    return Promise.resolve(123);
   }
+
+  // public async listAvailableChallengeInfoTypes(key: string): Promise<number> {
+  //   const queryRequest: QueryRequest = {
+  //     query: {
+  //       query: {
+  //         $case: "select",
+  //         select: {
+  //           table: "project_info_type_lu",
+  //           join: [],
+  //           column: [
+  //             {
+  //               name: "",
+  //               type: ColumnType.COLUMN_TYPE_INT,
+  //             },
+  //           ],
+  //           where: [
+  //             {
+  //               key: "name",
+  //               operator: Operator.OPERATOR_EQUAL,
+  //               value: {
+  //                 value: {
+  //                   $case: "stringValue",
+  //                   stringValue: key,
+  //                 },
+  //               },
+  //             },
+  //           ],
+  //           groupBy: [],
+  //           orderBy: [],
+  //           limit: 1,
+  //           offset: 0,
+  //         },
+  //       },
+  //     },
+  //   };
+  //   return Promise.resolve(10);
+  // }
 }
 
 export default new LegacyChallengeDomain();

src/domain/LegacyChallengePhase.ts

@@ -1,9 +1,9 @@
-import { QueryRunner } from "../common/QueryRunner";
-import { Value } from "@topcoder-framework/client-relational";
+import { QueryBuilder } from "@topcoder-framework/client-relational";
+import { CreateResult } from "@topcoder-framework/lib-common";
+import { queryRunner } from "../helper/QueryRunner";
 import { CreatePhaseInput, PhaseTypeList } from "../models/domain-layer/legacy/challenge_phase";
-import { PhaseType } from "../schema/project/PhaseType";
+import { PhaseTypeSchema } from "../schema/project/PhaseType";
 import { ProjectPhaseSchema } from "../schema/project/ProjectPhase";
-import { CreateResult } from "@topcoder-framework/lib-common";
 
 class LegacyChallengePhaseDomain {
   public async create(input: CreatePhaseInput): Promise<CreateResult> {
@@ -13,34 +13,28 @@ class LegacyChallengePhaseDomain {
       modifyUser: 22838965, // tcwebservice | TODO: Get using grpc interceptor
     };
 
-    const phaseId = (await new QueryRunner(ProjectPhaseSchema)
-      .insert(createInput)
-      .exec()) as number;
+    const { lastInsertId: phaseId } = await queryRunner.run(
+      new QueryBuilder(ProjectPhaseSchema).insert(createInput).build()
+    );
 
     return {
       kind: {
         $case: "integerId",
-        integerId: phaseId,
+        integerId: phaseId!,
       },
     };
   }
 
   public async getPhaseTypes(): Promise<PhaseTypeList> {
-    const projectPhases = (await new QueryRunner(PhaseType)
-      .select([PhaseType.columns.phaseTypeId, PhaseType.columns.name])
+    const query = new QueryBuilder(PhaseTypeSchema)
+      .select(PhaseTypeSchema.columns.phaseTypeId, PhaseTypeSchema.columns.name)
       .limit(500)
-      .offset(0)
-      .exec()) as [
-      {
-        values: {
-          phase_type_id: Value;
-          name: Value;
-        };
-      }
-    ];
+      .build();
+
+    const { rows: projectPhases } = await queryRunner.run(query);
 
     const list: PhaseTypeList = {
-      items: projectPhases.map(({ values }) => {
+      items: projectPhases!.map(({ values }) => {
         return {
           phaseTypeId:
             values.phase_type_id.value?.$case === "intValue"

src/domain/Prize.ts

@@ -0,0 +1,85 @@
+import { QueryBuilder } from "@topcoder-framework/client-relational";
+import { CreateResult, ScanCriteria } from "@topcoder-framework/lib-common";
+import { queryRunner } from "../helper/QueryRunner";
+import { CreatePrizeInput, Prize, PrizeList } from "../models/domain-layer/legacy/prize";
+import { PrizeSchema } from "../schema/project_payment/Prize";
+
+class PrizeDomain {
+  public async create(input: CreatePrizeInput): Promise<CreateResult> {
+    const createInput: Partial<Prize> = {
+      ...input,
+      createUser: 22838965, // tcwebservice | TODO: Get using grpc interceptor
+      modifyUser: 22838965, // tcwebservice | TODO: Get using grpc interceptor
+    };
+
+    const { lastInsertId: prizeId } = await queryRunner.run(
+      new QueryBuilder<CreatePrizeInput>(PrizeSchema).insert(createInput).build()
+    );
+
+    return {
+      kind: {
+        $case: "integerId",
+        integerId: prizeId!,
+      },
+    };
+  }
+
+  public async scan(criteria: ScanCriteria): Promise<PrizeList> {
+    const { rows: prizes } = await queryRunner.run(
+      new QueryBuilder(PrizeSchema)
+        .select(
+          PrizeSchema.columns.prizeId,
+          PrizeSchema.columns.prizeTypeId,
+          PrizeSchema.columns.prizeAmount,
+          PrizeSchema.columns.place,
+          PrizeSchema.columns.numberOfSubmissions,
+          PrizeSchema.columns.projectId,
+          PrizeSchema.columns.createDate,
+          PrizeSchema.columns.createUser,
+          PrizeSchema.columns.modifyDate,
+          PrizeSchema.columns.modifyUser
+        )
+        .build()
+    );
+
+    // const prizes = (await new QueryRunner(PrizeSchema).select([]).limit(10).offset(0).exec()) as [
+    //   {
+    //     values: {
+    //       prize_id: Value;
+    //       prize_type_id: number;
+    //       prize_amount: Value;
+    //       place: number;
+    //       number_of_submissions: number;
+    //       prize_description: string;
+    //       project_id: number;
+    //       create_date: number;
+    //       create_user: number;
+    //       modify_date: number;
+    //       modify_user: number;
+    //     };
+    //   }
+    // ];
+
+    console.log("prizes", prizes);
+
+    const list: PrizeList = {
+      prizes: [],
+      // prizes: prizes!.map(({ values }) => {
+      //   return {
+      //     place: values.place,
+      //     numberOfSubmissions: values.number_of_submissions,
+      //     prizeDescription: values.prize_description,
+      //     projectId: values.project_id,
+      //     createDate: values.create_date,
+      //     createUser: values.create_user,
+      //     modifyDate: values.modify_date,
+      //     modifyUser: values.modify_user,
+      //   };
+      // }),
+    };
+
+    return list;
+  }
+}
+
+export default new PrizeDomain();

src/helper/QueryRunner.ts

@@ -0,0 +1,8 @@
+const { GRPC_RDB_SERVER_HOST, GRPC_RDB_SERVER_PORT } = process.env;
+
+import { QueryRunner } from "@topcoder-framework/client-relational";
+
+export const queryRunner = new QueryRunner(
+  GRPC_RDB_SERVER_HOST!,
+  parseInt(GRPC_RDB_SERVER_PORT!, 10)
+);