88 add user page

README.md

@@ -55,4 +55,10 @@ Check out our [Next.js deployment documentation](https://nextjs.org/docs/deploym
 
 ![Problems num page 2](docs/images/page-problems-num.png)
 
+### Username page (`/users/[username]`)
+![Username page 1](docs/images/page-users-username-loading.png)
+
+![Username page 2](docs/images/page-users-username.png)
+
+
 </details>

src/app/api/submissions/language/[problemNum]/route.tsx

@@ -6,7 +6,7 @@ import {
   uhuntProblemNumUrl,
   uhuntProblemSubmissionListUrl,
 } from "@/utils/constants";
-import { Language, Problem, Submission } from "@/types";
+import { Language, Problem, Submission, SubmissionLangType } from "@/types";
 
 type getParamsType = {
   params: z.infer<typeof schema>;
@@ -64,13 +64,22 @@ export const GET = async (_request: Request, { params }: getParamsType) => {
   );
 
   // increment count of key-value for their respective language ID
-  const responseData: getResponseType = submissionData.reduce((acc, cur) => {
+  const reducedData: Record<string, number> = submissionData.reduce((acc, cur) => {
     const languageId = cur.lan;
     acc[languageId] = acc[languageId] + 1;
 
     return acc;
   }, languageObj);
-  delete responseData["undefined"];
+  delete reducedData["undefined"];
+
+  const processedData: SubmissionLangType[] = Object.entries(reducedData).map(
+    ([key, value]) => {
+      return {
+        language: Language[key],
+        count: value,
+      };
+    },
+  );
 
-  return Response.json(responseData);
+  return Response.json(processedData);
 };

src/app/api/submissions/overtime/[problemNum]/route.ts

@@ -3,20 +3,13 @@ import { z } from "zod";
 import { submissionOvertimeSchema as schema } from "@/schema";
 import { NextResponse } from "next/server";
 import { uhuntProblemNumUrl, uhuntSubmissionCountUrl } from "@/utils/constants";
-import { Problem } from "@/types";
+import { Problem, SubmissionsOvertimeLineChartType } from "@/types";
 import moment, { Moment } from "moment";
 
 type getParamsType = {
   params: z.infer<typeof schema>;
 };
 
-export type getResponseType = {
-  name: string;
-  time: string; // time formatted to year
-  submissions: number;
-  fill: string;
-}
-
 /**
  * Get the submission count of a problem using `problem number`
  * The submission count will be a cumulative submission count
@@ -75,7 +68,7 @@ export const GET = async (_request: Request, { params }: getParamsType) => {
   //     12 : Number of months each array element will represent
   const submissionUrlSplit = submssionCountUrl.split("/");
   const thirtyDaysInSeconds = 60 * 60 * 24 * 30;
-  const responseData:getResponseType[] = data.map((cur, i) => {
+  const responseData:SubmissionsOvertimeLineChartType[] = data.map((cur, i) => {
     const submissionTime = +submissionUrlSplit[7];
     const back = +submissionUrlSplit[8];
     const jump = +submissionUrlSplit[9];

src/app/api/users/[username]/submissions/attempted/route.ts

@@ -0,0 +1,94 @@
+
+import { z } from "zod";
+
+import { NextResponse } from "next/server";
+
+import { userSchema as schema } from "@/schema";
+import {
+  Language,
+  ProblemVerdictMap,
+  SubmissionLangType,
+  SubmissionsOvertimeLineChartType,
+  SubmissionSovledVsAttempted
+} from "@/types";
+import { RawUserSubmission } from "@/types/raw";
+import {
+  uhuntUserSubmissionsUrl,
+  uhuntUsername2UidUrl,
+} from "@/utils/constants";
+import moment from "moment";
+
+type getParamsType = {
+  params: z.infer<typeof schema>;
+};
+
+export const GET = async (_request: Request, {params}: getParamsType) => {
+  // validate params
+  const schemaResponse = await schema.safeParseAsync(params);
+  if (!schemaResponse.success) {
+    const message = {
+      message: schemaResponse.error.issues[0].message,
+    };
+
+    return NextResponse.json(message, {
+      status: 400,
+    });
+  }
+
+  //----------------------------------------------------------------------------------------------//
+
+  // fetch username ID
+  const { username } = params;
+
+  const usernameUrl = uhuntUsername2UidUrl(username);
+  const usernameResponse = await fetch(usernameUrl);
+  const usernameData: number = await usernameResponse.json();
+
+  // return 404 if problem doesn't exist
+  if (usernameData === 0) {
+    const message = {
+      message: `Username ${username} not found`,
+    };
+    return NextResponse.json(message, {
+      status: 404,
+    });
+  }
+
+  //----------------------------------------------------------------------------------------------//
+  // fetch submissions of the user
+  const userSubmissionsUrl = uhuntUserSubmissionsUrl(usernameData);
+  const userSubmissionResponse = await fetch(userSubmissionsUrl, {
+    cache: "no-cache",
+  });
+  const userSubmissionData =
+    (await userSubmissionResponse.json()) as RawUserSubmission;
+
+  // count solved submissions
+  // use a set to keep track of problems solved
+  const set = new Set();
+
+  const verdictSolvedId = 90
+  userSubmissionData.subs.forEach(cur => {
+    // cur[2] : verdict ID
+    if(cur[2] === verdictSolvedId) {
+      set.add(cur[1]) // add problem ID
+    }
+  })
+
+  const processedData: SubmissionSovledVsAttempted[] = [
+    {
+      name: "Solved",
+      count: set.size,
+      tooltipTitle: "Solved unique problems",
+      fill: ProblemVerdictMap.ac.bgHex
+    },
+    {
+      name: "Attempts",
+      count: userSubmissionData.subs.length,
+      tooltipTitle: "Submission attempts",
+      fill: ProblemVerdictMap.inq.bgHex
+    }
+  ]
+
+  return Response.json(processedData)
+}

src/app/api/users/[username]/submissions/language/route.ts

@@ -0,0 +1,90 @@
+import { z } from "zod";
+
+import { NextResponse } from "next/server";
+
+import { userSchema as schema } from "@/schema";
+import { Language, SubmissionLangType } from "@/types";
+import { RawUserSubmission } from "@/types/raw";
+import {
+  uhuntUserSubmissionsUrl,
+  uhuntUsername2UidUrl,
+} from "@/utils/constants";
+
+type getParamsType = {
+  params: z.infer<typeof schema>;
+};
+
+export const GET = async (_request: Request, { params }: getParamsType) => {
+  // validate params
+  const schemaResponse = await schema.safeParseAsync(params);
+  if (!schemaResponse.success) {
+    const message = {
+      message: schemaResponse.error.issues[0].message,
+    };
+
+    return NextResponse.json(message, {
+      status: 400,
+    });
+  }
+
+  //----------------------------------------------------------------------------------------------//
+
+  // fetch username ID
+  const { username } = params;
+
+  const usernameUrl = uhuntUsername2UidUrl(username);
+  const usernameResponse = await fetch(usernameUrl);
+  const usernameData: number = await usernameResponse.json();
+
+  // return 404 if problem doesn't exist
+  if (usernameData === 0) {
+    const message = {
+      message: `Username ${username} not found`,
+    };
+    return NextResponse.json(message, {
+      status: 404,
+    });
+  }
+
+  //----------------------------------------------------------------------------------------------//
+
+  // fetch submissions of the user
+  const userSubmissionsUrl = uhuntUserSubmissionsUrl(usernameData);
+  const userSubmissionResponse = await fetch(userSubmissionsUrl, {
+    cache: "no-cache",
+  });
+  const userSubmissionData =
+    (await userSubmissionResponse.json()) as RawUserSubmission;
+
+  // map language id as key and 0 as value. (the value will be count of a submission language)
+  let languageObj = Object.keys(Language).reduce(
+    (acc: Record<string, number>, cur: string) => {
+      acc[cur] = 0;
+
+      return acc;
+    },
+    {},
+  );
+
+  // count the submissions by language id
+  // object key: language ID
+  // object value: count
+  const reducedData = userSubmissionData.subs.reduce((acc, cur) => {
+    const languageId = cur[5];
+    acc[languageId] = acc[languageId] + 1;
+
+    return acc;
+  }, languageObj);
+  delete reducedData["undefined"];
+
+  const processedData: SubmissionLangType[] = Object.entries(reducedData).map(
+    ([key, value]) => {
+      return {
+        language: Language[key],
+        count: value,
+      };
+    },
+  );
+
+  return Response.json(processedData);
+};

src/app/api/users/[username]/submissions/overtime/route.ts

@@ -0,0 +1,117 @@
+import { z } from "zod";
+
+import { NextResponse } from "next/server";
+
+import { userSchema as schema } from "@/schema";
+import {
+  Language,
+  SubmissionLangType,
+  SubmissionsOvertimeLineChartType,
+} from "@/types";
+import { RawUserSubmission } from "@/types/raw";
+import {
+  uhuntUserSubmissionsUrl,
+  uhuntUsername2UidUrl,
+} from "@/utils/constants";
+import moment from "moment";
+
+type getParamsType = {
+  params: z.infer<typeof schema>;
+};
+
+export const GET = async (_request: Request, { params }: getParamsType) => {
+  // validate params
+  const schemaResponse = await schema.safeParseAsync(params);
+  if (!schemaResponse.success) {
+    const message = {
+      message: schemaResponse.error.issues[0].message,
+    };
+
+    return NextResponse.json(message, {
+      status: 400,
+    });
+  }
+
+  //----------------------------------------------------------------------------------------------//
+
+  // fetch username ID
+  const { username } = params;
+
+  const usernameUrl = uhuntUsername2UidUrl(username);
+  const usernameResponse = await fetch(usernameUrl);
+  const usernameData: number = await usernameResponse.json();
+
+  // return 404 if problem doesn't exist
+  if (usernameData === 0) {
+    const message = {
+      message: `Username ${username} not found`,
+    };
+    return NextResponse.json(message, {
+      status: 404,
+    });
+  }
+
+  //----------------------------------------------------------------------------------------------//
+  // fetch submissions of the user
+  const userSubmissionsUrl = uhuntUserSubmissionsUrl(usernameData);
+  const userSubmissionResponse = await fetch(userSubmissionsUrl, {
+    cache: "no-cache",
+  });
+  const userSubmissionData =
+    (await userSubmissionResponse.json()) as RawUserSubmission;
+
+  // count submissions by year
+  const initData: Record<string, number> = {};
+  let reducedData = userSubmissionData.subs.reduce((obj, cur, index) => {
+    const year = moment.unix(cur[4]).format("YYYY");
+    obj[year] = obj[year] + 1 || 1;
+
+    return obj;
+  }, initData);
+
+  // add missing years
+  // - loop through the array starting from index 1 going upto last array element
+  //   - convert processedData into an array using Object.entries
+  //     - sort the array
+  //   - get the current element and previous element
+  //   - loop through the difference between curYear and prevYear
+  //     - add entry to `processedData`
+  for (let i = 1; i < Object.entries(reducedData).length; i++) {
+    const sorted = Object.entries(reducedData).sort((a, b) => +a[0] - +b[0]);
+    const curYear = +sorted[i][0];
+    const prevYear = +sorted[i - 1][0];
+
+    // if (curYear - prevYear > 1) {
+    for (let k = prevYear + 1; k < curYear; k++) {
+      reducedData[k] = 0;
+    }
+    // }
+  }
+
+  // calculate cumulative sum
+  for (let i = 1; i < Object.entries(reducedData).length; i++) {
+    const sorted = Object.entries(reducedData).sort((a, b) => +a[0] - +b[0]);
+    const [curYear, curYearCount] = sorted[i];
+    const [prevYear, prevYearCount] = sorted[i - 1];
+
+    reducedData[curYear] = curYearCount + prevYearCount;
+  }
+
+  // construct data structure for Rechart area/line chart
+  const initProcessedData: SubmissionsOvertimeLineChartType[] = [];
+  const processedData: SubmissionsOvertimeLineChartType[] = Object.entries(
+    reducedData,
+  ).reduce((obj, cur, index) => {
+    const [year, count] = cur;
+    obj.push({
+      name: "submissions",
+      time: year,
+      submissions: count,
+      fill: "#8884d8",
+    });
+
+    return obj;
+  }, initProcessedData);
+
+  return Response.json(processedData);
+};