announcements

web/src/actions/admin/announcement.ts

@@ -0,0 +1,161 @@
+import { type Prisma, type PrismaClient, type AnnouncementType } from '@prisma/client'
+import { ActionError } from 'astro:actions'
+import { z } from 'zod'
+
+import { defineProtectedAction } from '../../lib/defineProtectedAction'
+import { prisma as prismaInstance } from '../../lib/prisma'
+
+const prisma = prismaInstance as PrismaClient
+
+const selectAnnouncementReturnFields = {
+  id: true,
+  title: true,
+  content: true,
+  type: true,
+  startDate: true,
+  endDate: true,
+  isActive: true,
+  createdAt: true,
+  updatedAt: true,
+} as const satisfies Prisma.AnnouncementSelect
+
+export const adminAnnouncementActions = {
+  create: defineProtectedAction({
+    accept: 'form',
+    permissions: 'admin',
+    input: z.object({
+      title: z.string().min(1, 'Title is required').max(255, 'Title must be less than 255 characters'),
+      content: z
+        .string()
+        .min(1, 'Content is required')
+        .max(1000, 'Content must be less than 1000 characters'),
+      type: z.enum(['INFO', 'WARNING', 'ALERT']),
+      startDate: z.coerce.date(),
+      endDate: z.coerce.date().nullable().optional(),
+      isActive: z.coerce.boolean().default(true),
+    }),
+    handler: async (input) => {
+      const announcement = await prisma.announcement.create({
+        data: {
+          ...input,
+          endDate: input.endDate || null,
+        },
+        select: selectAnnouncementReturnFields,
+      })
+
+      return { announcement }
+    },
+  }),
+
+  update: defineProtectedAction({
+    accept: 'form',
+    permissions: 'admin',
+    input: z.object({
+      id: z.coerce.number().int().positive(),
+      title: z.string().min(1, 'Title is required').max(255, 'Title must be less than 255 characters'),
+      content: z
+        .string()
+        .min(1, 'Content is required')
+        .max(1000, 'Content must be less than 1000 characters'),
+      type: z.enum(['INFO', 'WARNING', 'ALERT']),
+      startDate: z.coerce.date(),
+      endDate: z.coerce.date().nullable().optional(),
+      isActive: z.coerce.boolean().default(true),
+    }),
+    handler: async (input) => {
+      const announcement = await prisma.announcement.findUnique({
+        where: {
+          id: input.id,
+        },
+        select: {
+          id: true,
+        },
+      })
+
+      if (!announcement) {
+        throw new ActionError({
+          code: 'BAD_REQUEST',
+          message: 'Announcement not found',
+        })
+      }
+
+      const updatedAnnouncement = await prisma.announcement.update({
+        where: { id: announcement.id },
+        data: {
+          ...input,
+          endDate: input.endDate || null,
+        },
+        select: selectAnnouncementReturnFields,
+      })
+
+      return { updatedAnnouncement }
+    },
+  }),
+
+  delete: defineProtectedAction({
+    accept: 'form',
+    permissions: 'admin',
+    input: z.object({
+      id: z.coerce.number().int().positive(),
+    }),
+    handler: async (input) => {
+      const announcement = await prisma.announcement.findUnique({
+        where: {
+          id: input.id,
+        },
+        select: {
+          id: true,
+        },
+      })
+
+      if (!announcement) {
+        throw new ActionError({
+          code: 'BAD_REQUEST',
+          message: 'Announcement not found',
+        })
+      }
+
+      await prisma.announcement.delete({
+        where: { id: announcement.id },
+      })
+
+      return { success: true }
+    },
+  }),
+
+  toggleActive: defineProtectedAction({
+    accept: 'form',
+    permissions: 'admin',
+    input: z.object({
+      id: z.coerce.number().int().positive(),
+      isActive: z.coerce.boolean(),
+    }),
+    handler: async (input) => {
+      const announcement = await prisma.announcement.findUnique({
+        where: {
+          id: input.id,
+        },
+        select: {
+          id: true,
+        },
+      })
+
+      if (!announcement) {
+        throw new ActionError({
+          code: 'BAD_REQUEST',
+          message: 'Announcement not found',
+        })
+      }
+
+      const updatedAnnouncement = await prisma.announcement.update({
+        where: { id: announcement.id },
+        data: {
+          isActive: input.isActive,
+        },
+        select: selectAnnouncementReturnFields,
+      })
+
+      return { updatedAnnouncement }
+    },
+  }),
+}

web/src/actions/admin/index.ts

@@ -1,3 +1,4 @@
+import { adminAnnouncementActions } from './announcement'
 import { adminAttributeActions } from './attribute'
 import { adminEventActions } from './event'
 import { adminServiceActions } from './service'
@@ -7,6 +8,7 @@ import { verificationStep } from './verificationStep'
 
 export const adminActions = {
   attribute: adminAttributeActions,
+  announcement: adminAnnouncementActions,
   event: adminEventActions,
   service: adminServiceActions,
   serviceSuggestions: adminServiceSuggestionActions,

web/src/actions/admin/user.ts

@@ -54,11 +54,8 @@ export const adminUserActions = {
         .nullable()
         .default(null) // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
         .transform((val) => val || null),
-      picture: z.string().max(255, 'Picture URL must be less than 255 characters').nullable().default(null),
       pictureFile: z.instanceof(File).optional(),
-      verifier: z.boolean().default(false),
-      admin: z.boolean().default(false),
-      spammer: z.boolean().default(false),
+      role: z.enum(['admin', 'verifier', 'spammer']),
       verifiedLink: z
         .string()
         .url('Invalid URL')
@@ -72,7 +69,7 @@ export const adminUserActions = {
         .default(null) // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
         .transform((val) => val || null),
     }),
-    handler: async ({ id, picture, pictureFile, ...valuesToUpdate }) => {
+    handler: async ({ id, pictureFile, ...valuesToUpdate }) => {
       const user = await prisma.user.findUnique({
         where: {
           id,
@@ -89,10 +86,10 @@ export const adminUserActions = {
         })
       }
 
-      let pictureUrl = picture ?? null
-      if (pictureFile && pictureFile.size > 0) {
-        pictureUrl = await saveFileLocally(pictureFile, pictureFile.name, 'users/pictures/')
-      }
+      const pictureUrl =
+        pictureFile && pictureFile.size > 0
+          ? await saveFileLocally(pictureFile, pictureFile.name, 'users/pictures/')
+          : null
 
       const updatedUser = await prisma.user.update({
         where: { id: user.id },
@@ -293,10 +290,9 @@ export const adminUserActions = {
       input: z.object({
         userId: z.coerce.number().int().positive(),
         points: z.coerce.number().int(),
-        action: z.string().min(1, 'Action is required'),
         description: z.string().min(1, 'Description is required'),
       }),
-      handler: async (input) => {
+      handler: async (input, context) => {
         // Check if the user exists
         const user = await prisma.user.findUnique({
           where: { id: input.userId },
@@ -314,9 +310,9 @@ export const adminUserActions = {
           data: {
             userId: input.userId,
             points: input.points,
-            action: input.action,
+            action: 'MANUAL_ADJUSTMENT',
             description: input.description,
-            processed: true,
+            grantedByUserId: context.locals.user.id,
           },
         })
       },