feat(domain-acl): complete challenge update interfaces

Author: ThomasKranitsas

package.json

@@ -16,14 +16,14 @@
   "license": "ISC",
   "dependencies": {
     "@grpc/grpc-js": "^1.7.1",
-    "@topcoder-framework/client-relational": "^0.4.24-ci.0",
+    "@topcoder-framework/client-relational": "v0.4.23-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",
     "lodash": "^4.17.21",
     "source-map-support": "^0.5.21",
-    "topcoder-interface": "github:topcoder-platform/plat-interface-definition#v0.0.11",
+    "topcoder-interface": "github:topcoder-platform/plat-interface-definition#feat/challenge-acl-proto",
     "uuidv4": "^6.2.13"
   },
   "devDependencies": {

src/config/constants.ts

@@ -0,0 +1,105 @@
+import { Operator, QueryBuilder } from "@topcoder-framework/client-relational";
+import { CreateResult } from "@topcoder-framework/lib-common";
+import _ from "lodash";
+import { queryRunner } from "../helper/QueryRunner";
+import { GetContestEligibilityInput, ContestEligibilityList, ContestEligibility, GetGroupContestEligibilityInput, GroupContestEligibilityList, GroupContestEligibility, DeleteContestEligibilityInput, DeleteGroupContestEligibilityInput } from "../models/domain-layer/legacy/group_contest_eligibility";
+import { ContestEligibilitySchema } from "../schema/ContestEligibility.ts/ContestEligibility";
+import { GroupContestEligibilitySchema } from "../schema/ContestEligibility.ts/GroupContestEligibility";
+
+class LegacyGroupContestEligibilityDomain {
+  public async getContestEligibilities(input:GetContestEligibilityInput): Promise<ContestEligibilityList> {
+    const { rows } = await queryRunner.run(
+      new QueryBuilder(ContestEligibilitySchema)
+        .select(..._.map(ContestEligibilitySchema.columns))
+        .where(ContestEligibilitySchema.columns.contestId, Operator.OPERATOR_EQUAL, {
+          value: {
+            $case: "intValue",
+            intValue: input.contestId,
+          },
+        })
+        .build()
+    );
+
+    return { contestEligibilities: rows && rows?.length > 0 ? rows!.map(r => ContestEligibility.fromPartial(r as ContestEligibility)) : [] }
+  }
+
+  public async createContestEligibility(input:ContestEligibility): Promise<CreateResult> {
+    const { lastInsertId } = await queryRunner.run(
+      new QueryBuilder(ContestEligibilitySchema)
+      .insert({ ...input })
+      .build()
+    )
+    return {
+      kind: {
+        $case: "integerId",
+        integerId: lastInsertId!,
+      },
+    };
+  }
+
+  public async getGroupContestEligibilities(input:GetGroupContestEligibilityInput): Promise<GroupContestEligibilityList> {
+    const { rows } = await queryRunner.run(
+      new QueryBuilder(GroupContestEligibilitySchema)
+        .select(..._.map(GroupContestEligibilitySchema.columns))
+        .where(GroupContestEligibilitySchema.columns.contestEligibilityId, Operator.OPERATOR_EQUAL, {
+          value: {
+            $case: "intValue",
+            intValue: input.contestEligibilityId,
+          },
+        })
+        .build()
+    );
+
+    return { groupContestEligibilities: rows && rows?.length > 0 ? rows!.map(r => GroupContestEligibility.fromPartial(r as GroupContestEligibility)) : [] }
+  }
+
+  public async createGroupContestEligibility(input:GroupContestEligibility): Promise<CreateResult> {
+    const { lastInsertId } = await queryRunner.run(
+      new QueryBuilder(GroupContestEligibilitySchema)
+      .insert({ ...input })
+      .build()
+    )
+    return {
+      kind: {
+        $case: "integerId",
+        integerId: lastInsertId!,
+      },
+    };
+  }
+
+  public async deleteContestEligibility (input: DeleteContestEligibilityInput) {
+    await queryRunner.run(
+      new QueryBuilder(ContestEligibilitySchema)
+        .delete()
+        .where(ContestEligibilitySchema.columns.contestEligibilityId, Operator.OPERATOR_EQUAL, {
+          value: {
+            $case: "intValue",
+            intValue: input.contestEligibilityId,
+          },
+        })
+        .build()
+    );
+  }
+
+  public async deleteGroupContestEligibility (input: DeleteGroupContestEligibilityInput) {
+    await queryRunner.run(
+      new QueryBuilder(GroupContestEligibilitySchema)
+        .delete()
+        .where(GroupContestEligibilitySchema.columns.contestEligibilityId, Operator.OPERATOR_EQUAL, {
+          value: {
+            $case: "intValue",
+            intValue: input.contestEligibilityId,
+          },
+        })
+        .andWhere(GroupContestEligibilitySchema.columns.groupId, Operator.OPERATOR_EQUAL, {
+          value: {
+            $case: "intValue",
+            intValue: input.groupId,
+          },
+        })
+        .build()
+    );
+  }
+}
+
+export default new LegacyGroupContestEligibilityDomain();

src/domain/GroupContestEligibility.ts

@@ -1,12 +1,53 @@
+import _ from 'lodash';
 import { Operator, QueryBuilder } from "@topcoder-framework/client-relational";
 import { queryRunner } from "../helper/QueryRunner";
 import {
-  CheckChallengeExistsResponse,
-  CreateChallengeInput,
+  CheckChallengeExistsResponse, CloseChallengeInput, LegacyChallenge, LegacyChallengeId, UpdateChallengeInput,
 } from "../models/domain-layer/legacy/challenge";
 import { ProjectSchema } from "../schema/project/Project";
 
 class LegacyChallengeDomain {
+
+  public async activateChallenge(input:LegacyChallengeId) {
+    // TODO: Activate
+  }
+
+  public async closeChallenge(input:CloseChallengeInput) {
+    // TODO: close challenge
+  }
+
+  public async update(input:UpdateChallengeInput) {
+    await queryRunner.run(
+      new QueryBuilder(ProjectSchema)
+        .update({ projectStatusId: input.projectStatusId, modifyUser: input.modifyUser })
+        .where(ProjectSchema.columns.projectId, Operator.OPERATOR_EQUAL, {
+          value: {
+            $case: "intValue",
+            intValue: input.projectId,
+          },
+        })
+        .build()
+    );
+  }
+
+  public async getLegacyChallenge(
+    input: LegacyChallengeId
+  ): Promise<LegacyChallenge|undefined> {
+    const { rows } = await queryRunner.run(
+      new QueryBuilder(ProjectSchema)
+        .select(..._.map(ProjectSchema.columns))
+        .where(ProjectSchema.columns.projectId, Operator.OPERATOR_EQUAL, {
+          value: {
+            $case: "intValue",
+            intValue: input.legacyChallengeId,
+          },
+        })
+        .limit(1)
+        .build()
+    );
+    return rows?.length ? LegacyChallenge.fromPartial(rows[0] as LegacyChallenge) : undefined;
+  }
+
   public async checkChallengeExists(
     legacyChallengeId: number
   ): Promise<CheckChallengeExistsResponse> {
@@ -30,6 +71,7 @@ class LegacyChallengeDomain {
     };
   }
 
+<<<<<<< HEAD
   public async createLegacyChallenge(input: CreateChallengeInput): Promise<number> {
     const transaction = queryRunner.beginTransaction();
 
@@ -52,6 +94,10 @@ class LegacyChallengeDomain {
     const { lastInsertId: legacyChallengeId } = createLegacyChallengeQueryResult;
 
     return Promise.resolve(legacyChallengeId!);
+=======
+  public async createLegacyChallenge(input: any): Promise<number> {
+    return Promise.resolve(123);
+>>>>>>> 44dc00a (feat(domain-acl): complete challenge update interfaces)
   }
 
   // public async listAvailableChallengeInfoTypes(key: string): Promise<number> {

src/domain/LegacyChallenge.ts

@@ -0,0 +1,52 @@
+import { Operator, QueryBuilder } from "@topcoder-framework/client-relational";
+import _ from "lodash";
+import { queryRunner } from "../helper/QueryRunner";
+import { DeleteNotificationsInput, GetNotificationsInput, Notification, NotificationList } from "../models/domain-layer/legacy/notification";
+import { NotificationSchema } from "../schema/project/Notification";
+
+class LegacyNotificationDomain {
+
+  public async getNotifications(input:GetNotificationsInput): Promise<NotificationList> {
+    const { rows } = await queryRunner.run(
+      new QueryBuilder(NotificationSchema)
+        .select(..._.map(NotificationSchema.columns))
+        .where(NotificationSchema.columns.externalRefId, Operator.OPERATOR_EQUAL, {
+          value: {
+            $case: "intValue",
+            intValue: input.externalRefId,
+          },
+        })
+        .andWhere(NotificationSchema.columns.projectId, Operator.OPERATOR_EQUAL, {
+          value: {
+            $case: "intValue",
+            intValue: input.projectId,
+          },
+        })
+        .build()
+    );
+
+    return { notifications: rows!.map(r => Notification.fromPartial(r as Notification)) };
+  }
+
+  public async deleteNotifications(input:DeleteNotificationsInput) {
+    await queryRunner.run(
+      new QueryBuilder(NotificationSchema)
+      .delete()
+      .where(NotificationSchema.columns.projectId, Operator.OPERATOR_EQUAL, {
+        value: {
+          $case: "intValue",
+          intValue: input.projectId,
+        },
+      })
+      .andWhere(NotificationSchema.columns.externalRefId, Operator.OPERATOR_EQUAL, {
+        value: {
+          $case: "intValue",
+          intValue: input.externalRefId,
+        },
+      })
+      .build()
+    );
+  }
+}
+
+export default new LegacyNotificationDomain();