feat(quest): add full CRUD and image handling for hunt quests

2026-07-31 01:03:54 +02:00
parent 77becc453e
commit 24632742ef
15 changed files with 1228 additions and 7 deletions
@@ -0,0 +1,48 @@
+import { useValidatedParams, z, zh } from 'h3-zod';
+import prisma from '~~/lib/prisma';
+
+export default defineEventHandler(async (event) => {
+  const user = await requireUserSession(event);
+
+  const userId = user.user.id;
+  const { huntId, questId } = await useValidatedParams(
+    event,
+    z.object({
+      huntId: zh.numAsString,
+      questId: zh.numAsString
+    })
+  );
+
+  // Verify membership
+  const quest = await prisma.huntQuest.findUnique({
+    where: {
+      id: questId,
+      huntId,
+      hunt: {
+        members: {
+          some: {
+            memberId: userId
+          }
+        }
+      }
+    },
+    select: {
+      id: true
+    }
+  });
+
+  if (!quest) {
+    throw createError({ statusCode: 404, statusMessage: 'Not found!' });
+  }
+
+  await prisma.huntQuest.update({
+    where: {
+      id: questId
+    },
+    data: {
+      pictureId: null
+    }
+  });
+
+  return { success: true };
+});
@@ -0,0 +1,81 @@
+import { useValidatedParams, z, zh } from 'h3-zod';
+import { randomUUID } from 'node:crypto';
+import prisma from '~~/lib/prisma';
+import { minioClient, s3Bucket, s3Host } from '~~/lib/s3';
+
+export default defineEventHandler(async (event) => {
+  const user = await requireUserSession(event);
+
+  const userId = user.user.id;
+  const { huntId, questId } = await useValidatedParams(
+    event,
+    z.object({
+      huntId: zh.numAsString,
+      questId: zh.numAsString
+    })
+  );
+
+  // Verify membership
+  const quest = await prisma.huntQuest.findUnique({
+    where: {
+      id: questId,
+      huntId,
+      hunt: {
+        members: {
+          some: {
+            memberId: userId
+          }
+        }
+      }
+    },
+    select: {
+      id: true
+    }
+  });
+
+  if (!quest) {
+    throw createError({ statusCode: 404, statusMessage: 'Not found!' });
+  }
+
+  const body = await readFormData(event);
+  const formDataObj = Object.fromEntries(body.entries());
+
+  const { image } = z
+    .object({
+      image: z
+        .file()
+        .mime(['image/png', 'image/jpeg', 'image/jpg'])
+        .max(10_000_000)
+    })
+    .parse(formDataObj);
+
+  const uuid = randomUUID();
+  await minioClient.putObject(
+    s3Bucket,
+    uuid,
+    Buffer.from(await image.arrayBuffer()),
+    undefined,
+    {
+      'Cache-Control': 'public, max-age=31536000, immutable',
+      'Content-Type': image.type
+    }
+  );
+
+  await prisma.huntQuest.update({
+    where: {
+      id: questId
+    },
+    data: {
+      picture: {
+        create: {
+          creatorId: userId,
+          url: `https://${s3Bucket}.${s3Host}/${uuid}`,
+          uuid,
+          questId
+        }
+      }
+    }
+  });
+
+  return { success: true };
+});
@@ -0,0 +1,62 @@
+import { useValidatedParams, z, zh } from 'h3-zod';
+import prisma from '~~/lib/prisma';
+
+export default defineEventHandler(async (event) => {
+  const user = await requireUserSession(event);
+
+  const userId = user.user.id;
+  const { huntId, questId } = await useValidatedParams(
+    event,
+    z.object({
+      huntId: zh.numAsString,
+      questId: zh.numAsString
+    })
+  );
+
+  // Verify membership and get quest order
+  const quest = await prisma.huntQuest.findUnique({
+    where: {
+      id: questId,
+      huntId,
+      hunt: {
+        members: {
+          some: {
+            memberId: userId
+          }
+        }
+      }
+    },
+    select: {
+      id: true,
+      order: true
+    }
+  });
+
+  if (!quest) {
+    throw createError({ statusCode: 404, statusMessage: 'Not found!' });
+  }
+
+  // Delete the quest
+  await prisma.huntQuest.delete({
+    where: {
+      id: questId
+    }
+  });
+
+  // Reorder remaining quests
+  await prisma.huntQuest.updateMany({
+    where: {
+      huntId,
+      order: {
+        gt: quest.order
+      }
+    },
+    data: {
+      order: {
+        decrement: 1
+      }
+    }
+  });
+
+  return { success: true };
+});
@@ -0,0 +1,63 @@
+import { useValidatedParams, z, zh } from 'h3-zod';
+import prisma from '~~/lib/prisma';
+
+export default defineEventHandler(async (event) => {
+  const user = await requireUserSession(event);
+
+  const userId = user.user.id;
+  const { huntId, questId } = await useValidatedParams(
+    event,
+    z.object({
+      huntId: zh.numAsString,
+      questId: zh.numAsString
+    })
+  );
+
+  const quest = await prisma.huntQuest.findUnique({
+    where: {
+      id: questId,
+      huntId,
+      hunt: {
+        members: {
+          some: {
+            memberId: userId
+          }
+        }
+      }
+    },
+    select: {
+      id: true,
+      title_de: true,
+      title_en: true,
+      description_de: true,
+      description_en: true,
+      question_de: true,
+      question_en: true,
+      location: true,
+      locationLink: true,
+      order: true,
+      optional: true,
+      pictureRequired: true,
+      textRequired: true,
+      textType: true,
+      textUnit: true,
+      textSolution: true,
+      points: true,
+      extraPoints: true,
+      extraText_de: true,
+      extraText_en: true,
+      picture: {
+        select: {
+          id: true,
+          url: true
+        }
+      }
+    }
+  });
+
+  if (!quest) {
+    throw createError({ statusCode: 404, statusMessage: 'Not found!' });
+  }
+
+  return quest;
+});
@@ -0,0 +1,76 @@
+import { useValidatedBody, useValidatedParams, z, zh } from 'h3-zod';
+import prisma from '~~/lib/prisma';
+
+export default defineEventHandler(async (event) => {
+  const user = await requireUserSession(event);
+
+  const userId = user.user.id;
+  const { huntId, questId } = await useValidatedParams(
+    event,
+    z.object({
+      huntId: zh.numAsString,
+      questId: zh.numAsString
+    })
+  );
+
+  // Verify membership
+  const quest = await prisma.huntQuest.findUnique({
+    where: {
+      id: questId,
+      huntId,
+      hunt: {
+        members: {
+          some: {
+            memberId: userId
+          }
+        }
+      }
+    },
+    select: {
+      id: true
+    }
+  });
+
+  if (!quest) {
+    throw createError({ statusCode: 404, statusMessage: 'Not found!' });
+  }
+
+  const body = await useValidatedBody(
+    event,
+    z.object({
+      title_de: z.string().min(1).max(256).trim(),
+      title_en: z.string().min(1).max(256).trim(),
+      description_de: z.string().max(2000).trim().default(''),
+      description_en: z.string().max(2000).trim().default(''),
+      question_de: z.string().max(1000).trim().nullish(),
+      question_en: z.string().max(1000).trim().nullish(),
+      location: z.string().max(256).trim().nullish(),
+      locationLink: z.string().url().nullish(),
+      optional: z.boolean().default(true),
+      pictureRequired: z.boolean().default(false),
+      textRequired: z.boolean().default(false),
+      textType: z
+        .enum(['TEXT', 'WORD', 'CHAR', 'NUMBER', 'INTEGER'])
+        .default('TEXT'),
+      textUnit: z.string().max(64).trim().nullish(),
+      textSolution: z.string().max(256).trim().nullish(),
+      points: z.number().int().min(0).max(32767).default(10),
+      extraPoints: z.number().int().min(0).max(32767).nullish(),
+      extraText_de: z.string().max(256).trim().nullish(),
+      extraText_en: z.string().max(256).trim().nullish()
+    })
+  );
+
+  return await prisma.huntQuest.update({
+    where: {
+      id: questId
+    },
+    data: body,
+    select: {
+      id: true,
+      title_de: true,
+      title_en: true,
+      order: true
+    }
+  });
+});
@@ -0,0 +1,81 @@
+import { useValidatedBody, useValidatedParams, z, zh } from 'h3-zod';
+import prisma from '~~/lib/prisma';
+
+export default defineEventHandler(async (event) => {
+  const user = await requireUserSession(event);
+
+  const userId = user.user.id;
+  const { huntId, questId } = await useValidatedParams(
+    event,
+    z.object({
+      huntId: zh.numAsString,
+      questId: zh.numAsString
+    })
+  );
+
+  const { direction } = await useValidatedBody(
+    event,
+    z.object({
+      direction: z.enum(['up', 'down'])
+    })
+  );
+
+  // Verify membership and get quest
+  const quest = await prisma.huntQuest.findUnique({
+    where: {
+      id: questId,
+      huntId,
+      hunt: {
+        members: {
+          some: {
+            memberId: userId
+          }
+        }
+      }
+    },
+    select: {
+      id: true,
+      order: true
+    }
+  });
+
+  if (!quest) {
+    throw createError({ statusCode: 404, statusMessage: 'Not found!' });
+  }
+
+  const targetOrder = direction === 'up' ? quest.order - 1 : quest.order + 1;
+
+  if (targetOrder < 0) {
+    throw createError({ statusCode: 400, statusMessage: 'Already at top!' });
+  }
+
+  // Find the quest to swap with
+  const swapQuest = await prisma.huntQuest.findFirst({
+    where: {
+      huntId,
+      order: targetOrder
+    },
+    select: {
+      id: true,
+      order: true
+    }
+  });
+
+  if (!swapQuest) {
+    throw createError({ statusCode: 400, statusMessage: 'Already at bottom!' });
+  }
+
+  // Swap orders in a transaction
+  await prisma.$transaction([
+    prisma.huntQuest.update({
+      where: { id: quest.id },
+      data: { order: swapQuest.order }
+    }),
+    prisma.huntQuest.update({
+      where: { id: swapQuest.id },
+      data: { order: quest.order }
+    })
+  ]);
+
+  return { success: true };
+});