feat(fullstack): Add notifications, user is now an entity, add testcontainers, rework custom permissions, get user from JWT in endpoints

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/application_form/ApplicationForm.kt

@@ -3,8 +3,8 @@ package com.betriebsratkanzlei.legalconsenthub.application_form
 import com.betriebsratkanzlei.legalconsenthub.form_element.FormElementSection
 import com.betriebsratkanzlei.legalconsenthub.user.User
 import com.betriebsratkanzlei.legalconsenthub_api.model.ApplicationFormStatus
-import jakarta.persistence.AttributeOverride
-import jakarta.persistence.AttributeOverrides
+import jakarta.persistence.JoinColumn
+import jakarta.persistence.ManyToOne
 import jakarta.persistence.CascadeType
 import jakarta.persistence.Column
 import jakarta.persistence.Entity
@@ -14,7 +14,7 @@ import jakarta.persistence.EnumType
 import jakarta.persistence.GeneratedValue
 import jakarta.persistence.Id
 import jakarta.persistence.OneToMany
-import jakarta.persistence.Embedded
+
 import org.springframework.data.annotation.CreatedDate
 import org.springframework.data.annotation.LastModifiedDate
 import org.springframework.data.jpa.domain.support.AuditingEntityListener
@@ -43,18 +43,12 @@ class ApplicationForm(
     @Column(nullable = false)
     var status: ApplicationFormStatus = ApplicationFormStatus.DRAFT,
 
-    @Embedded
-    @AttributeOverrides(
-        AttributeOverride(name = "id", column = Column(name = "created_by_id", nullable = false)),
-        AttributeOverride(name = "name", column = Column(name = "created_by_name", nullable = false))
-    )
+    @ManyToOne
+    @JoinColumn(name = "created_by_id", nullable = false)
     var createdBy: User,
 
-    @Embedded
-    @AttributeOverrides(
-        AttributeOverride(name = "id", column = Column(name = "last_modified_by_id", nullable = false)),
-        AttributeOverride(name = "name", column = Column(name = "last_modified_by_name", nullable = false))
-    )
+    @ManyToOne
+    @JoinColumn(name = "last_modified_by_id", nullable = false)
     var lastModifiedBy: User,
 
     @CreatedDate

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/application_form/ApplicationFormMapper.kt

@@ -1,17 +1,20 @@
 package com.betriebsratkanzlei.legalconsenthub.application_form
 
 import com.betriebsratkanzlei.legalconsenthub.form_element.FormElementSectionMapper
-import com.betriebsratkanzlei.legalconsenthub.security.CustomJwtTokenPrincipal
 import com.betriebsratkanzlei.legalconsenthub.user.User
 import com.betriebsratkanzlei.legalconsenthub.user.UserMapper
+import com.betriebsratkanzlei.legalconsenthub.user.UserService
 import com.betriebsratkanzlei.legalconsenthub_api.model.ApplicationFormDto
 import com.betriebsratkanzlei.legalconsenthub_api.model.CreateApplicationFormDto
-import org.springframework.security.core.context.SecurityContextHolder
 import org.springframework.stereotype.Component
 import java.time.LocalDateTime
 
 @Component
-class ApplicationFormMapper(private val formElementSectionMapper: FormElementSectionMapper, private val userMapper: UserMapper) {
+class ApplicationFormMapper(
+    private val formElementSectionMapper: FormElementSectionMapper, 
+    private val userMapper: UserMapper,
+    private val userService: UserService
+) {
     fun toApplicationFormDto(applicationForm: ApplicationForm): ApplicationFormDto {
         return ApplicationFormDto(
             id = applicationForm.id ?: throw IllegalStateException("ApplicationForm ID must not be null!"),
@@ -43,18 +46,15 @@ class ApplicationFormMapper(private val formElementSectionMapper: FormElementSec
     }
 
     fun toApplicationForm(createApplicationFormDto: CreateApplicationFormDto): ApplicationForm {
-        // TODO: Move this in upper layer
-        val principal = SecurityContextHolder.getContext().authentication.principal as CustomJwtTokenPrincipal
-        val createdBy = User(principal.name ?: "UNKNOWN USER", principal.id ?: "")
-        val lastModifiedBy = User(principal.name ?: "UNKNOWN USER", principal.id ?: "")
+        val currentUser = userService.getCurrentUser()
 
         val applicationForm = ApplicationForm(
             name = createApplicationFormDto.name,
             isTemplate = createApplicationFormDto.isTemplate,
             organizationId = createApplicationFormDto.organizationId ?: "",
             status = createApplicationFormDto.status ?: com.betriebsratkanzlei.legalconsenthub_api.model.ApplicationFormStatus.DRAFT,
-            createdBy = createdBy,
-            lastModifiedBy = lastModifiedBy,
+            createdBy = currentUser,
+            lastModifiedBy = currentUser,
         )
         applicationForm.formElementSections = createApplicationFormDto.formElementSections
             .map { formElementSectionMapper.toFormElementSection(it, applicationForm) }

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/application_form/ApplicationFormService.kt

@@ -5,9 +5,11 @@ import com.betriebsratkanzlei.legalconsenthub.error.ApplicationFormNotCreatedExc
 import com.betriebsratkanzlei.legalconsenthub.error.ApplicationFormNotDeletedException
 import com.betriebsratkanzlei.legalconsenthub.error.ApplicationFormNotFoundException
 import com.betriebsratkanzlei.legalconsenthub.error.ApplicationFormNotUpdatedException
+import com.betriebsratkanzlei.legalconsenthub.notification.NotificationService
 import com.betriebsratkanzlei.legalconsenthub_api.model.ApplicationFormDto
 import com.betriebsratkanzlei.legalconsenthub_api.model.ApplicationFormStatus
 import com.betriebsratkanzlei.legalconsenthub_api.model.CreateApplicationFormDto
+import com.betriebsratkanzlei.legalconsenthub_api.model.NotificationType
 import org.springframework.data.domain.Page
 import org.springframework.data.domain.PageRequest
 import org.springframework.stereotype.Service
@@ -16,7 +18,8 @@ import java.util.UUID
 @Service
 class ApplicationFormService(
     private val applicationFormRepository: ApplicationFormRepository,
-    private val applicationFormMapper: ApplicationFormMapper
+    private val applicationFormMapper: ApplicationFormMapper,
+    private val notificationService: NotificationService
 ) {
 
     fun createApplicationForm(createApplicationFormDto: CreateApplicationFormDto): ApplicationForm {
@@ -76,10 +79,61 @@ class ApplicationFormService(
 
         applicationForm.status = ApplicationFormStatus.SUBMITTED
 
-        return try {
+        val savedApplicationForm = try {
             applicationFormRepository.save(applicationForm)
         } catch (e: Exception) {
             throw ApplicationFormNotUpdatedException(e, id)
         }
+
+        // Create notifications for relevant users
+        createSubmissionNotifications(savedApplicationForm)
+
+        return savedApplicationForm
+    }
+
+    private fun createSubmissionNotifications(applicationForm: ApplicationForm) {
+        val title = "Neuer Mitbestimmungsantrag eingereicht"
+        val message = "Ein neuer Mitbestimmungsantrag '${applicationForm.name}' wurde von ${applicationForm.createdBy.name} eingereicht und wartet auf Ihre Bearbeitung."
+        val clickTarget = "/application-forms/${applicationForm.id}/0"
+
+        // Create notification for admin users
+        notificationService.createNotificationForUser(
+            title = title,
+            message = message,
+            clickTarget = clickTarget,
+            recipient = null,
+            targetGroup = "admin",
+            type = NotificationType.INFO
+        )
+
+        // Create notification for works council members
+        notificationService.createNotificationForUser(
+            title = title,
+            message = message,
+            clickTarget = clickTarget,
+            recipient = null,
+            targetGroup = "works_council_member",
+            type = NotificationType.INFO
+        )
+
+        // Create notification for employer
+        notificationService.createNotificationForUser(
+            title = title,
+            message = message,
+            clickTarget = clickTarget,
+            recipient = null,
+            targetGroup = "employer",
+            type = NotificationType.INFO
+        )
+
+        // Create notification for employee
+        notificationService.createNotificationForUser(
+            title = title,
+            message = message,
+            clickTarget = clickTarget,
+            recipient = null,
+            targetGroup = "employee",
+            type = NotificationType.INFO
+        )
     }
 }

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/comment/Comment.kt

@@ -3,10 +3,7 @@ package com.betriebsratkanzlei.legalconsenthub.comment;
 import com.betriebsratkanzlei.legalconsenthub.application_form.ApplicationForm
 import com.betriebsratkanzlei.legalconsenthub.form_element.FormElement
 import com.betriebsratkanzlei.legalconsenthub.user.User
-import jakarta.persistence.AttributeOverride
-import jakarta.persistence.AttributeOverrides
 import jakarta.persistence.Column
-import jakarta.persistence.Embedded
 import jakarta.persistence.Entity
 import jakarta.persistence.EntityListeners
 import jakarta.persistence.GeneratedValue;
@@ -30,11 +27,8 @@ class Comment(
     @Column(nullable = false)
     var message: String = "",
 
-    @Embedded
-    @AttributeOverrides(
-        AttributeOverride(name = "id", column = Column(name = "created_by_id", nullable = false)),
-        AttributeOverride(name = "name", column = Column(name = "created_by_name", nullable = false))
-    )
+    @ManyToOne
+    @JoinColumn(name = "created_by_id", nullable = false)
     var createdBy: User,
 
     @CreatedDate

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/comment/CommentMapper.kt

@@ -5,6 +5,7 @@ import com.betriebsratkanzlei.legalconsenthub.error.ApplicationFormNotFoundExcep
 import com.betriebsratkanzlei.legalconsenthub.error.FormElementNotFoundException
 import com.betriebsratkanzlei.legalconsenthub.form_element.FormElementRepository
 import com.betriebsratkanzlei.legalconsenthub.user.UserMapper
+import com.betriebsratkanzlei.legalconsenthub.user.UserService
 import com.betriebsratkanzlei.legalconsenthub_api.model.CommentDto
 import com.betriebsratkanzlei.legalconsenthub_api.model.CreateCommentDto
 import org.springframework.stereotype.Component
@@ -14,6 +15,7 @@ import java.util.UUID
 @Component
 class CommentMapper(
     private val userMapper: UserMapper,
+    private val userService: UserService,
     private val applicationFormRepository: ApplicationFormRepository,
     private val formElementRepository: FormElementRepository
 ) {
@@ -53,9 +55,11 @@ class CommentMapper(
         val formElement = formElementRepository.findById(formElementId)
             .orElseThrow { FormElementNotFoundException(formElementId) }
 
+        val currentUser = userService.getCurrentUser()
+
         return Comment(
             message = commentDto.message,
-            createdBy = userMapper.toUser(commentDto.createdBy),
+            createdBy = currentUser,
             applicationForm = applicationForm,
             formElement = formElement
         )

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/config/SecurityConfig.kt

@@ -9,6 +9,7 @@ import org.springframework.security.oauth2.jose.jws.SignatureAlgorithm
 import org.springframework.security.oauth2.jwt.JwtDecoder
 import org.springframework.security.oauth2.jwt.NimbusJwtDecoder
 import org.springframework.security.web.SecurityFilterChain
+import org.springframework.http.HttpMethod
 
 @Configuration
 @EnableWebSecurity
@@ -24,6 +25,8 @@ class SecurityConfig {
             authorizeHttpRequests {
                 authorize("/swagger-ui/**", permitAll)
                 authorize("/v3/**", permitAll)
+                // For user registration
+                authorize(HttpMethod.POST, "/users", permitAll)
                 authorize(anyRequest, authenticated)
             }
             oauth2ResourceServer {

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/config/TestContainersConfig.kt

@@ -0,0 +1,40 @@
+package com.betriebsratkanzlei.legalconsenthub.config
+
+import com.github.dockerjava.api.model.ExposedPort
+import com.github.dockerjava.api.model.HostConfig
+import com.github.dockerjava.api.model.PortBinding
+import com.github.dockerjava.api.model.Ports
+import org.springframework.boot.testcontainers.service.connection.ServiceConnection
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.context.annotation.Profile
+import org.testcontainers.containers.PostgreSQLContainer;
+import org.testcontainers.utility.DockerImageName
+
+@Configuration
+@Profile("testcontainers")
+class TestContainersConfig {
+
+    @Bean
+    @ServiceConnection
+    fun postgresContainer(): PostgreSQLContainer<*> {
+        return PostgreSQLContainer(DockerImageName.parse("postgres:17-alpine"))
+            .withDatabaseName("legalconsenthub")
+            .withUsername("legalconsenthub")
+            .withPassword("legalconsenthub")
+            .withExposedPorts(5432)
+            .withCreateContainerCmdModifier { cmd ->
+                cmd.withHostConfig(
+                    HostConfig().apply {
+                        this.withPortBindings(
+                            PortBinding(
+                                Ports.Binding.bindPort(5432),
+                                ExposedPort(5432)
+                            )
+                        )
+                    }
+                )
+            }
+            .withReuse(true)
+    }
+}

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/error/ExceptionHandler.kt

@@ -16,7 +16,7 @@ class ExceptionHandler {
     var logger = LoggerFactory.getLogger(ExceptionHandler::class.java)
 
     @ResponseBody
-    @ExceptionHandler(ApplicationFormNotFoundException::class)
+    @ExceptionHandler(ApplicationFormNotFoundException::class, UserNotFoundException::class)
     @ResponseStatus(HttpStatus.NOT_FOUND)
     fun handleNotFoundError(e: Exception): ResponseEntity<ProblemDetails> {
         logger.warn(e.message, e)
@@ -47,6 +47,22 @@ class ExceptionHandler {
             )
     }
 
+    @ResponseBody
+    @ExceptionHandler(UserAlreadyExistsException::class)
+    @ResponseStatus(HttpStatus.CONFLICT)
+    fun handleUserAlreadyExistsError(e: UserAlreadyExistsException): ResponseEntity<ProblemDetails> {
+        logger.warn(e.message, e)
+        return ResponseEntity.status(HttpStatus.CONFLICT).contentType(MediaType.APPLICATION_PROBLEM_JSON)
+            .body(
+                ProblemDetails(
+                    title = "Conflict",
+                    status = HttpStatus.CONFLICT.value(),
+                    type = URI.create("about:blank"),
+                    detail = e.message ?: "Resource already exists"
+                )
+            )
+    }
+
     @ResponseBody
     @ExceptionHandler(
         ApplicationFormNotCreatedException::class,

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/error/UserAlreadyExistsException.kt

@@ -0,0 +1,3 @@
+package com.betriebsratkanzlei.legalconsenthub.error
+
+class UserAlreadyExistsException(id: String): RuntimeException("User with ID $id already exists") 

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/error/UserNotFoundException.kt

@@ -0,0 +1,3 @@
+package com.betriebsratkanzlei.legalconsenthub.error
+
+class UserNotFoundException(id: String): RuntimeException("Couldn't find user with ID: $id") 

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/notification/Notification.kt

@@ -0,0 +1,52 @@
+package com.betriebsratkanzlei.legalconsenthub.notification
+
+import com.betriebsratkanzlei.legalconsenthub.user.User
+import com.betriebsratkanzlei.legalconsenthub_api.model.NotificationType
+import jakarta.persistence.Column
+import jakarta.persistence.JoinColumn
+import jakarta.persistence.ManyToOne
+import jakarta.persistence.Entity
+import jakarta.persistence.EntityListeners
+import jakarta.persistence.Enumerated
+import jakarta.persistence.EnumType
+import jakarta.persistence.GeneratedValue
+import jakarta.persistence.Id
+import org.springframework.data.annotation.CreatedDate
+import org.springframework.data.jpa.domain.support.AuditingEntityListener
+import java.time.LocalDateTime
+import java.util.UUID
+
+@Entity
+@EntityListeners(AuditingEntityListener::class)
+class Notification(
+    @Id
+    @GeneratedValue
+    var id: UUID? = null,
+
+    @Column(nullable = false)
+    var title: String = "",
+
+    @Column(nullable = false, columnDefinition = "TEXT")
+    var message: String = "",
+
+    @Column(nullable = false)
+    var clickTarget: String = "",
+
+    @Column(nullable = false)
+    var isRead: Boolean = false,
+
+    @ManyToOne
+    @JoinColumn(name = "recipient_id", nullable = true)
+    var recipient: User?,
+
+    @Column(nullable = false)
+    var targetGroup: String = "",
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    var type: NotificationType = NotificationType.INFO,
+
+    @CreatedDate
+    @Column(nullable = false)
+    var createdAt: LocalDateTime? = null
+) 

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/notification/NotificationController.kt

@@ -0,0 +1,102 @@
+package com.betriebsratkanzlei.legalconsenthub.notification
+
+import com.betriebsratkanzlei.legalconsenthub.security.CustomJwtTokenPrincipal
+import com.betriebsratkanzlei.legalconsenthub.user.UserService
+import com.betriebsratkanzlei.legalconsenthub_api.api.NotificationApi
+import com.betriebsratkanzlei.legalconsenthub_api.model.CreateNotificationDto
+import com.betriebsratkanzlei.legalconsenthub_api.model.NotificationDto
+import com.betriebsratkanzlei.legalconsenthub_api.model.PagedNotificationDto
+import org.springframework.http.ResponseEntity
+import org.springframework.security.core.context.SecurityContextHolder
+import org.springframework.web.bind.annotation.RestController
+import java.util.UUID
+
+@RestController
+class NotificationController(
+    private val notificationService: NotificationService,
+    private val notificationMapper: NotificationMapper,
+    private val pagedNotificationMapper: PagedNotificationMapper,
+    private val userService: UserService
+) : NotificationApi {
+
+    override fun getNotifications(page: Int, size: Int): ResponseEntity<PagedNotificationDto> {
+        val principal = SecurityContextHolder.getContext().authentication.principal as CustomJwtTokenPrincipal
+        val recipientId = principal.id ?: throw IllegalStateException("User ID not found")
+
+        val user = userService.getUserById(recipientId)
+
+        val notifications = if (user.role != null) {
+            notificationService.getNotificationsForUserAndGroup(
+                recipientId = recipientId,
+                userRole = user.role!!.value,
+                page = page,
+                size = size
+            )
+        } else {
+            notificationService.getNotificationsForUser(
+                recipientId = recipientId,
+                page = page,
+                size = size
+            )
+        }
+
+        return ResponseEntity.ok(pagedNotificationMapper.toPagedNotificationDto(notifications))
+    }
+
+    override fun getUnreadNotifications(): ResponseEntity<List<NotificationDto>> {
+        val principal = SecurityContextHolder.getContext().authentication.principal as CustomJwtTokenPrincipal
+        val recipientId = principal.id ?: throw IllegalStateException("User ID not found")
+
+        val user = userService.getUserById(recipientId)
+
+        val notifications = if (user.role != null) {
+            notificationService.getUnreadNotificationsForUserAndGroup(recipientId, user.role!!.value)
+        } else {
+            notificationService.getUnreadNotificationsForUser(recipientId)
+        }
+
+        return ResponseEntity.ok(notifications.map { notificationMapper.toNotificationDto(it) })
+    }
+
+    override fun getUnreadNotificationCount(): ResponseEntity<Long> {
+        val principal = SecurityContextHolder.getContext().authentication.principal as CustomJwtTokenPrincipal
+        val recipientId = principal.id ?: throw IllegalStateException("User ID not found")
+
+        val user = userService.getUserById(recipientId)
+
+        val count = if (user.role != null) {
+            notificationService.getUnreadNotificationCountForUserAndGroup(recipientId, user.role!!.value)
+        } else {
+            notificationService.getUnreadNotificationCount(recipientId)
+        }
+
+        return ResponseEntity.ok(count)
+    }
+
+    override fun markAllNotificationsAsRead(): ResponseEntity<Unit> {
+        val principal = SecurityContextHolder.getContext().authentication.principal as CustomJwtTokenPrincipal
+        val recipientId = principal.id ?: throw IllegalStateException("User ID not found")
+
+        val user = userService.getUserById(recipientId)
+
+        if (user.role != null) {
+            notificationService.markAllAsReadForUserAndGroup(recipientId, user.role!!.value)
+        } else {
+            notificationService.markAllAsRead(recipientId)
+        }
+
+        return ResponseEntity.noContent().build()
+    }
+
+    override fun markNotificationAsRead(id: UUID): ResponseEntity<NotificationDto> {
+        val notification = notificationService.markAsRead(id)
+            ?: return ResponseEntity.notFound().build()
+
+        return ResponseEntity.ok(notificationMapper.toNotificationDto(notification))
+    }
+
+    override fun createNotification(createNotificationDto: CreateNotificationDto): ResponseEntity<NotificationDto> {
+        val notification = notificationService.createNotification(createNotificationDto)
+        return ResponseEntity.ok(notificationMapper.toNotificationDto(notification))
+    }
+}

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/notification/NotificationMapper.kt

@@ -0,0 +1,38 @@
+package com.betriebsratkanzlei.legalconsenthub.notification
+
+import com.betriebsratkanzlei.legalconsenthub.user.UserMapper
+import com.betriebsratkanzlei.legalconsenthub_api.model.CreateNotificationDto
+import com.betriebsratkanzlei.legalconsenthub_api.model.NotificationDto
+import org.springframework.stereotype.Component
+
+@Component
+class NotificationMapper(
+    private val userMapper: UserMapper
+) {
+
+    fun toNotificationDto(notification: Notification): NotificationDto {
+        return NotificationDto(
+            id = notification.id!!,
+            title = notification.title,
+            message = notification.message,
+            clickTarget = notification.clickTarget,
+            isRead = notification.isRead,
+            recipient = notification.recipient?.let { userMapper.toUserDto(it) },
+            targetGroup = notification.targetGroup,
+            type = notification.type,
+            createdAt = notification.createdAt!!
+        )
+    }
+
+    fun toNotification(createNotificationDto: CreateNotificationDto): Notification {
+        return Notification(
+            title = createNotificationDto.title,
+            message = createNotificationDto.message,
+            clickTarget = createNotificationDto.clickTarget,
+            isRead = false,
+            recipient = createNotificationDto.recipient?.let { userMapper.toUser(it) },
+            targetGroup = createNotificationDto.targetGroup,
+            type = createNotificationDto.type
+        )
+    }
+}

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/notification/NotificationRepository.kt

@@ -0,0 +1,47 @@
+package com.betriebsratkanzlei.legalconsenthub.notification
+
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.Pageable
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Modifying
+import org.springframework.data.jpa.repository.Query
+import org.springframework.data.repository.query.Param
+import org.springframework.stereotype.Repository
+import java.util.UUID
+
+@Repository
+interface NotificationRepository : JpaRepository<Notification, UUID> {
+
+    fun findByRecipientIdOrderByCreatedAtDesc(recipientId: String?, pageable: Pageable): Page<Notification>
+
+    fun findByRecipientIdAndIsReadFalseOrderByCreatedAtDesc(recipientId: String?): List<Notification>
+
+    fun findByRecipientIsNullOrderByCreatedAtDesc(pageable: Pageable): Page<Notification>
+
+    fun findByRecipientIsNullAndIsReadFalseOrderByCreatedAtDesc(): List<Notification>
+
+    @Query("SELECT n FROM Notification n WHERE (n.recipient.id = :recipientId) OR (n.recipient IS NULL AND n.targetGroup = :targetGroup) OR (n.recipient IS NULL AND n.targetGroup = 'all') ORDER BY n.createdAt DESC")
+    fun findByRecipientIdOrTargetGroupOrderByCreatedAtDesc(@Param("recipientId") recipientId: String, @Param("targetGroup") targetGroup: String, pageable: Pageable): Page<Notification>
+
+    @Query("SELECT n FROM Notification n WHERE ((n.recipient.id = :recipientId) OR (n.recipient IS NULL AND n.targetGroup = :targetGroup) OR (n.recipient IS NULL AND n.targetGroup = 'all')) AND n.isRead = false ORDER BY n.createdAt DESC")
+    fun findByRecipientIdOrTargetGroupAndIsReadFalseOrderByCreatedAtDesc(@Param("recipientId") recipientId: String, @Param("targetGroup") targetGroup: String): List<Notification>
+
+    @Query("SELECT COUNT(n) FROM Notification n WHERE ((n.recipient.id = :recipientId) OR (n.recipient IS NULL AND n.targetGroup = :targetGroup) OR (n.recipient IS NULL AND n.targetGroup = 'all')) AND n.isRead = false")
+    fun countByRecipientIdOrTargetGroupAndIsReadFalse(@Param("recipientId") recipientId: String, @Param("targetGroup") targetGroup: String): Long
+
+    @Modifying
+    @Query("UPDATE Notification n SET n.isRead = true WHERE n.recipient.id = :recipientId")
+    fun markAllAsReadByRecipientId(@Param("recipientId") recipientId: String)
+
+    @Modifying
+    @Query("UPDATE Notification n SET n.isRead = true WHERE n.recipient IS NULL")
+    fun markAllAsReadForNullRecipients()
+
+    @Modifying
+    @Query("UPDATE Notification n SET n.isRead = true WHERE (n.recipient.id = :recipientId) OR (n.recipient IS NULL AND n.targetGroup = :targetGroup) OR (n.recipient IS NULL AND n.targetGroup = 'all')")
+    fun markAllAsReadByRecipientIdOrTargetGroup(@Param("recipientId") recipientId: String, @Param("targetGroup") targetGroup: String)
+
+    fun countByRecipientIdAndIsReadFalse(recipientId: String?): Long
+
+    fun countByRecipientIsNullAndIsReadFalse(): Long
+}

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/notification/NotificationService.kt

@@ -0,0 +1,87 @@
+package com.betriebsratkanzlei.legalconsenthub.notification
+
+import com.betriebsratkanzlei.legalconsenthub.user.User
+import com.betriebsratkanzlei.legalconsenthub_api.model.CreateNotificationDto
+import com.betriebsratkanzlei.legalconsenthub_api.model.NotificationType
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.PageRequest
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import java.util.UUID
+
+@Service
+class NotificationService(
+    private val notificationRepository: NotificationRepository,
+    private val notificationMapper: NotificationMapper
+) {
+
+    fun createNotification(createNotificationDto: CreateNotificationDto): Notification {
+        val notification = notificationMapper.toNotification(createNotificationDto)
+        return notificationRepository.save(notification)
+    }
+
+    fun createNotificationForUser(
+        title: String,
+        message: String,
+        clickTarget: String,
+        recipient: User?,
+        targetGroup: String,
+        type: NotificationType = NotificationType.INFO
+    ): Notification {
+        val notification = Notification(
+            title = title,
+            message = message,
+            clickTarget = clickTarget,
+            recipient = recipient,
+            targetGroup = targetGroup,
+            type = type
+        )
+        return notificationRepository.save(notification)
+    }
+
+    fun getNotificationsForUser(recipientId: String, page: Int = 0, size: Int = 20): Page<Notification> {
+        val pageable = PageRequest.of(page, size)
+        return notificationRepository.findByRecipientIdOrderByCreatedAtDesc(recipientId, pageable)
+    }
+
+    fun getNotificationsForUserAndGroup(recipientId: String, userRole: String, page: Int = 0, size: Int = 20): Page<Notification> {
+        val pageable = PageRequest.of(page, size)
+        return notificationRepository.findByRecipientIdOrTargetGroupOrderByCreatedAtDesc(recipientId, userRole, pageable)
+    }
+
+    fun getUnreadNotificationsForUser(recipientId: String): List<Notification> {
+        return notificationRepository.findByRecipientIdAndIsReadFalseOrderByCreatedAtDesc(recipientId)
+    }
+
+    fun getUnreadNotificationsForUserAndGroup(recipientId: String, userRole: String): List<Notification> {
+        return notificationRepository.findByRecipientIdOrTargetGroupAndIsReadFalseOrderByCreatedAtDesc(recipientId, userRole)
+    }
+
+    fun getUnreadNotificationCount(recipientId: String): Long {
+        return notificationRepository.countByRecipientIdAndIsReadFalse(recipientId)
+    }
+
+    fun getUnreadNotificationCountForUserAndGroup(recipientId: String, userRole: String): Long {
+        return notificationRepository.countByRecipientIdOrTargetGroupAndIsReadFalse(recipientId, userRole)
+    }
+
+    @Transactional
+    fun markAllAsRead(recipientId: String) {
+        notificationRepository.markAllAsReadByRecipientId(recipientId)
+    }
+
+    @Transactional
+    fun markAllAsReadForUserAndGroup(recipientId: String, userRole: String) {
+        notificationRepository.markAllAsReadByRecipientIdOrTargetGroup(recipientId, userRole)
+    }
+
+    fun markAsRead(notificationId: UUID): Notification? {
+        val notification = notificationRepository.findById(notificationId).orElse(null)
+        return if (notification != null) {
+            notification.isRead = true
+            notificationRepository.save(notification)
+        } else {
+            null
+        }
+    }
+}

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/notification/PagedNotificationMapper.kt

@@ -0,0 +1,25 @@
+package com.betriebsratkanzlei.legalconsenthub.notification
+
+import com.betriebsratkanzlei.legalconsenthub_api.model.PagedNotificationDto
+import org.springframework.data.domain.Page
+import org.springframework.stereotype.Component
+
+@Component
+class PagedNotificationMapper(
+    private val notificationMapper: NotificationMapper
+) {
+
+    fun toPagedNotificationDto(page: Page<Notification>): PagedNotificationDto {
+        return PagedNotificationDto(
+            content = page.content.map { notificationMapper.toNotificationDto(it) },
+            number = page.number,
+            propertySize = page.size,
+            numberOfElements = page.numberOfElements,
+            totalElements = page.totalElements,
+            totalPages = page.totalPages,
+            first = page.isFirst,
+            last = page.isLast,
+            empty = page.isEmpty
+        )
+    }
+} 

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/user/User.kt

@@ -1,9 +1,37 @@
 package com.betriebsratkanzlei.legalconsenthub.user
 
-import jakarta.persistence.Embeddable
+import com.betriebsratkanzlei.legalconsenthub_api.model.UserRole
+import com.betriebsratkanzlei.legalconsenthub_api.model.UserStatus
+import jakarta.persistence.*
+import org.springframework.data.annotation.CreatedDate
+import org.springframework.data.annotation.LastModifiedDate
+import org.springframework.data.jpa.domain.support.AuditingEntityListener
+import java.time.LocalDateTime
 
-@Embeddable
+@Entity
+@EntityListeners(AuditingEntityListener::class)
+@Table(name = "app_user")
 class User(
+    @Id
+    @Column(nullable = false)
+    var id: String,
+
+    @Column(nullable = false)
     var name: String,
-    var id: String
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    var status: UserStatus = UserStatus.ACTIVE,
+    
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = true)
+    var role: UserRole? = null,
+
+    @CreatedDate
+    @Column(nullable = false)
+    var createdAt: LocalDateTime? = null,
+
+    @LastModifiedDate
+    @Column(nullable = false)
+    var modifiedAt: LocalDateTime? = null
 )

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/user/UserController.kt

@@ -0,0 +1,29 @@
+package com.betriebsratkanzlei.legalconsenthub.user
+
+import com.betriebsratkanzlei.legalconsenthub_api.api.UserApi
+import com.betriebsratkanzlei.legalconsenthub_api.model.CreateUserDto
+import com.betriebsratkanzlei.legalconsenthub_api.model.UserDto
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+class UserController(
+    private val userService: UserService,
+    private val userMapper: UserMapper
+) : UserApi {
+
+    override fun createUser(createUserDto: CreateUserDto): ResponseEntity<UserDto> {
+        val user = userService.createUser(createUserDto)
+        return ResponseEntity.status(201).body(userMapper.toUserDto(user))
+    }
+
+    override fun getUserById(id: String): ResponseEntity<UserDto> {
+        val user = userService.getUserById(id)
+        return ResponseEntity.ok(userMapper.toUserDto(user))
+    }
+
+    override fun deleteUser(id: String): ResponseEntity<Unit> {
+        userService.deleteUser(id)
+        return ResponseEntity.noContent().build()
+    }
+} 

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/user/UserMapper.kt

@@ -9,6 +9,8 @@ class UserMapper() {
         return UserDto(
             id = user.id,
             name = user.name,
+            status = user.status,
+            role = user.role
         )
     }
 
@@ -16,6 +18,8 @@ class UserMapper() {
         return User(
             id = userDto.id,
             name = userDto.name,
+            status = userDto.status,
+            role = userDto.role
         )
     }
 }

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/user/UserRepository.kt

@@ -0,0 +1,7 @@
+package com.betriebsratkanzlei.legalconsenthub.user
+
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface UserRepository : JpaRepository<User, String> 

legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/user/UserService.kt

@@ -0,0 +1,46 @@
+package com.betriebsratkanzlei.legalconsenthub.user
+
+import com.betriebsratkanzlei.legalconsenthub.error.UserAlreadyExistsException
+import com.betriebsratkanzlei.legalconsenthub.error.UserNotFoundException
+import com.betriebsratkanzlei.legalconsenthub.security.CustomJwtTokenPrincipal
+import com.betriebsratkanzlei.legalconsenthub_api.model.CreateUserDto
+import com.betriebsratkanzlei.legalconsenthub_api.model.UserStatus
+import org.springframework.security.core.context.SecurityContextHolder
+import org.springframework.stereotype.Service
+
+@Service
+class UserService(
+    private val userRepository: UserRepository
+) {
+
+    fun getCurrentUser(): User {
+        val principal = SecurityContextHolder.getContext().authentication.principal as CustomJwtTokenPrincipal
+        val userId = principal.id ?: throw IllegalStateException("User ID not found")
+
+        return userRepository.findById(userId)
+            .orElseThrow { UserNotFoundException(userId) }
+    }
+
+    fun createUser(createUserDto: CreateUserDto): User {
+        if (userRepository.existsById(createUserDto.id)) {
+            throw UserAlreadyExistsException(createUserDto.id)
+        }
+
+        val user = User(
+            id = createUserDto.id,
+            name = createUserDto.name,
+            status = createUserDto.status ?: UserStatus.ACTIVE,
+            role = createUserDto.role
+        )
+        return userRepository.save(user)
+    }
+
+    fun getUserById(userId: String): User {
+        return userRepository.findById(userId)
+            .orElseThrow { UserNotFoundException(userId) }
+    }
+
+    fun deleteUser(userId: String) {
+        userRepository.deleteById(userId)
+    }
+}