Added accessible challenges check

app/challenges-platform/index.ts

@@ -3,6 +3,7 @@ export {
   ParticipantsService,
   ReviewsService,
   SubmissionService,
+  AccessibleChallengesService,
 } from "./services";
 import { Transformer } from "./models";
 import { transformers } from "../../config/challenges-platform/transformers";

app/challenges-platform/services/accessible-challenges-service.ts

@@ -0,0 +1,24 @@
+import { accessibleChallenges } from "../../../db/schema";
+import { Ok, Result } from "ts-results";
+import { eq } from "drizzle-orm";
+import { db } from "../../../db";
+import { Challenge, Participant } from "../models";
+
+export const count = async (
+  challenge: Challenge,
+  participant: Participant,
+): Promise<Result<Number, Error>> => {
+  const accessibleChallengesResult = await db
+    .select({
+      pId: accessibleChallenges.participantId,
+      cId: accessibleChallenges.challengeId,
+    })
+    .from(accessibleChallenges)
+    .where(
+      eq(accessibleChallenges.participantId, participant.id) &&
+        eq(accessibleChallenges.challengeId, challenge.id),
+    )
+    .execute();
+
+  return Ok(accessibleChallengesResult.length);
+};

app/challenges-platform/services/index.ts

@@ -1,3 +1,4 @@
+export * as AccessibleChallengesService from "./accessible-challenges-service";
 export * as ChallengesService from "./challenges-service";
 export * as ParticipantsService from "./participants-service";
 export * as ReviewsService from "./reviews-service";

db/schema.ts

@@ -14,6 +14,14 @@ export const challenges = sqliteTable("challenges", {
   deleted: integer("deleted", { mode: "boolean" }).notNull().default(false),
 });
 
+export const accessibleChallenges = sqliteTable("accessible_challenges", {
+  id: integer("id").primaryKey(),
+  challengeId: integer("challenge_id").references(() => challenges.id),
+  participantId: integer("participant_id").references(() => participants.id),
+  createdAt: text("created_at").default(sql`CURRENT_TIMESTAMP`),
+  updatedAt: text("updated_at").default(sql`CURRENT_TIMESTAMP`),
+});
+
 export const participants = sqliteTable("participants", {
   id: integer("id").primaryKey(),
   uuid: text("uuid").notNull(),

test/challenges-platform/factories/accessible-challenge-factory.ts

@@ -0,0 +1,32 @@
+import { challengeFactory } from "./challenge-factory";
+import { participantFactory } from "./participant-factory";
+import {
+  Challenge,
+  Participant,
+} from "../../../app/challenges-platform/models";
+import { AccessibleChallengesService } from "../../../app/challenges-platform";
+import { db } from "../../../db";
+import { accessibleChallenges } from "../../../db/schema";
+
+export const accessibleChallengeFactory = async ({
+    challenge,
+    participant,
+  }: {
+    challenge?: Challenge;
+    participant?: Participant;
+  } = {}): Promise<Number> => {
+    const c = challenge || (await challengeFactory());
+    const p = participant || (await participantFactory());
+
+    const insertResult = await db
+    .insert(accessibleChallenges)
+    .values({
+      challengeId: c.id,
+      participantId: p.id,
+    })
+    .returning();
+
+    const result = await AccessibleChallengesService.count(c, p);
+    if (!result.ok) fail("Expected result to be Ok");
+    return result.val;
+  };

test/challenges-platform/services/accessible-challenges-service.test.ts

@@ -0,0 +1,36 @@
+import { challengeFactory } from "../factories/challenge-factory";
+import { participantFactory } from "../factories/participant-factory";
+import { accessibleChallengeFactory } from "../factories/accessible-challenge-factory";
+import { AccessibleChallengesService } from "../../../app/challenges-platform";
+
+describe("AccessibleChallengesService", () => {
+  describe("count", () => {
+    describe("when the challenge is not accessible", () => {
+      it("returns 0", async () => {
+        const challenge = await challengeFactory();
+        const participant = await participantFactory();
+
+        const result = await AccessibleChallengesService.count(challenge, participant);
+
+        if (!result.ok) fail("Expected result to be Ok");
+        expect(result.val).toBe(0);
+      });
+    });
+    describe("when the challenge is accessible", () => {
+      it("returns 1", async () => {
+        const challenge = await challengeFactory();
+        const participant = await participantFactory();
+
+        const insert = await accessibleChallengeFactory({
+            challenge,
+            participant
+        });
+
+        const result = await AccessibleChallengesService.count(challenge, participant);
+
+        if (!result.ok) fail("Expected result to be Ok");
+        expect(result.val).toBe(1);
+      });
+    });
+  })
+});