Initial Commit

server/api/admin/motd.put.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod'
+import { settings } from '../../db/schema'
+
+const bodySchema = z.object({
+  message: z.string().trim().max(500),
+})
+
+export default defineEventHandler(async (event) => {
+  await requirePermission(event, 'site.manage')
+  const { message } = await readValidatedBody(event, bodySchema.parse)
+  const db = useDb()
+  await db
+    .insert(settings)
+    .values({ key: 'motd', value: message })
+    .onDuplicateKeyUpdate({ set: { value: message } })
+  broadcastToAll({ type: 'motd', message })
+  return { message }
+})

server/api/admin/roles.get.ts

@@ -0,0 +1,18 @@
+import { asc, count, eq } from 'drizzle-orm'
+import { roles, userRoles } from '../../db/schema'
+
+export default defineEventHandler(async (event) => {
+  await requirePermission(event, 'admin.access')
+  const roleList = await useDb()
+    .select({
+      id: roles.id,
+      name: roles.name,
+      memberCount: count(userRoles.userId),
+    })
+    .from(roles)
+    .leftJoin(userRoles, eq(userRoles.roleId, roles.id))
+    .groupBy(roles.id)
+    .orderBy(asc(roles.name))
+  const permsByRole = await getRolePermissions()
+  return roleList.map(r => ({ ...r, permissions: permsByRole.get(r.id) ?? [] }))
+})

server/api/admin/roles.post.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod'
+
+const bodySchema = z.object({
+  name: z.string().trim().min(2).max(50).regex(/^[\w-]+$/, 'Nur Buchstaben, Zahlen, - und _'),
+})
+
+export default defineEventHandler(async (event) => {
+  await requirePermission(event, 'roles.manage')
+  const { name } = await readValidatedBody(event, bodySchema.parse)
+  const id = await ensureRole(name)
+  return { id, name }
+})

server/api/admin/roles/[id].delete.ts

@@ -0,0 +1,21 @@
+import { eq } from 'drizzle-orm'
+import { roles } from '../../../db/schema'
+import { SYSTEM_ROLES } from '../../../../shared/utils/permissions'
+
+export default defineEventHandler(async (event) => {
+  await requirePermission(event, 'roles.manage')
+  const id = Number(getRouterParam(event, 'id'))
+  if (!Number.isInteger(id) || id <= 0) {
+    throw createError({ statusCode: 400, statusMessage: 'Ungültige ID' })
+  }
+  const db = useDb()
+  const existing = await db.select({ name: roles.name }).from(roles).where(eq(roles.id, id)).limit(1)
+  if (!existing[0]) {
+    throw createError({ statusCode: 404, statusMessage: 'Rolle nicht gefunden' })
+  }
+  if ((SYSTEM_ROLES as readonly string[]).includes(existing[0].name)) {
+    throw createError({ statusCode: 400, statusMessage: `Die ${existing[0].name}-Rolle kann nicht gelöscht werden` })
+  }
+  await db.delete(roles).where(eq(roles.id, id))
+  return { ok: true }
+})

server/api/admin/roles/[id]/permissions.put.ts

@@ -0,0 +1,38 @@
+import { eq, inArray } from 'drizzle-orm'
+import { z } from 'zod'
+import { PERMISSION_KEYS } from '../../../../../shared/utils/permissions'
+import { permissions, rolePermissions, roles } from '../../../../db/schema'
+
+const bodySchema = z.object({
+  permissions: z.array(z.string()).max(50),
+})
+
+export default defineEventHandler(async (event) => {
+  await requirePermission(event, 'roles.manage')
+  const id = Number(getRouterParam(event, 'id'))
+  if (!Number.isInteger(id) || id <= 0) {
+    throw createError({ statusCode: 400, statusMessage: 'Ungültige ID' })
+  }
+  const { permissions: keys } = await readValidatedBody(event, bodySchema.parse)
+  if (keys.some(k => !PERMISSION_KEYS.includes(k))) {
+    throw createError({ statusCode: 400, statusMessage: 'Unbekannte Berechtigung' })
+  }
+
+  const db = useDb()
+  const [role] = await db.select({ name: roles.name }).from(roles).where(eq(roles.id, id)).limit(1)
+  if (!role) {
+    throw createError({ statusCode: 404, statusMessage: 'Rolle nicht gefunden' })
+  }
+  if (role.name === 'admin') {
+    throw createError({ statusCode: 400, statusMessage: 'Die Admin-Rolle hat immer alle Berechtigungen' })
+  }
+
+  await db.delete(rolePermissions).where(eq(rolePermissions.roleId, id))
+  if (keys.length) {
+    const rows = await db.select({ id: permissions.id }).from(permissions).where(inArray(permissions.key, keys))
+    if (rows.length) {
+      await db.insert(rolePermissions).values(rows.map(r => ({ roleId: id, permissionId: r.id })))
+    }
+  }
+  return { ok: true }
+})

server/api/admin/users.get.ts

@@ -0,0 +1,26 @@
+import { asc, eq } from 'drizzle-orm'
+import { roles, userRoles, users } from '../../db/schema'
+
+export default defineEventHandler(async (event) => {
+  await requirePermission(event, 'admin.access')
+  const db = useDb()
+
+  const allUsers = await db
+    .select({ id: users.id, name: users.name, email: users.email, createdAt: users.createdAt })
+    .from(users)
+    .orderBy(asc(users.name))
+
+  const roleRows = await db
+    .select({ userId: userRoles.userId, roleId: roles.id, name: roles.name })
+    .from(userRoles)
+    .innerJoin(roles, eq(userRoles.roleId, roles.id))
+
+  const byUser = new Map<number, { id: number, name: string }[]>()
+  for (const row of roleRows) {
+    const list = byUser.get(row.userId) ?? []
+    list.push({ id: row.roleId, name: row.name })
+    byUser.set(row.userId, list)
+  }
+
+  return allUsers.map(u => ({ ...u, roles: byUser.get(u.id) ?? [] }))
+})

server/api/admin/users/[id]/roles.post.ts

@@ -0,0 +1,29 @@
+import { eq } from 'drizzle-orm'
+import { z } from 'zod'
+import { roles, users } from '../../../../db/schema'
+
+const bodySchema = z.object({
+  roleId: z.number().int().positive(),
+})
+
+export default defineEventHandler(async (event) => {
+  await requirePermission(event, 'users.manage')
+  const userId = Number(getRouterParam(event, 'id'))
+  if (!Number.isInteger(userId) || userId <= 0) {
+    throw createError({ statusCode: 400, statusMessage: 'Ungültige ID' })
+  }
+  const { roleId } = await readValidatedBody(event, bodySchema.parse)
+  const db = useDb()
+
+  const [user] = await db.select({ id: users.id }).from(users).where(eq(users.id, userId)).limit(1)
+  if (!user) {
+    throw createError({ statusCode: 404, statusMessage: 'Nutzer nicht gefunden' })
+  }
+  const [role] = await db.select({ id: roles.id }).from(roles).where(eq(roles.id, roleId)).limit(1)
+  if (!role) {
+    throw createError({ statusCode: 404, statusMessage: 'Rolle nicht gefunden' })
+  }
+
+  await assignRole(userId, roleId)
+  return { ok: true }
+})

server/api/admin/users/[id]/roles/[roleId].delete.ts

@@ -0,0 +1,23 @@
+import { and, eq } from 'drizzle-orm'
+import { roles, userRoles } from '../../../../../db/schema'
+
+export default defineEventHandler(async (event) => {
+  const admin = await requirePermission(event, 'users.manage')
+  const userId = Number(getRouterParam(event, 'id'))
+  const roleId = Number(getRouterParam(event, 'roleId'))
+  if (!Number.isInteger(userId) || userId <= 0 || !Number.isInteger(roleId) || roleId <= 0) {
+    throw createError({ statusCode: 400, statusMessage: 'Ungültige ID' })
+  }
+  const db = useDb()
+
+  const [role] = await db.select({ name: roles.name }).from(roles).where(eq(roles.id, roleId)).limit(1)
+  if (!role) {
+    throw createError({ statusCode: 404, statusMessage: 'Rolle nicht gefunden' })
+  }
+  if (role.name === 'admin' && userId === admin.id) {
+    throw createError({ statusCode: 400, statusMessage: 'Du kannst dir nicht selbst die Admin-Rolle entziehen' })
+  }
+
+  await db.delete(userRoles).where(and(eq(userRoles.userId, userId), eq(userRoles.roleId, roleId)))
+  return { ok: true }
+})