Merge branch 'development' into feature/request-gliederung-access

Author: danielswiatek

.github/dependabot.yml

@@ -1,11 +1,9 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
 version: 2
 updates:
-  - package-ecosystem: 'npm' # See documentation for possible values
-    directory: '/' # Location of package manifests
+  - package-ecosystem: npm
+    directory: /
     schedule:
-      interval: 'daily'
+      interval: "daily"
+    labels:
+      - component:deps
+      - deps:npm

apps/api/prisma/seeders/anmeldungen.ts

@@ -14,8 +14,6 @@ import type { Seeder } from './index.js'
 
 const ENTRY_COUNT = 100
 
-faker.seed(123)
-
 async function create(prisma: PrismaClient, unterveranstaltung: Unterveranstaltung): Promise<void> {
   const address = await prisma.address.create({
     data: {

apps/api/src/services/program/program.create.ts

@@ -9,23 +9,28 @@ export const programCreateProcedure = defineProtectedMutateProcedure({
   roleIds: ['ADMIN'],
   inputSchema: z.strictObject({
     veranstaltungId: z.string().uuid(),
-    name: z.string(),
-    description: z.string(),
-    location: z.string(),
-    responsible: z.string(),
-    startingAt: z.date(),
-    endingAt: z.date(),
+    data: z.object({
+      name: z.string(),
+      description: z.string(),
+      location: z.string(),
+      responsible: z.string(),
+      startingAt: z.date(),
+      endingAt: z.date(),
+    }),
   }),
-  handler: async ({ input }) => {
-    if (dayjs(input.endingAt).isBefore(input.startingAt)) {
+  handler: async ({ input: { veranstaltungId, data } }) => {
+    if (dayjs(data.endingAt).isBefore(data.startingAt)) {
       throw new TRPCError({
         code: 'BAD_REQUEST',
         message: 'Das Enddatum kann nicht vor dem Startdatum liegen.',
       })
     }
 
     await prisma.programmPunkt.create({
-      data: input,
+      data: {
+        ...data,
+        veranstaltungId: veranstaltungId,
+      },
     })
   },
 })

apps/api/src/services/program/program.delete.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod'
+import prisma from '../../prisma.js'
+import { defineProtectedMutateProcedure } from '../../types/defineProcedure.js'
+
+export const programDeleteProcedure = defineProtectedMutateProcedure({
+  key: 'delete',
+  roleIds: ['ADMIN'],
+  inputSchema: z.strictObject({
+    programId: z.string().uuid(),
+  }),
+  handler: async ({ input: { programId } }) => {
+    await prisma.programmPunkt.delete({
+      where: {
+        id: programId,
+      },
+    })
+  },
+})

apps/api/src/services/program/program.edit.ts

@@ -0,0 +1,36 @@
+import { TRPCError } from '@trpc/server'
+import dayjs from 'dayjs'
+import { z } from 'zod'
+import prisma from '../../prisma.js'
+import { defineProtectedMutateProcedure } from '../../types/defineProcedure.js'
+
+export const programEditProcedure = defineProtectedMutateProcedure({
+  key: 'edit',
+  roleIds: ['ADMIN'],
+  inputSchema: z.strictObject({
+    programId: z.string().uuid(),
+    data: z.object({
+      name: z.string(),
+      description: z.string(),
+      location: z.string(),
+      responsible: z.string(),
+      startingAt: z.date(),
+      endingAt: z.date(),
+    }),
+  }),
+  handler: async ({ input: { programId, data } }) => {
+    if (dayjs(data.endingAt).isBefore(data.startingAt)) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: 'Das Enddatum kann nicht vor dem Startdatum liegen.',
+      })
+    }
+
+    await prisma.programmPunkt.update({
+      where: {
+        id: programId,
+      },
+      data: data,
+    })
+  },
+})

apps/api/src/services/program/program.get.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod'
+import prisma from '../../prisma.js'
+import { defineProtectedMutateProcedure } from '../../types/defineProcedure.js'
+
+export const programGetProcedure = defineProtectedMutateProcedure({
+  key: 'get',
+  roleIds: ['ADMIN'],
+  inputSchema: z.strictObject({
+    programId: z.string().uuid(),
+  }),
+  handler: async ({ input }) => {
+    return await prisma.programmPunkt.findUniqueOrThrow({
+      where: {
+        id: input.programId,
+      },
+      select: {
+        name: true,
+        description: true,
+        location: true,
+        responsible: true,
+        startingAt: true,
+        endingAt: true,
+      },
+    })
+  },
+})

apps/api/src/services/program/program.list.ts

@@ -14,6 +14,7 @@ export const programListProcedure = defineProtectedQueryProcedure({
         veranstaltungId: input.veranstaltungId,
       },
       select: {
+        id: true,
         name: true,
         description: true,
         location: true,

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

@@ -2,14 +2,23 @@
 import { mergeRouters } from '../../trpc.js'
 import { programSearchLocationProcedure, programSearchResponsiblesProcedure } from './program.autocomplete.js'
 import { programCreateProcedure } from './program.create.js'
+import { programDeleteProcedure } from './program.delete.js'
+import { programEditProcedure } from './program.edit.js'
+import { programGetProcedure } from './program.get.js'
 import { programListProcedure } from './program.list.js'
 
 // Import Routes here - do not delete this line
 
 export const programRouter = mergeRouters(
+  // Queries
   programListProcedure,
-  programCreateProcedure,
+  programGetProcedure,
   programSearchLocationProcedure,
-  programSearchResponsiblesProcedure
+  programSearchResponsiblesProcedure,
+
+  // Mutations
+  programCreateProcedure,
+  programEditProcedure,
+  programDeleteProcedure
   // Add Routes here - do not delete this line
 )

apps/api/src/services/unterveranstaltung/unterveranstaltungList.ts

@@ -11,7 +11,18 @@ export const unterveranstaltungListProcedure = defineProtectedQueryProcedure({
   key: 'list',
   roleIds: [Role.ADMIN, Role.GLIEDERUNG_ADMIN],
   inputSchema: z.strictObject({
-    veranstaltungId: z.string().uuid().optional(),
+    mode: z
+      .discriminatedUnion('mode', [
+        z.strictObject({
+          mode: z.literal('veranstaltung'),
+          veranstaltungId: z.string().uuid(),
+        }),
+        z.strictObject({
+          mode: z.literal('gliederung'),
+          gliederungId: z.string().uuid(),
+        }),
+      ])
+      .optional(),
     table: defineTableInput({
       filter: {
         gliederungName: z.string().optional(),
@@ -24,12 +35,13 @@ export const unterveranstaltungListProcedure = defineProtectedQueryProcedure({
   async handler({
     ctx: { account },
     input: {
-      veranstaltungId,
+      mode,
       table: { filter, pagination },
     },
   }) {
     const where: Prisma.UnterveranstaltungWhereInput = {
-      veranstaltungId,
+      veranstaltungId: mode?.mode === 'veranstaltung' ? mode.veranstaltungId : undefined,
+      gliederungId: mode?.mode === 'gliederung' ? mode.gliederungId : undefined,
       gliederung: {
         name: {
           contains: filter?.gliederungName,
@@ -49,7 +61,7 @@ export const unterveranstaltungListProcedure = defineProtectedQueryProcedure({
     // Role-based Filter
     if (account.role !== Role.ADMIN) {
       const gliederung = await getGliederungRequireAdmin(account.id)
-      where.gliederungId = gliederung.id
+      where.gliederungId = gliederung.id // TODO:
     }
 
     const total = await prisma.unterveranstaltung.count({ where })

apps/api/src/services/veranstaltung/veranstaltungPublicGet.ts

@@ -19,6 +19,7 @@ export const veranstaltungPublicGetProcedure = definePublicQueryProcedure({
         ort: true,
         programmPunkte: {
           select: {
+            id: true,
             name: true,
             description: true,
             location: true,