Start admin pages

server/api/admin/answer/[answerId]/review.post.ts

@@ -0,0 +1,67 @@
+import { useValidatedBody, useValidatedParams, z, zh } from 'h3-zod';
+import prisma from '~~/lib/prisma';
+
+export default defineEventHandler(async (event) => {
+  const user = await requireUserSession(event);
+
+  if (user.user.role !== 'ADMIN') {
+    throw createError({ status: 403, statusText: 'Not allowed!' });
+  }
+  const userId = user.user.id;
+  const { answerId } = await useValidatedParams(
+    event,
+    z.object({
+      answerId: zh.numAsString
+    })
+  );
+
+  const answer = await prisma.questAnswer.findUnique({
+    where: {
+      id: answerId,
+      OR: [
+        {
+          quest: {
+            hunt: {
+              creatorId: userId
+            }
+          }
+        },
+        {
+          quest: {
+            hunt: {
+              members: {
+                some: {
+                  memberId: userId
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    select: { id: true }
+  });
+
+  if (!answer) {
+    throw createError({ status: 404, statusText: 'Not found!' });
+  }
+  const { score, review } = await useValidatedBody(
+    event,
+    z.object({
+      score: z.number().min(0).nullable(),
+      review: z.string().max(256).nullable()
+    })
+  );
+
+  await prisma.questAnswer.update({
+    where: {
+      id: answerId
+    },
+    data: {
+      score,
+      review,
+      reviewerId: userId
+    }
+  });
+  return answer;
+});

server/api/admin/hunt/[huntId]/index.get.ts

@@ -0,0 +1,78 @@
+import { useValidatedParams, z, zh } from 'h3-zod';
+import prisma from '~~/lib/prisma';
+import { sendJson } from '~~/server/utils/json';
+
+export default defineEventHandler(async (event) => {
+  const user = await requireUserSession(event);
+
+  if (user.user.role !== 'ADMIN') {
+    throw createError({
+      status: 403,
+      statusText: 'Not allowed!'
+    });
+  }
+  const userId = user.user.id;
+  const { huntId } = await useValidatedParams(
+    event,
+    z.object({
+      huntId: zh.numAsString
+    })
+  );
+
+  const hunt = await prisma.hunt.findUnique({
+    where: {
+      id: huntId,
+      OR: [
+        {
+          creatorId: userId
+        },
+        {
+          members: {
+            some: {
+              memberId: userId
+            }
+          }
+        }
+      ]
+    },
+    select: {
+      id: true,
+      name: true,
+      description: true,
+      virtual: true,
+      start: true,
+      end: true,
+      allowJoin: true,
+      revealQuests: true,
+      revealAnswers: true,
+      updatedAt: true,
+      creator: {
+        select: {
+          name: true,
+          id: true,
+          email: true
+        }
+      },
+      members: {
+        select: {
+          createdAt: true,
+          member: {
+            select: {
+              id: true,
+              name: true,
+              email: true
+            }
+          }
+        }
+      }
+    }
+  });
+
+  if (!hunt) {
+    throw createError({ status: 404, statusText: 'Not found!' });
+  }
+
+  setHeader(event, 'Content-Type', 'application/json');
+
+  return sendJson(hunt);
+});

server/api/admin/hunt/[huntId]/index.post.ts

@@ -0,0 +1,59 @@
+import { useValidatedBody, useValidatedParams, z, zh } from 'h3-zod';
+import prisma from '~~/lib/prisma';
+
+export default defineEventHandler(async (event) => {
+  const user = await requireUserSession(event);
+
+  if (user.user.role !== 'ADMIN') {
+    throw createError({ status: 403, statusText: 'Not allowed!' });
+  }
+  const userId = user.user.id;
+  const { huntId } = await useValidatedParams(
+    event,
+    z.object({
+      huntId: zh.numAsString
+    })
+  );
+
+  const { updatedAt, ...data } = await useValidatedBody(
+    event,
+    z
+      .object({
+        name: z.string().min(1).max(256).trim(),
+        description: z.string().min(1).max(1000).trim(),
+        virtual: z.boolean(),
+        start: z.iso.datetime(),
+        end: z.iso.datetime(),
+        allowJoin: z.boolean(),
+        revealQuests: z.boolean(),
+        revealAnswers: z.boolean()
+      })
+      .partial()
+      .and(
+        z.object({
+          updatedAt: z.iso.datetime()
+        })
+      )
+  );
+
+  await prisma.hunt.update({
+    where: {
+      id: huntId,
+      updatedAt,
+      OR: [
+        {
+          creatorId: userId
+        },
+        {
+          members: {
+            some: {
+              memberId: userId
+            }
+          }
+        }
+      ]
+    },
+    data
+  });
+  return {};
+});

server/api/admin/quest/[questId]/index.get.ts

@@ -0,0 +1,101 @@
+import { useValidatedParams, z, zh } from 'h3-zod';
+import prisma from '~~/lib/prisma';
+
+export default defineEventHandler(async (event) => {
+  const user = await requireUserSession(event);
+
+  if (user.user.role !== 'ADMIN') {
+    throw createError({ status: 403, statusText: 'Not allowed!' });
+  }
+  const userId = user.user.id;
+  const { questId } = await useValidatedParams(
+    event,
+    z.object({
+      questId: zh.numAsString
+    })
+  );
+
+  const quest = await prisma.huntQuest.findUnique({
+    where: {
+      id: questId,
+      OR: [
+        {
+          hunt: {
+            creatorId: userId
+          }
+        },
+        {
+          hunt: {
+            members: {
+              some: {
+                memberId: userId
+              }
+            }
+          }
+        }
+      ]
+    },
+    omit: {
+      huntId: true,
+      pictureId: true,
+      order: true
+    },
+    include: {
+      hunt: {
+        select: {
+          name: true,
+          id: true
+        }
+      },
+      answers: {
+        select: {
+          id: true,
+          text: true,
+          updatedAt: true,
+          team: {
+            select: {
+              id: true,
+              name: true
+            }
+          },
+          score: true,
+          review: true,
+          internalNote: true,
+          rankingValue: true,
+          showcase: true,
+          reviewer: {
+            select: {
+              name: true,
+              id: true
+            }
+          },
+          member: {
+            select: {
+              name: true,
+              id: true
+            }
+          },
+          picture: {
+            select: {
+              url: true,
+              createdAt: true
+            }
+          }
+        },
+        orderBy: [
+          { rankingValue: { sort: 'desc', nulls: 'last' } },
+          { score: { sort: 'desc', nulls: 'last' } },
+          {
+            updatedAt: 'desc'
+          }
+        ]
+      }
+    }
+  });
+
+  if (!quest) {
+    throw createError({ status: 404, statusText: 'Not found!' });
+  }
+
+  return quest;
+});

server/auth.d.ts

@@ -1,9 +0,0 @@
-import type { User as PUser } from '@prisma/client';
-
-declare module '#auth-utils' {
-  interface User extends Pick<PUser, 'id' | 'role' | 'name'> {}
-  interface UserSession {
-    user: User;
-    loggedInAt: string | Date;
-  }
-}

server/utils/json.ts

@@ -0,0 +1,11 @@
+import superjson from 'superjson';
+
+export function sendJson<T extends object>(data: T) {
+  const hackData = {
+    ...data,
+    toJSON() {
+      return this;
+    }
+  };
+  return superjson.stringify(hackData) as unknown as typeof hackData;
+}