Initial start of rewrite.

Author: Blckbrry-Pi

lib/auth/webhookClientAuthPerms.ts

@@ -5,7 +5,7 @@ import { getConfig } from "metadata/server";
 const addClientPerms = async (input: InputAuth): Promise<Auth> => {
     if (input.__type === "oauth") return {
         ...input,
-        trustedClientAuth: (await getConfig()).webhook.clientOauthAllowToken,
+        oauth_allow_token: (await getConfig()).webhook.clientOauthAllowToken,
     };
     else return input;
 };

lib/cache/challs.ts

@@ -32,7 +32,9 @@ export interface CachedChall {
 export const CHALLENGE_HASH_KEY = "chall";
 
 export const parseChallenge = (challJson: string): CachedChall | null => {
+    console.log("tp0");
     const parsed: unknown = JSON.parse(challJson);
+    console.log(parsed);
 
     if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return null;
 
@@ -48,11 +50,14 @@ export const parseChallenge = (challJson: string): CachedChall | null => {
         if (!vis || !chall) return null;
     }
 
+    console.log("tp1");
+
     const challId = challIdFromStr(challRaw);
     if (!challId) return null;
 
     if (typeof csmRaw !== 'object' || csmRaw === null) return null;
 
+    console.log("tp2");
 
     const {
         name: nameRaw,
@@ -83,6 +88,9 @@ export const parseChallenge = (challJson: string): CachedChall | null => {
             !hint    || !tag
         ) return null;
     }
+
+    console.log("tp3");
+
     {
         const cats = catRaw.every((s) => typeof s === 'string');
         const auths = authRaw.every((s) => typeof s === 'string');
@@ -92,6 +100,8 @@ export const parseChallenge = (challJson: string): CachedChall | null => {
         if (!cats || !auths || !hints || !tags) return null;
         if (typeof linksRaw !== 'object' || linksRaw === null) return null;
     }
+    console.log("tp4");
+
     const { web, nc, admin, static: staticLinks } = linksRaw as Record<string, unknown>;
     {
         const webArr = Array.isArray(web);
@@ -108,6 +118,7 @@ export const parseChallenge = (challJson: string): CachedChall | null => {
 
         if (!webValid || !ncValid || !adminValid || !staticValid) return null;
     }
+    
     const links = { nc, web, admin, static: staticLinks };
 
     const visible = visRaw;
@@ -125,6 +136,8 @@ export const parseChallenge = (challJson: string): CachedChall | null => {
         name, points, desc, solveCount, categories, authors, hints, tags, links, id: challId
     };
 
+    console.log("tp5");
+
     return { visible, id: challId, clientSideMetadata };
 }
 

lib/cache/teams.ts

@@ -97,22 +97,23 @@ export const removeStale = async (notStale: TeamId[]): Promise<TeamId[]> => {
     return removeIds.map(teamIdFromStr).flatMap(id => id ? [id] : []);
 };
 
-// export const sortBy = (teams: CachedTeamMeta[]) => [...teams].sort((a, b) => a.score - b.score);
+
+
 
 export enum SortingCriteria {
-    POINTS,
+    POINTS_HIGH_FIRST,
     LASTSOLVE_REV,
     NAME,
     ELIG,
 }
 
-const { POINTS, LASTSOLVE_REV, NAME, ELIG } = SortingCriteria;
+const { POINTS_HIGH_FIRST, LASTSOLVE_REV, NAME, ELIG } = SortingCriteria;
 
 
 const compareCriteria = (a: CachedTeamMeta, b: CachedTeamMeta, criteria: SortingCriteria) => {
     switch (criteria) {
-        case POINTS:
-            return a.score - b.score;
+        case POINTS_HIGH_FIRST:
+            return b.score - a.score;
         case LASTSOLVE_REV:
             return (b.lastSolve ?? -1) - (a.lastSolve ?? -1);
         case NAME:
@@ -123,7 +124,7 @@ const compareCriteria = (a: CachedTeamMeta, b: CachedTeamMeta, criteria: Sorting
 }
 
 
-export const sortBy = (challs: CachedTeamMeta[], criteria: SortingCriteria[] = [POINTS, LASTSOLVE_REV, NAME, ELIG]) => {
+export const sortBy = (challs: CachedTeamMeta[], criteria: SortingCriteria[] = [POINTS_HIGH_FIRST, LASTSOLVE_REV, NAME, ELIG]) => {
     const compareFn = (a: CachedTeamMeta, b: CachedTeamMeta) => criteria
         .map(c => compareCriteria(a, b, c))
         .find(v => v !== 0) ?? 0;

lib/components/challenges/drop/parts/ChallDropBody.tsx

@@ -2,20 +2,15 @@
 import ReactMarkdown from "react-markdown";
 
 // Hooks
-
+import { useState } from "react"
 
 // Types
-
 import React, { CSSProperties, FC } from "react"
-
-
-// Styles
 import { ChallDropProps } from "./ChallDrop";
-
+import ChallDropFlagInput from "./ChallDropFlagInput";
 
 // Utils
 import remarkGfm from "remark-gfm";
-import ChallDropFlagInput from "./ChallDropFlagInput";
 
 
 const ListItem = ({ item, className, style }: { item: string, style?: CSSProperties, className?: string }) => (
@@ -39,10 +34,21 @@ const EnglishList = ({ items: list, style, className }: { items: string[], style
     </>;
 }
 
+const Hint = ({ value }: { value: string }) => {
+    const [revealed, setRevealed] = useState(false);
+    return <div
+        className={`
+            block transition-all py-1 px-2 rounded-lg mb-2 select-none 
+            ${revealed ? "text-white bg-slate-800 cursor-default" : "text-transparent bg-slate-900 cursor-pointer"}`}
+        onClick={() => setRevealed(true)}>
+        {value}
+    </div>;
+};
+
 const BodyMeta: FC<Pick<
     ChallDropProps["metadata"],
-    "solveCount" | "categories" | "points" | "tags" | "authors"
->> = ({ solveCount, categories, points, authors }) => (
+    "solveCount" | "categories" | "points" | "tags" | "authors" | "hints"
+>> = ({ solveCount, categories, points, authors, hints }) => (
     <div className="w-full p-5 pt-2 pl-0 ml-auto flex flex-col"
         style={{ gridArea: "meta" }}>
         <div className="py-3">
@@ -53,6 +59,10 @@ const BodyMeta: FC<Pick<
         <span className="py-1.5">
             {solveCount.toLocaleString('en-US', {maximumFractionDigits: 0})} {solveCount === 1 ? "solve" : "solves"}
         </span>
+        <div className="py-3">
+            <h4 className="font-medium text-base mb-1">Hints:</h4>
+            {hints.map(hint => <Hint value={hint} />)}
+        </div>
         <div className="py-1.5 mb-auto">
             By <EnglishList className="font-mono text-chall-author-name-color" items={authors}/>
         </div>
@@ -106,7 +116,7 @@ const Links: FC<{ urls: string[], type: LinkType }> = ({ urls, type }) => {
 };
 
 const ChallDropBody: FC<ChallDropProps & { open: boolean }> = ({
-    metadata: { solveCount, categories, points, tags, desc, links, authors },
+    metadata: { solveCount, categories, points, tags, desc, links, authors, hints },
     solved,
     submission: { challId, userId, teamId }
 }) => (
@@ -139,7 +149,7 @@ const ChallDropBody: FC<ChallDropProps & { open: boolean }> = ({
             </div>
         </div>
 
-        <BodyMeta {...{ solveCount, solved, points, tags, categories, links, authors }}/>
+        <BodyMeta {...{ solveCount, solved, points, tags, categories, links, authors, hints }}/>
 
         <ChallDropFlagInput {...{ challId, teamId, userId }} />
 

lib/components/challenges/drop/parts/ChallDropFlagInput.tsx

@@ -54,8 +54,14 @@ const ChallDropFlagInput: FC<ChallDropFlagInputProps> = ({challId, userId, teamI
                         method: "POST",
                         body: JSON.stringify({ challId, userId, teamId, flag: inputValue }),
                     });
-                    if (res.ok && await res.text() === "true") location.reload();
-                    else alert("Invalid Flag");
+                    if (res.ok) {
+                        if (await res.text() === "failed") {
+                            alert("Incorrect flag. Please try again.");
+                        }
+                        location.reload();
+                    } else {
+                        alert("Server error");
+                    }
                 }
             }}/>
         <div

lib/components/filter-view/FilterView.tsx

@@ -21,12 +21,20 @@ import { FilterStateHook } from "hooks/useFilter";
 
 interface FilterViewProps {
     filterState: FilterStateHook;
-    challs: ClientSideMeta[];
+    challs: (ClientSideMeta & { solved: boolean })[];
 }
 
 const FilterView: FC<FilterViewProps> = ({ filterState, challs }) => {
     const categories = useMemo(
-        () => [...new Set(challs.flatMap(c => c.categories).map(s => s.toLowerCase())).values()].sort(),
+        () => [
+            ...new Set(challs.flatMap(c => c.categories).map(s => s.toLowerCase())).values()
+        ].sort().map(name => [
+            name,
+            challs
+                .filter(c => c.categories.includes(name))
+                .map(c => c.solved)
+                .reduce(([solved, total], challSolved) => [solved + Number(challSolved), total + 1], [0, 0] as [number, number]),
+        ] as [string, [number, number]]),
         [challs],
     );
     const tags = useMemo(

lib/components/filter-view/parts/ChallCheckFilter.tsx

@@ -58,7 +58,7 @@ const CheckBox: FC<CheckBoxProps> = ({ checked, set, label: inner }) => (
 );
 
 interface ChallCheckFilterProps {
-    list: string[];
+    list: ([string, [number, number]] | string)[];
     heading: string;
     has: (item: string) => boolean,
     set: (item: string, value: boolean) => void,
@@ -69,13 +69,17 @@ const ChallCheckFilter: FC<ChallCheckFilterProps> = ({ list, heading, has, set }
     <div className="flex flex-col justify-start items-start w-full">
         <h4 className="border-b border-b-play-selector-line-divider-color w-full mb-4 text-2xl pb-1">{heading}</h4>
         {list.map(
-            (item, idx) => (
-                <CheckBox
+            (input, idx) => typeof input === "string"
+                ? <CheckBox
                     key={idx}
-                    checked={has(item)}
-                    set={v => set(item, v)}
-                    label={item}/>
-            )
+                    checked={has(input)}
+                    set={v => set(input, v)}
+                    label={input}/>
+                : <CheckBox
+                    key={idx}
+                    checked={has(input[0])}
+                    set={v => set(input[0], v)}
+                    label={`${input[0]} (${input[1][0]}/${input[1][1]})`}/>
         )}
     </div>
 );

lib/database/challs.ts

@@ -8,9 +8,9 @@ import { apiLogger } from "logging";
 
 const syncAllChalls = async () => {
     try {
-        const allChalls = await makeWebhookRequest<DbChallengeMeta[]>({
-            section: "challenge",
-            query: { __tag: "get_all" },
+        const allChalls = await makeWebhookRequest("chall_arr", {
+            __type: "chall",
+            query_name: "get_all",
         });
         const challs = allChalls.map(dbToCacheChall).flatMap(c => c ? [c] : []);
         const usedIds = challs.map(c => c.id);
@@ -28,9 +28,10 @@ const syncChall = async ({ id }: { id: ChallId }) => {
     try {
         apiLogger.trace`Runnning syncChall on chall ${id}.`;
 
-        const challData = await makeWebhookRequest<DbChallengeMeta>({
-            section: "challenge",
-            query: { __tag: "get", id: challIdToStr(id), },
+        const challData = await makeWebhookRequest("chall", {
+            __type: "chall",
+            query_name: "get",
+            id: challIdToStr(id),
         });
 
         apiLogger.trace`Challenge identified as ${challData.name}.`;
@@ -47,7 +48,7 @@ const syncChall = async ({ id }: { id: ChallId }) => {
         apiLogger.trace`Adding challenge to redis cache...`;
 
         const cachedChallenge = await updateChall(chall);
-        if (cachedChallenge) apiLogger.error`Replaced chall ${cachedChallenge}`;
+        if (cachedChallenge) apiLogger.warn`Replaced chall ${cachedChallenge}`;
 
         apiLogger.info`${challData.name} sync successful.`;
 

lib/database/makeWebhookReq.ts

@@ -1,24 +1,49 @@
 import { getConfig } from "metadata/server";
 import WebhookDbQuery from "./queries";
+import { DbChallengeMeta, DbTeamMeta, DbUserMeta } from "./db-types";
 
-const makeWebhookDbRequest = async <T>(query: WebhookDbQuery): Promise<T> => {
-    const { webhook: { url: webhookUrl }, frontendAuthToken } = await getConfig();
+type ReturnTypes = {
+    chall: DbChallengeMeta,
+    chall_arr: DbChallengeMeta[],
+
+    team: DbTeamMeta,
+    team_arr: DbTeamMeta[],
 
+    user: DbUserMeta,
+    user_arr: DbUserMeta[],
+
+    availability: boolean,
+    auth_status: boolean,
+};
+
+const makeWebhookDbRequest = async <RetType extends keyof ReturnTypes>(type: RetType, query: WebhookDbQuery): Promise<ReturnTypes[RetType]> => {
+    const { webhook: { url: webhookUrl }, frontendAuthToken } = await getConfig();
     const init: RequestInit = {
         method: "POST",
         headers: {
             "authorization": `Bearer ${frontendAuthToken}`,
             "Content-Type": "application/json",
         },
         body: JSON.stringify({
-            _type: "sqlquery",
-            targets: { sql: query },
+            sql: query,
         }),
     };
     const fetchReturn = await fetch(webhookUrl, init);
-    const jsonVal = await fetchReturn.json();
-    if (fetchReturn.ok) return jsonVal.sql;
-    else throw jsonVal.sql
+    const returnVal = await fetchReturn.text();
+    const jsonVal = (() => {
+        try {
+            return JSON.parse(returnVal)
+        } catch (e) {
+            throw returnVal;
+        }
+    })();
+    
+    if (!fetchReturn.ok) throw jsonVal.sql;
+
+    const { __type, data } = jsonVal.sql;
+    if (__type !== type) throw jsonVal.sql;
+    
+    return data;
 };
 
 export default makeWebhookDbRequest;

lib/database/queries/challs.ts

@@ -1,16 +1,15 @@
 export type GetChallenge = {
-    __tag: "get";
+    query_name: "get";
     id: string;
 };
 export type GetAllChallenges = {
-    __tag: "get_all";
+    query_name: "get_all";
 };
 
 type InnerChallengeQuery = GetChallenge | GetAllChallenges;
 
 type ChallengeQuery = {
-    section: "challenge";
-    query: InnerChallengeQuery;
-};
+    __type: "chall";
+} & InnerChallengeQuery;
 
 export default ChallengeQuery;