From a0ebad9a5880e7ab18f2f7a0ef2bbb2020d36bb6 Mon Sep 17 00:00:00 2001
From: Shine Chang <shine00chang@gmail.com>
Date: Fri, 4 Oct 2024 20:33:44 -0700
Subject: [PATCH] (add) polygon upload session

---
 packages/api-server/src/admin.html            | 52 +++++++++++++---
 packages/api-server/src/client.html           | 29 ++++++---
 .../api-server/src/routes/v1/domain.routes.ts | 26 +++++++-
 .../src/services/problem.services.ts          |  6 +-
 .../src/services/testcase.services.ts         | 10 +++-
 .../src/connections/mongodb.connections.ts    |  8 +--
 packages/types/src/types/problem.types.ts     |  5 +-
 .../src/routes/polygon.routes.ts              | 60 +++++++++++++++++++
 .../src/routes/testcase.routes.ts             | 32 ----------
 .../src/services/polygon.services.ts          | 28 ++++-----
 .../src/services/testcase.services.ts         | 25 +++++++-
 packages/upload-server/src/start.ts           |  2 +
 12 files changed, 204 insertions(+), 79 deletions(-)
 create mode 100644 packages/upload-server/src/routes/polygon.routes.ts

diff --git a/packages/api-server/src/admin.html b/packages/api-server/src/admin.html
index 7e6e5130..134ed577 100644
--- a/packages/api-server/src/admin.html
+++ b/packages/api-server/src/admin.html
@@ -84,6 +84,8 @@ <h2>Problems</h2>
 <input type="text" id="problem-input" placeholder="input"><br>
 <input type="text" id="problem-output" placeholder="output"><br>
 <button id='problem-add'>add</button> <br>
+<button id='problem-polygon'>polygon add</button> (zipped package)
+<input type="file" id="problem-polygon-input"> <br>
 <button id='problem-get'>get</button> <br>
 
 <div id='problem-list'>
@@ -129,7 +131,7 @@ <h2>Testcases</h2>
 </div>
 
 <script>
-  const uploadURL = 'http://13.93.218.61:8001';
+  const uploadURL = 'http://localhost:8001';
 
   let getUserId = _ => undefined;
 
@@ -300,24 +302,56 @@ <h2>Testcases</h2>
       .catch(console.error);
   }
 
+  document.getElementById('problem-polygon').onclick = async _ => {
+
+    console.log('problem-polygon');
+
+    if (getDomainId() === undefined) return alert('no domain selected');
+    
+    if (!document.getElementById('problem-polygon-input').files[0])
+      return alert('no polygon file selected');
+
+    const { uploadId } = await betterFetch(`/v1/domains/${getDomainId()}/problems/polygon-upload-session`);
+
+    const formData = new FormData();
+    formData.append('package', document.getElementById('problem-polygon-input').files[0]);
+
+    const res = await betterFetch(uploadURL + `/polygon/${uploadId}`, {
+      method: "POST",
+      body: formData 
+    })
+      .then(res => alert('package uploaded'))
+  }
+
   document.getElementById('problem-get').onclick = async _ => {
 
     console.log('problem-get');
 
     if (getDomainId() === undefined) return alert('no domain selected');
 
-    const res = await betterFetch(`/v1/domains/${getDomainId()}/problems/`)
+    const problems = await betterFetch(`/v1/domains/${getDomainId()}/problems/`)
 
     let html = '';
-    for (const { name, id } of res) {
-      html += `
-      <div>
-      <input type='radio' name='problem-radio' value='${id}'>
-      <label for='${id}'><b>${name}</b>: (<i>${id}</i>)</label>
+    for (const { name, id, context, inputFormat, outputFormat, constraints } of problems) {
+
+      const problemHTML = `
+      ${constraints.time}ms <br>
+      ${constraints.memory}MB <br>
+      <hr>
+      ${context}<br>
+      ${inputFormat}<br>
+      ${outputFormat}<br>
+      <hr>`;
+      html += ` 
+      <details>
+        <summary>
+          <input type='radio' name='problem-radio' value='${id}'>
+          <label for='${id}'><b>${name}</b> (<i>${id}</i>)</label>
+        </summary>
+        ${problemHTML}
       </div>`
     }
-
-    document.getElementById('problem-list').innerHTML = html;
+   document.getElementById('problem-list').innerHTML = html;
   }
 
   document.getElementById('series-add').onclick = async _ => {
diff --git a/packages/api-server/src/client.html b/packages/api-server/src/client.html
index 2038087f..a2c648fe 100644
--- a/packages/api-server/src/client.html
+++ b/packages/api-server/src/client.html
@@ -5,6 +5,7 @@
       margin:40px auto;max-width:700px;line-height:1.6;font-size:18px;color:#444;padding:0 10px;
       font-family: 'Poppins';
     }
+    b{font-weight: 900}
     h1,h2,h3{line-height:1.2}
     input,div,button { margin: 0.2rem }
     input {
@@ -32,7 +33,6 @@
       cursor: pointer;
       padding: 5px 16px;
       font-size: 14px;
-      font-weight: 500;
       line-height: 20px;
       vertical-align: middle;
       border: 1px solid;
@@ -261,17 +261,28 @@ <h2>Ranklist</h2>
 
     if (getContestId() === undefined) return alert('no contest selected');
     
-    const res = await betterFetch(`/v1/contests/${getContestId()}/problems/`)
-
-    if (res.error)
-      return console.error(res.message);
+    const { problems } = await betterFetch(`/v1/contests/${getContestId()}/problems/`)
 
     let html = '';
-    for (const { name, id } of res.problems) {
+    for (const { name, id } of problems) {
+
+      const problem = await betterFetch(`/v1/contests/${getContestId()}/problems/${id}`);
+
+      const problemHTML = `
+      ${problem.constraints.time}ms <br>
+      ${problem.constraints.memory}MB <br>
+      <hr>
+      ${problem.context}<br>
+      ${problem.inputFormat}<br>
+      ${problem.outputFormat}<br>
+      <hr>`;
       html += ` 
-      <div>
-      <input type='radio' name='problem-radio' value='${id}'>
-      <label for='${id}'><b>${name}</b> (<i>${id}</i>)</label>
+      <details>
+        <summary>
+          <input type='radio' name='problem-radio' value='${id}'>
+          <label for='${id}'><b>${name}</b> (<i>${id}</i>)</label>
+        </summary>
+        ${problemHTML}
       </div>`
     }
 
diff --git a/packages/api-server/src/routes/v1/domain.routes.ts b/packages/api-server/src/routes/v1/domain.routes.ts
index 842671a2..80417f43 100644
--- a/packages/api-server/src/routes/v1/domain.routes.ts
+++ b/packages/api-server/src/routes/v1/domain.routes.ts
@@ -25,7 +25,7 @@ import { type FastifyTypeBox } from '../../types.js'
 import { createDomainProblem, deleteDomainProblem, fetchDomainProblems, updateDomainProblem } from '../../services/problem.services.js'
 import { fetchDomainProblem } from '@argoncs/common'
 import { createTestingSubmission } from '../../services/submission.services.js'
-import { createUploadSession } from '../../services/testcase.services.js'
+import { createPolygonUploadSession, createUploadSession } from '../../services/testcase.services.js'
 import { UnauthorizedError, badRequestSchema, forbiddenSchema, methodNotAllowedSchema, notFoundSchema, unauthorizedSchema } from 'http-errors-enhanced'
 import { createContest, createContestSeries, fetchDomainContestSeries, fetchDomainContests } from '../../services/contest.services.js'
 import { userAuthHook } from '../../hooks/authentication.hooks.js'
@@ -309,6 +309,30 @@ async function domainProblemRoutes (problemRoutes: FastifyTypeBox): Promise<void
       await reply.status(200).send({ uploadId })
     }
   )
+
+  problemRoutes.get(
+    '/polygon-upload-session',
+    {
+      schema: {
+        response: {
+          200: Type.Object({ uploadId: Type.String() }),
+          400: badRequestSchema,
+          401: unauthorizedSchema,
+          403: forbiddenSchema,
+          404: notFoundSchema
+        },
+        params: Type.Object({ domainId: Type.String() })
+      },
+      onRequest: [userAuthHook, problemRoutes.auth([
+        [hasDomainPrivilege(['problem.manage'])]
+      ]) as any]
+    },
+    async (request, reply) => {
+      const { domainId } = request.params
+      const { uploadId } = await createPolygonUploadSession({ domainId })
+      await reply.status(200).send({ uploadId })
+    }
+  )
 }
 
 async function domainContestRoutes (contestRoutes: FastifyTypeBox): Promise<void> {
diff --git a/packages/api-server/src/services/problem.services.ts b/packages/api-server/src/services/problem.services.ts
index e04f229f..66fffc3c 100644
--- a/packages/api-server/src/services/problem.services.ts
+++ b/packages/api-server/src/services/problem.services.ts
@@ -1,9 +1,9 @@
 import {
   type NewProblem,
   type Problem
-} from '@argoncs/types'
+} from '@argoncs/types' /*=*/
 import { NotFoundError } from 'http-errors-enhanced'
-import { mongoClient, domainProblemCollection, submissionCollection, testcaseUploadCollection } from '@argoncs/common'
+import { mongoClient, domainProblemCollection, submissionCollection, uploadSessionCollection } from '@argoncs/common'
 import { testcaseExists } from './testcase.services.js'
 
 import { nanoid } from 'nanoid'
@@ -43,7 +43,7 @@ export async function deleteDomainProblem ({ problemId, domainId }: { problemId:
         throw new NotFoundError('Problem not found')
       }
 
-      await testcaseUploadCollection.deleteMany({ problemId })
+      await uploadSessionCollection.deleteMany({ problemId })
       await submissionCollection.deleteMany({ problemId })
     })
   } finally {
diff --git a/packages/api-server/src/services/testcase.services.ts b/packages/api-server/src/services/testcase.services.ts
index bfc6be6d..b5a80598 100644
--- a/packages/api-server/src/services/testcase.services.ts
+++ b/packages/api-server/src/services/testcase.services.ts
@@ -1,5 +1,5 @@
 import { NotFoundError } from 'http-errors-enhanced'
-import { fetchDomainProblem, minio, testcaseUploadCollection } from '@argoncs/common'
+import { fetchDomainProblem, minio, uploadSessionCollection } from '@argoncs/common'
 
 import path = require('node:path')
 import { nanoid } from 'nanoid'
@@ -20,6 +20,12 @@ export async function testcaseExists ({ problemId, domainId, filename, versionId
 export async function createUploadSession ({ problemId, domainId }: { problemId: string, domainId: string }): Promise<{ uploadId: string }> {
   const id = nanoid(32)
   await fetchDomainProblem({ problemId, domainId }) // Could throw not found
-  await testcaseUploadCollection.insertOne({ id, problemId, domainId, createdAt: (new Date()).getTime() })
+  await uploadSessionCollection.insertOne({ id, problemId, domainId, createdAt: (new Date()).getTime() })
+  return { uploadId: id }
+}
+
+export async function createPolygonUploadSession ({ domainId }: { domainId: string }): Promise<{ uploadId: string }> {
+  const id = nanoid(32)
+  await uploadSessionCollection.insertOne({ id, domainId, polygon: true, createdAt: (new Date()).getTime() })
   return { uploadId: id }
 }
diff --git a/packages/common/src/connections/mongodb.connections.ts b/packages/common/src/connections/mongodb.connections.ts
index 0b41a491..5d82d8f5 100644
--- a/packages/common/src/connections/mongodb.connections.ts
+++ b/packages/common/src/connections/mongodb.connections.ts
@@ -1,4 +1,4 @@
-import { type ConetstProblemList, type Contest, type ContestProblem, type Submission, type Domain, type EmailVerification, type Problem, type Team, type TeamInvitation, type TestcaseUpload, type User, type UserPrivateSession, type TeamScore, type ContestSeries } from '@argoncs/types'
+import { type ConetstProblemList, type Contest, type ContestProblem, type Submission, type Domain, type EmailVerification, type Problem, type Team, type TeamInvitation, type User, type UserPrivateSession, type TeamScore, type ContestSeries, type UploadSession } from '@argoncs/types'
 import { MongoClient, type IndexSpecification, type CreateIndexesOptions, type Db, type Collection } from 'mongodb'
 
 interface Index {
@@ -59,7 +59,7 @@ const collections: CollectionIndex[] = [
     ]
   },
   {
-    name: 'testcaseUploads',
+    name: 'uploadSessions',
     indexes: [
       { keys: { id: 1 }, options: { unique: true } },
       { keys: { problemId: 1 } },
@@ -125,7 +125,7 @@ export let domainProblemCollection: Collection<Problem>
 export let submissionCollection: Collection<Submission>
 export let sessionCollection: Collection<UserPrivateSession>
 export let emailVerificationCollection: Collection<EmailVerification>
-export let testcaseUploadCollection: Collection<TestcaseUpload>
+export let uploadSessionCollection: Collection<UploadSession>
 export let contestCollection: Collection<Contest>
 export let teamCollection: Collection<Team>
 export let teamInvitationCollection: Collection<TeamInvitation>
@@ -156,7 +156,7 @@ export async function connectMongoDB (url: string): Promise<void> {
 
   submissionCollection = mongoDB.collection('submissions')
 
-  testcaseUploadCollection = mongoDB.collection('testcaseUploads')
+  uploadSessionCollection = mongoDB.collection('uploadSessions')
 
   contestCollection = mongoDB.collection('contests')
   contestProblemCollection = mongoDB.collection('contestProblems')
diff --git a/packages/types/src/types/problem.types.ts b/packages/types/src/types/problem.types.ts
index 24584fe6..0e25ba0d 100644
--- a/packages/types/src/types/problem.types.ts
+++ b/packages/types/src/types/problem.types.ts
@@ -47,9 +47,10 @@ export type Problem = Static<typeof ProblemSchema>
 export const ContestProblemSchema = Type.Intersect([ProblemSchema, Type.Object({ contestId: Type.String(), obsolete: Type.Boolean() })])
 export type ContestProblem = Static<typeof ContestProblemSchema>
 
-export interface TestcaseUpload {
+export interface UploadSession {
   id: string
-  problemId: string
+  problemId?: string
+  polygon?: boolean
   domainId: string
   createdAt: number
 }
diff --git a/packages/upload-server/src/routes/polygon.routes.ts b/packages/upload-server/src/routes/polygon.routes.ts
new file mode 100644
index 00000000..0d64e549
--- /dev/null
+++ b/packages/upload-server/src/routes/polygon.routes.ts
@@ -0,0 +1,60 @@
+import { consumePolygonUploadSession, consumeUploadSession, uploadTestcase } from '../services/testcase.services.js'
+import { uploadPolygon } from '../services/polygon.services.js'
+
+import { Type } from '@sinclair/typebox'
+import multipart, { type MultipartFile } from '@fastify/multipart'
+import { type FastifyTypeBox } from '../types.js' /*=*/
+import { BadRequestError, badRequestSchema, PayloadTooLargeError, unauthorizedSchema } from 'http-errors-enhanced'
+
+export async function polygonRoutes (routes: FastifyTypeBox): Promise<void> {
+  await routes.register(multipart.default, {
+    limits: {
+      fileSize: 20971520,
+      files: 1
+    }
+  })
+
+  /**
+   * Uploads a zipped Polygon package.
+   * Unzips and parses the package, and update the problem.
+   */
+  routes.post(
+    '/:uploadId',
+    {
+      schema: {
+        params: Type.Object({ uploadId: Type.String() }),
+        response: {
+          201: Type.Object({ problemId: Type.String() }),
+          400: badRequestSchema,
+          401: unauthorizedSchema,
+          413: Type.Object({ statusCode: Type.Number(), error: Type.String(), message: Type.String() })
+        }
+      }
+    },
+    async (request, reply) => {
+      const { uploadId } = request.params
+      const { domainId } = await consumePolygonUploadSession(uploadId)
+
+      try {
+        const archive: MultipartFile | undefined = await request.file()
+        if (archive === undefined) {
+          throw new BadRequestError('No file found in request')
+        }
+
+        const problemId = await uploadPolygon({ domainId, archive })
+
+        return await reply.status(201).send({ problemId })
+      } catch (err) {
+        if (err instanceof routes.multipartErrors.InvalidMultipartContentTypeError) {
+          throw new BadRequestError('Request must be multipart')
+        } else if (err instanceof routes.multipartErrors.FilesLimitError) {
+          throw new PayloadTooLargeError('Too many files in one request')
+        } else if (err instanceof routes.multipartErrors.RequestFileTooLargeError) {
+          throw new PayloadTooLargeError('Testcase too large to be processed')
+        } else {
+          throw err
+        }
+      }
+    }
+  )
+}
diff --git a/packages/upload-server/src/routes/testcase.routes.ts b/packages/upload-server/src/routes/testcase.routes.ts
index 8122f225..9c727efc 100644
--- a/packages/upload-server/src/routes/testcase.routes.ts
+++ b/packages/upload-server/src/routes/testcase.routes.ts
@@ -54,36 +54,4 @@ export async function testcaseRoutes (routes: FastifyTypeBox): Promise<void> {
       }
     }
   )
-
-  /**
-   * Uploads a zipped Polygon package.
-   * Unzips and parses the package, and update the problem.
-   */
-  routes.post(
-    '/:uploadId/polygon',
-    {
-      schema: {
-        params: Type.Object({ uploadId: Type.String() }),
-        response: {
-          201: Type.Object({ problemId: Type.String() }),
-          400: badRequestSchema,
-          401: unauthorizedSchema,
-          413: Type.Object({ statusCode: Type.Number(), error: Type.String(), message: Type.String() })
-        }
-      }
-    },
-    async (request, reply) => {
-      const { uploadId } = request.params
-      const { domainId, problemId } = await consumeUploadSession(uploadId)
-
-      const archive = await request.file()
-      if (archive === undefined) {
-        throw new BadRequestError('No file found in request')
-      }
-
-      await uploadPolygon(domainId, problemId, archive)
-
-      return await reply.status(201).send({ problemId })
-    }
-  )
 }
diff --git a/packages/upload-server/src/services/polygon.services.ts b/packages/upload-server/src/services/polygon.services.ts
index 3e40ee65..29232d56 100644
--- a/packages/upload-server/src/services/polygon.services.ts
+++ b/packages/upload-server/src/services/polygon.services.ts
@@ -1,6 +1,6 @@
 import { uploadFile } from './testcase.services.js'
 import { nanoid } from 'nanoid'
-import { type Constraints, type NewProblem } from '@argoncs/types'
+import { Problem, type Constraints, type NewProblem } from '@argoncs/types'
 import { type MultipartFile } from '@fastify/multipart'
 import { exec as exec_sync } from 'node:child_process'
 import { promisify } from 'node:util'
@@ -12,13 +12,10 @@ import { domainProblemCollection } from '@argoncs/common'
 const exec = promisify(exec_sync)
 
 /* Extracts content from polygon package archive, updates problem data, and uploads testcases */
-export async function uploadPolygon (
-  domainId: string,
-  problemId: string,
-  archive: MultipartFile
-): Promise<void> {
+export async function uploadPolygon ({ domainId, archive }: { domainId: string, archive: MultipartFile}): Promise<string> {
+
   // Make working directory
-  const work_path = path.join(process.cwd(), `temp-${await nanoid()}`)
+  const work_path = path.join(process.cwd(), `temp-${nanoid()}`)
   await fs.mkdir(work_path)
 
   // Copy archive into directory
@@ -30,7 +27,7 @@ export async function uploadPolygon (
 
   if (stderr) {
     console.log(stderr)
-    throw new BadRequestError('Couldnot unzip package archive')
+    throw new BadRequestError('Could not unzip package archive')
   }
   console.log(`== Finished Unzipping. ${archive_path} => ${work_path}`)
 
@@ -49,7 +46,9 @@ export async function uploadPolygon (
   const context = statement.legend + '\n\n' + statement.notes
 
   // Create Problem
-  const problem: NewProblem = {
+  const problem: Problem = {
+    id: nanoid(),
+    domainId,
     name: statement.name,
     context,
     inputFormat: statement.input,
@@ -71,8 +70,8 @@ export async function uploadPolygon (
     const input_file = await fs.open(path.join(work_path, 'tests', name))
     const output_file = await fs.open(path.join(work_path, 'tests', name + '.a'))
 
-    const input = await uploadFile(domainId, problemId, name, input_file.createReadStream())
-    const output = await uploadFile(domainId, problemId, name + '-ans', output_file.createReadStream())
+    const input = await uploadFile(domainId, problem.id, name, input_file.createReadStream())
+    const output = await uploadFile(domainId, problem.id, name + '-ans', output_file.createReadStream())
 
     problem.testcases.push({
       input,
@@ -80,13 +79,14 @@ export async function uploadPolygon (
       points: 100 / test_n
     })
   }
+  /* Cleanup working directory */
+  await exec(`rm -rf ${work_path}`)
 
   console.log('problem: ', problem)
 
   // Update problem
   // Assuming the token is correct, the problem must exist.
-  await domainProblemCollection.updateOne({ id: problemId, domainId }, { $set: problem })
+  await domainProblemCollection.insertOne(problem)
 
-  /* Cleanup working directory */
-  await exec(`rm -rf ${work_path}`)
+  return problem.id
 }
diff --git a/packages/upload-server/src/services/testcase.services.ts b/packages/upload-server/src/services/testcase.services.ts
index 2b365c71..ced5a95a 100644
--- a/packages/upload-server/src/services/testcase.services.ts
+++ b/packages/upload-server/src/services/testcase.services.ts
@@ -1,6 +1,6 @@
-import { minio, testcaseUploadCollection } from '@argoncs/common'
+import { minio, uploadSessionCollection } from '@argoncs/common'
 import { type MultipartFile } from '@fastify/multipart'
-import { UnauthorizedError } from 'http-errors-enhanced'
+import { BadRequestError, UnauthorizedError } from 'http-errors-enhanced'
 import path from 'node:path'
 import type internal from 'node:stream'
 
@@ -32,9 +32,28 @@ export async function uploadFile (
 
 /* Consumes an upload session, returns the domain and problem authorized */
 export async function consumeUploadSession (uploadId: string): Promise<{ domainId: string, problemId: string }> {
-  const upload = await testcaseUploadCollection.findOneAndDelete({ id: uploadId })
+  const upload = await uploadSessionCollection.findOneAndDelete({ id: uploadId })
   if (upload == null) {
     throw new UnauthorizedError('Invalid upload session token')
   }
+  const { domainId, problemId } = upload;
+  if (!problemId) {
+    if (upload.polygon) 
+      throw new BadRequestError('Upload session created for Polygon upload, not testcase upload.')
+    else 
+      throw new BadRequestError('Testcase upload session does not have problemId.')
+  }
+  return { domainId, problemId } 
+}
+
+/* Consumes an upload session, returns the domain and problem authorized */
+export async function consumePolygonUploadSession (uploadId: string): Promise<{ domainId: string }> {
+  const upload = await uploadSessionCollection.findOneAndDelete({ id: uploadId })
+  if (upload == null) {
+    throw new UnauthorizedError('Invalid upload session token')
+  }
+  if (upload.problemId && !upload.polygon) {
+    throw new BadRequestError('Upload session created for testcase upload, not Polygon upload.')
+  }
   return upload
 }
diff --git a/packages/upload-server/src/start.ts b/packages/upload-server/src/start.ts
index 9fc6a000..2ad50edf 100644
--- a/packages/upload-server/src/start.ts
+++ b/packages/upload-server/src/start.ts
@@ -11,6 +11,7 @@ import { connectMinIO, connectMongoDB, sentry } from '@argoncs/common'
 
 import fastifySensible from '@fastify/sensible'
 import assert from 'assert'
+import { polygonRoutes } from './routes/polygon.routes.js'
 
 const app = fastify({
   logger: {
@@ -48,6 +49,7 @@ export async function startUploadServer (): Promise<void> {
     credentials: true
   })
 
+  await app.register(polygonRoutes, { prefix: '/polygon' })
   await app.register(testcaseRoutes, { prefix: '/testcases' })
   await app.register(heartbeatRoutes, { prefix: '/heartbeat' })