2.11.0

apps/api/package.json

@@ -33,7 +33,7 @@
     "@codeanker/service-sms": "file:../../vendor/codeanker-service-sms-0.0.2.tar.gz",
     "@e965/xlsx": "^0.20.3",
     "@faker-js/faker": "catalog:",
-    "@hono/node-server": "^1.19.6",
+    "@hono/node-server": "^1.19.10",
     "@hono/trpc-server": "^0.4.0",
     "@prisma/client": "^5.19.1",
     "@prisma/extension-accelerate": "^1.1.0",
@@ -45,7 +45,7 @@
     "dot-prop": "^9.0.0",
     "fast-csv": "^5.0.1",
     "handlebars": "^4.7.8",
-    "hono": "^4.12.0",
+    "hono": "^4.12.4",
     "http-errors": "^2.0.1",
     "jsonwebtoken": "^9.0.2",
     "meilisearch": "^0.37.0",

apps/api/prisma/migrations/20260304182124_custom_field_order/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "CustomField" ADD COLUMN     "order" INTEGER;

apps/api/prisma/schema/CustomField.prisma

@@ -19,6 +19,7 @@ model CustomField {
   id                   String                @id @default(uuid(7))
   name                 String
   description          String?
+  order                Int?
   type                 CustomFieldType
   required             Boolean               @default(false)
   options              String[]

apps/api/src/routes/oidc/index.ts

@@ -136,7 +136,16 @@ oidcRouter.get('/dlrg/login', async (c) => {
   const as = await oauth.processDiscoveryResponse(issuer, discoveryRequestResponse)
   const authorizationUrl = new URL(as.authorization_endpoint!)
 
-  const redirectUri = new URL('/api/connect/dlrg/callback', config.clientUrl)
+  const host = await prisma.hostname.findFirst({
+    where: {
+      hostname: c.req.header('Host'),
+    }
+  })
+  if (host === null) {
+    return c.text('Invalid domain', 400)
+  }
+
+  const redirectUri = new URL('/api/connect/dlrg/callback', host.hostname)
   const registerAs = c.req.query('as')?.trim()
   if (registerAs !== undefined && registerAs?.length > 0) {
     redirectUri.searchParams.set('as', registerAs)

apps/api/src/services/customFields/customFields.router.ts

@@ -9,6 +9,8 @@ import { customFieldsVeranstaltungCreate } from './customFieldsVeranstaltungCrea
 import { customFieldsVeranstaltungDelete, customFieldsUnterveranstaltungDelete } from './customFieldsDelete.js'
 import { customFieldsUpdate } from './customFieldsUpdate.js'
 import { customFieldValuesUpdate } from './customFieldValuesUpdate.js'
+import { customFieldUnterveranstaltungOrder } from './schema/customFieldsUnterveranstaltungOrder.js'
+import { customFieldVeranstaltungOrder } from './schema/customFieldsVeranstaltungOrder.js'
 // Import Routes here - do not delete this line
 
 export const customFieldsRouter = mergeRouters(
@@ -21,6 +23,8 @@ export const customFieldsRouter = mergeRouters(
   customFieldsUnterveranstaltungDelete,
   customFieldsUnterveranstaltungCreate,
   customFieldValuesUpdate,
-  customFieldsTemplates
+  customFieldsTemplates,
+  customFieldVeranstaltungOrder,
+  customFieldUnterveranstaltungOrder
   // Add Routes here - do not delete this line
 )

apps/api/src/services/customFields/customFieldsList.ts

@@ -2,14 +2,15 @@ import { z } from 'zod'
 
 import { CustomFieldPosition, CustomFieldType, Prisma } from '@prisma/client'
 import prisma from '../../prisma.js'
-import { definePublicQueryProcedure } from '../../types/defineProcedure.js'
+import { defineProtectedQueryProcedure, definePublicQueryProcedure } from '../../types/defineProcedure.js'
 import {
   calculatePagination,
   defineEmptyQueryResponse,
   defineQueryResponse,
   defineTableInput,
 } from '../../types/defineTableProcedure.js'
 import { boolish } from '../../util/zod.js'
+import { getGliederungRequireAdmin } from '../../util/getGliederungRequireAdmin.js'
 
 const baseFilter = z.strictObject({
   entity: z.enum(['veranstaltung', 'unterveranstaltung']),
@@ -23,6 +24,7 @@ export const customFieldsTable = definePublicQueryProcedure({
   async handler({ input: { entity, entityId, position } }) {
     if (entity === 'veranstaltung') {
       return await prisma.customField.findMany({
+        orderBy: [{ order: { sort: 'asc', nulls: 'last' } }],
         where: {
           veranstaltungId: entityId,
           positions:
@@ -35,6 +37,14 @@ export const customFieldsTable = definePublicQueryProcedure({
       })
     } else if (entity === 'unterveranstaltung') {
       return await prisma.customField.findMany({
+        orderBy: [
+          {
+            unterveranstaltungId: { sort: 'asc', nulls: 'first' },
+          },
+          {
+            order: { sort: 'asc', nulls: 'last' },
+          },
+        ],
         where: {
           positions:
             position === undefined
@@ -64,8 +74,9 @@ export const customFieldsTable = definePublicQueryProcedure({
   },
 })
 
-export const customFieldsList = definePublicQueryProcedure({
+export const customFieldsList = defineProtectedQueryProcedure({
   key: 'table',
+  roleIds: ['ADMIN', 'GLIEDERUNG_ADMIN'],
   inputSchema: baseFilter.extend({
     table: defineTableInput({
       filter: {
@@ -74,10 +85,14 @@ export const customFieldsList = definePublicQueryProcedure({
         required: boolish,
         position: z.nativeEnum(CustomFieldPosition),
       },
-      orderBy: ['name'],
+      orderBy: ['name', 'order'],
     }),
   }),
-  async handler({ input }) {
+  async handler({ ctx, input }) {
+    if (ctx.account.role === 'GLIEDERUNG_ADMIN') {
+      await getGliederungRequireAdmin(ctx.accountId)
+    }
+
     const where: Prisma.CustomFieldWhereInput = {
       name: {
         contains: input.table?.filter?.name,
@@ -93,22 +108,39 @@ export const customFieldsList = definePublicQueryProcedure({
             },
     }
 
+    if (input.entity === 'veranstaltung') {
+      where.veranstaltungId = input.entityId
+    } else if (input.entity === 'unterveranstaltung') {
+      where.OR = [
+        {
+          unterveranstaltungId: input.entityId,
+        },
+        {
+          veranstaltung: {
+            unterveranstaltungen: {
+              some: {
+                id: input.entityId,
+              },
+            },
+          },
+        },
+      ]
+    }
+
     const total = await prisma.customField.count({ where })
     const { pageIndex, pageSize, pages } = calculatePagination(total, input.table?.pagination)
 
     if (input.entity === 'veranstaltung') {
       const customFields = await prisma.customField.findMany({
         take: pageSize,
         skip: pageSize * pageIndex,
-        where: {
-          ...where,
-          veranstaltungId: input.entityId,
-        },
+        where,
         orderBy: input.table?.orderBy,
         select: {
           id: true,
           name: true,
           description: true,
+          order: true,
           type: true,
           positions: true,
           required: true,
@@ -122,27 +154,18 @@ export const customFieldsList = definePublicQueryProcedure({
       const customFields = await prisma.customField.findMany({
         take: pageSize,
         skip: pageSize * pageIndex,
-        where: {
-          ...where,
-          OR: [
-            {
-              unterveranstaltungId: input.entityId,
-            },
-            {
-              veranstaltung: {
-                unterveranstaltungen: {
-                  some: {
-                    id: input.entityId,
-                  },
-                },
-              },
-            },
-          ],
-        },
+        orderBy: [
+          {
+            unterveranstaltungId: { sort: 'asc', nulls: 'first' },
+          },
+          ...(input.table?.orderBy ?? []),
+        ],
+        where,
         select: {
           id: true,
           name: true,
           description: true,
+          order: true,
           type: true,
           positions: true,
           required: true,

apps/api/src/services/customFields/schema/customField.schema.ts

@@ -1,11 +1,21 @@
 import { CustomFieldPosition, CustomFieldType } from '@prisma/client'
 import { z } from 'zod'
 
-export const customFieldSchema = z.strictObject({
-  name: z.string().min(1),
-  description: z.string().nullable(),
-  type: z.nativeEnum(CustomFieldType),
-  required: z.boolean(),
-  options: z.array(z.string()),
-  positions: z.nativeEnum(CustomFieldPosition).array(),
-})
+export const customFieldSchema = z
+  .strictObject({
+    name: z.string().min(1),
+    description: z.string().nullable(),
+    type: z.nativeEnum(CustomFieldType),
+    required: z.boolean(),
+    options: z.array(z.string()),
+    positions: z.nativeEnum(CustomFieldPosition).array().min(1),
+  })
+  .superRefine((values, ctx) => {
+    const optionTypes = ['BASIC_DROPDOWN', 'BASIC_RADIO', 'BASIC_SWITCH'] as CustomFieldType[]
+    if (optionTypes.includes(values.type) && values.options.length === 0) {
+      ctx.addIssue({
+        code: 'custom',
+        message: 'Es muss mindestens eine Auswahlmöglichkeit angegeben werden',
+      })
+    }
+  })

apps/api/src/services/customFields/schema/customFieldsUnterveranstaltungOrder.ts

@@ -0,0 +1,54 @@
+import z from 'zod'
+import { defineProtectedMutateProcedure } from '../../../types/defineProcedure.js'
+import { getGliederungRequireAdmin } from '../../../util/getGliederungRequireAdmin.js'
+import { TRPCError } from '@trpc/server'
+import prisma from '../../../prisma.js'
+
+export const customFieldUnterveranstaltungOrder = defineProtectedMutateProcedure({
+  key: 'unterveranstaltungOrder',
+  roleIds: ['ADMIN', 'GLIEDERUNG_ADMIN'],
+  inputSchema: z.strictObject({
+    unterveranstaltungId: z.string().uuid(),
+    fields: z.array(z.string().uuid()),
+  }),
+  handler: async ({ ctx, input }) => {
+    if (ctx.account.role === 'GLIEDERUNG_ADMIN') {
+      const gliederung = await getGliederungRequireAdmin(ctx.accountId)
+      if (gliederung.id !== input.unterveranstaltungId) {
+        throw new TRPCError({
+          code: 'FORBIDDEN',
+        })
+      }
+    }
+
+    const fields = await prisma.customField.findMany({
+      where: {
+        unterveranstaltungId: input.unterveranstaltungId,
+        id: {
+          in: input.fields,
+        },
+      },
+    })
+
+    if (fields.length !== input.fields.length) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: 'Some supplied fields do not belong to the given unterveranstaltung!',
+      })
+    }
+
+    await prisma.$transaction(
+      input.fields.map((field, index) =>
+        prisma.customField.update({
+          where: {
+            unterveranstaltungId: input.unterveranstaltungId,
+            id: field,
+          },
+          data: {
+            order: index + 1,
+          },
+        })
+      )
+    )
+  },
+})

apps/api/src/services/customFields/schema/customFieldsVeranstaltungOrder.ts

@@ -0,0 +1,44 @@
+import { TRPCError } from '@trpc/server'
+import z from 'zod'
+import prisma from '../../../prisma.js'
+import { defineProtectedMutateProcedure } from '../../../types/defineProcedure.js'
+
+export const customFieldVeranstaltungOrder = defineProtectedMutateProcedure({
+  key: 'veranstaltungOrder',
+  roleIds: ['ADMIN'],
+  inputSchema: z.strictObject({
+    veranstaltungId: z.string().uuid(),
+    fields: z.array(z.string().uuid()),
+  }),
+  handler: async ({ input }) => {
+    const fields = await prisma.customField.findMany({
+      where: {
+        veranstaltungId: input.veranstaltungId,
+        id: {
+          in: input.fields,
+        },
+      },
+    })
+
+    if (fields.length !== input.fields.length) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: 'Some supplied fields do not belong to the given veranstaltung!',
+      })
+    }
+
+    await prisma.$transaction(
+      input.fields.map((field, index) =>
+        prisma.customField.update({
+          where: {
+            veranstaltungId: input.veranstaltungId,
+            id: field,
+          },
+          data: {
+            order: index + 1,
+          },
+        })
+      )
+    )
+  },
+})

apps/api/src/services/gliederung/gliederungVerwaltungGet.ts

@@ -19,6 +19,7 @@ export const gliederungVerwaltungGetProcedure = defineProtectedQueryProcedure({
         id: true,
         name: true,
         edv: true,
+        domain: true,
       },
     })
   },

apps/frontend/src/components/CustomFields/CustomFieldsTable.vue

@@ -32,6 +32,18 @@ const router = useRouter()
 
 const column = createColumnHelper<CustomField>()
 const columns = [
+  column.accessor('order', {
+    header: 'Reihenfolge',
+    enableSorting: true,
+    cell({ getValue }) {
+      const order = getValue()
+      if (!order) {
+        return '-'
+      }
+
+      return order
+    },
+  }),
   column.accessor('name', {
     header: 'Name',
     enableColumnFilter: true,
@@ -174,6 +186,7 @@ function onClick(field: CustomField) {
   <DataTable
     :query="query"
     :columns="columns"
+    :initial-sort="[{ id: 'order', desc: false }]"
     @click="onClick"
   />
 </template>

apps/frontend/src/components/forms/person/FormPersonGeneral.vue

@@ -45,6 +45,7 @@ const props = defineProps<{
 const emit = defineEmits<{
   submit: [data: FormPersonGeneralSubmit]
   showTerms: []
+  showPrivacy: []
 }>()
 
 async function queryGliederungen(searchTerm: string) {
@@ -237,7 +238,7 @@ const submit = () => {
           <span>Ich habe die gesonderten </span>
           <u
             class="cursor-pointer"
-            @click="emit('showTerms')"
+            @click="emit('showPrivacy')"
           >
             <span>Datenschutzerklärung</span>
             <ArrowTopRightOnSquareIcon class="h-4 inline ml-1" />