Mrc-5298-Role Update Endpoints

api/app/src/main/kotlin/packit/controllers/RoleController.kt

@@ -6,6 +6,9 @@ import org.springframework.stereotype.Controller
 import org.springframework.validation.annotation.Validated
 import org.springframework.web.bind.annotation.*
 import packit.model.dto.CreateRole
+import packit.model.dto.RoleDto
+import packit.model.dto.UpdateRolePermissions
+import packit.model.toDto
 import packit.service.RoleService
 
 @Controller
@@ -21,13 +24,44 @@ class RoleController(private val roleService: RoleService)
         return ResponseEntity.ok(mapOf("message" to "Role created"))
     }
 
-    @DeleteMapping("/{name}")
+    @DeleteMapping("/{roleName}")
     fun deleteRole(
-        @PathVariable name: String
+        @PathVariable roleName: String
+    ): ResponseEntity<Map<String, String?>>
+    {
+        roleService.deleteRole(roleName)
+
+        return ResponseEntity.noContent().build()
+    }
+
+    @PutMapping("/update-permissions/{roleName}")
+    fun updatePermissionsToRole(
+        @RequestBody @Validated updateRolePermissions: UpdateRolePermissions,
+        @PathVariable roleName: String
     ): ResponseEntity<Unit>
     {
-        roleService.deleteRole(name)
+        roleService.updatePermissionsToRole(roleName, updateRolePermissions)
 
         return ResponseEntity.noContent().build()
     }
+
+    @GetMapping("/names")
+    fun getRoleNames(): ResponseEntity<List<String>>
+    {
+        return ResponseEntity.ok(roleService.getRoleNames())
+    }
+
+    @GetMapping
+    fun getRolesWithRelationships(@RequestParam isUsername: Boolean?): ResponseEntity<List<RoleDto>>
+    {
+        val roles = roleService.getRoles(isUsername)
+        return ResponseEntity.ok(roles.map { it.toDto() })
+    }
+
+    @GetMapping("/{roleName}")
+    fun getRole(@PathVariable roleName: String): ResponseEntity<RoleDto>
+    {
+        val role = roleService.getRole(roleName)
+        return ResponseEntity.ok(role.toDto())
+    }
 }

api/app/src/main/kotlin/packit/exceptions/PackitExceptionHandler.kt

@@ -53,6 +53,13 @@ class PackitExceptionHandler
             .toResponseEntity()
     }
 
+    @ExceptionHandler(IllegalArgumentException::class)
+    fun handleIllegalArgumentException(e: Exception): ResponseEntity<String>
+    {
+        return ErrorDetail(HttpStatus.BAD_REQUEST, e.message ?: "Invalid argument")
+            .toResponseEntity()
+    }
+
     @ExceptionHandler(AccessDeniedException::class, AuthenticationException::class)
     fun handleAccessDenied(e: Exception): ResponseEntity<String>
     {

api/app/src/main/kotlin/packit/model/Packet.kt

@@ -3,6 +3,7 @@ package packit.model
 import jakarta.persistence.*
 import org.hibernate.annotations.JdbcTypeCode
 import org.hibernate.type.SqlTypes
+import packit.model.dto.BasicPacketDto
 import packit.model.dto.PacketDto
 
 @Entity
@@ -32,3 +33,5 @@ class Packet(
 fun Packet.toDto() = PacketDto(
     id, name, displayName, parameters, published, importTime, startTime, endTime
 )
+
+fun Packet.toBasicDto() = BasicPacketDto(name, id)

api/app/src/main/kotlin/packit/model/PacketGroup.kt

@@ -1,14 +1,17 @@
 package packit.model
 
 import jakarta.persistence.*
+import packit.model.dto.PacketGroupDto
 
 @Entity
 @Table(name = "packet_group")
 class PacketGroup(
     var name: String,
-    @OneToMany(mappedBy = "packetGroup")
+    @OneToMany(mappedBy = "packetGroup", cascade = [CascadeType.ALL])
     var rolePermissions: MutableList<RolePermission> = mutableListOf(),
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     var id: Int? = null
 )
+
+fun PacketGroup.toDto() = PacketGroupDto(name, id!!)

api/app/src/main/kotlin/packit/model/Role.kt

@@ -1,6 +1,7 @@
 package packit.model
 
 import jakarta.persistence.*
+import packit.model.dto.RoleDto
 
 @Entity
 @Table(name = "`role`")
@@ -9,9 +10,14 @@ class Role(
     var isUsername: Boolean = false,
     @OneToMany(mappedBy = "role", fetch = FetchType.EAGER, cascade = [CascadeType.ALL])
     var rolePermissions: MutableList<RolePermission> = mutableListOf(),
-    @ManyToMany(mappedBy = "roles", fetch = FetchType.LAZY)
+    @ManyToMany(mappedBy = "roles", fetch = FetchType.EAGER)
     var users: MutableList<User> = mutableListOf(),
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     var id: Int? = null,
 )
+
+fun Role.toDto() =
+    RoleDto(
+        name, rolePermissions.map { it.toDto() }, users.map { it.toDto() }, id!!
+    )

api/app/src/main/kotlin/packit/model/RolePermission.kt

@@ -1,6 +1,7 @@
 package packit.model
 
 import jakarta.persistence.*
+import packit.model.dto.RolePermissionDto
 
 @Entity
 @Table(name = "role_permission")
@@ -29,3 +30,46 @@ class RolePermission(
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     var id: Int? = null,
 )
+{
+    init
+    {
+        val nonNullFields = listOf(packet, tag, packetGroup).count { it != null }
+        require(nonNullFields <= 1) {
+            "Either all of packet, tag, packetGroup should be null or only one of them should be not null"
+        }
+    }
+
+    override fun equals(other: Any?): Boolean
+    {
+        return when
+        {
+            this === other -> true
+            other !is RolePermission -> false
+            role.name != other.role.name -> false
+            permission.name != other.permission.name -> false
+            packet?.id != other.packet?.id -> false
+            packetGroup?.id != other.packetGroup?.id -> false
+            tag?.id != other.tag?.id -> false
+            else -> true
+        }
+    }
+
+    override fun hashCode(): Int
+    {
+        val prime = 31
+        var result = role.name.hashCode()
+        result = prime * result + permission.name.hashCode()
+        result = prime * result + packet?.id.hashCode()
+        result = prime * result + packetGroup?.id.hashCode()
+        result = prime * result + tag?.id.hashCode()
+        return result
+    }
+}
+
+fun RolePermission.toDto() = RolePermissionDto(
+    permission.name,
+    packet?.toBasicDto(),
+    tag?.toDto(),
+    packetGroup?.toDto(),
+    id!!
+)

api/app/src/main/kotlin/packit/model/Tag.kt

@@ -1,6 +1,7 @@
 package packit.model
 
 import jakarta.persistence.*
+import packit.model.dto.TagDto
 
 @Entity
 @Table(name = "tag")
@@ -14,3 +15,5 @@ class Tag(
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     val id: Int? = null,
 )
+
+fun Tag.toDto() = TagDto(name, id!!)

api/app/src/main/kotlin/packit/model/User.kt

@@ -1,6 +1,7 @@
 package packit.model
 
 import jakarta.persistence.*
+import packit.model.dto.UserDto
 import java.time.Instant
 import java.util.*
 
@@ -25,3 +26,5 @@ class User(
     @GeneratedValue(strategy = GenerationType.UUID)
     val id: UUID? = null
 )
+
+fun User.toDto() = UserDto(username, id!!)

api/app/src/main/kotlin/packit/model/dto/BasicPacketDto.kt

@@ -0,0 +1,6 @@
+package packit.model.dto
+
+data class BasicPacketDto(
+    val name: String,
+    val id: String,
+)

api/app/src/main/kotlin/packit/model/dto/PacketGroupDto.kt

@@ -0,0 +1,3 @@
+package packit.model.dto
+
+data class PacketGroupDto(val name: String, val id: Int)

api/app/src/main/kotlin/packit/model/dto/RoleDto.kt

@@ -0,0 +1,8 @@
+package packit.model.dto
+
+data class RoleDto(
+    var name: String,
+    var rolePermissions: List<RolePermissionDto> = listOf(),
+    var users: List<UserDto> = listOf(),
+    var id: Int
+)

api/app/src/main/kotlin/packit/model/dto/RolePermissionDto.kt

@@ -0,0 +1,9 @@
+package packit.model.dto
+
+data class RolePermissionDto(
+    val permission: String,
+    val packet: BasicPacketDto? = null,
+    val tag: TagDto? = null,
+    val packetGroup: PacketGroupDto? = null,
+    val id: Int,
+)

api/app/src/main/kotlin/packit/model/dto/TagDto.kt

@@ -0,0 +1,3 @@
+package packit.model.dto
+
+data class TagDto(val name: String, val id: Int)

api/app/src/main/kotlin/packit/model/dto/UpdateRolePermission.kt

@@ -0,0 +1,25 @@
+package packit.model.dto
+
+import org.jetbrains.annotations.NotNull
+
+data class UpdateRolePermissions(
+    val addPermissions: List<UpdateRolePermission> = listOf(),
+    val removePermissions: List<UpdateRolePermission> = listOf()
+)
+
+data class UpdateRolePermission(
+    @field:NotNull
+    val permission: String,
+    val packetId: String? = null,
+    val tagId: Int? = null,
+    val packetGroupId: Int? = null
+)
+{
+    init
+    {
+        val nonNullFields = listOf(packetId, tagId, packetGroupId).count { it != null }
+        require(nonNullFields <= 1) {
+            "Either all of packetId, tagId, packetGroupId should be null or only one of them should be not null"
+        }
+    }
+}

api/app/src/main/kotlin/packit/model/dto/UserDto.kt

@@ -0,0 +1,5 @@
+package packit.model.dto
+
+import java.util.*
+
+data class UserDto(val username: String, val id: UUID)

api/app/src/main/kotlin/packit/repository/PermissionRepository.kt

@@ -8,4 +8,5 @@ import packit.model.Permission
 interface PermissionRepository : JpaRepository<Permission, Int>
 {
     fun findByNameIn(names: List<String>): List<Permission>
+    fun findByName(name: String): Permission?
 }

api/app/src/main/kotlin/packit/repository/RolePermissionRepository.kt

@@ -0,0 +1,17 @@
+package packit.repository
+
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Modifying
+import org.springframework.data.jpa.repository.Query
+import org.springframework.stereotype.Repository
+import org.springframework.transaction.annotation.Transactional
+import packit.model.RolePermission
+
+@Repository
+interface RolePermissionRepository : JpaRepository<RolePermission, Int>
+{
+    @Modifying
+    @Transactional
+    @Query("DELETE FROM RolePermission rp WHERE rp.id IN :ids")
+    fun deleteAllByIdIn(ids: List<Int>)
+}

api/app/src/main/kotlin/packit/repository/RoleRepository.kt

@@ -2,6 +2,7 @@ package packit.repository
 
 import org.springframework.data.jpa.repository.JpaRepository
 import org.springframework.stereotype.Repository
+import org.springframework.transaction.annotation.Transactional
 import packit.model.Role
 
 @Repository
@@ -10,5 +11,8 @@ interface RoleRepository : JpaRepository<Role, Int>
     fun findByName(name: String): Role?
     fun existsByName(name: String): Boolean
     fun findByNameIn(names: List<String>): List<Role>
+    fun findAllByIsUsername(isUsername: Boolean): List<Role>
+
+    @Transactional
     fun deleteByName(name: String)
 }

api/app/src/main/kotlin/packit/service/RolePermissionService.kt

@@ -0,0 +1,80 @@
+package packit.service
+
+import org.springframework.http.HttpStatus
+import org.springframework.stereotype.Service
+import packit.exceptions.PackitException
+import packit.model.Role
+import packit.model.RolePermission
+import packit.model.dto.UpdateRolePermission
+import packit.repository.*
+
+interface RolePermissionService
+{
+    fun removeRolePermissionsFromRole(role: Role, removeRolePermissions: List<UpdateRolePermission>)
+    fun getRolePermissionsToAdd(role: Role, addRolePermissions: List<UpdateRolePermission>): List<RolePermission>
+}
+
+@Service
+class BaseRolePermissionService(
+    private val permissionRepository: PermissionRepository,
+    private val packetRepository: PacketRepository,
+    private val packetGroupRepository: PacketGroupRepository,
+    private val tagRepository: TagRepository,
+    private val rolePermissionRepository: RolePermissionRepository
+) : RolePermissionService
+{
+    internal fun getRolePermissionsToUpdate(
+        role: Role,
+        updateRolePermissions: List<UpdateRolePermission>
+    ): List<RolePermission>
+    {
+        return updateRolePermissions.map { addRolePermission ->
+            val permission = permissionRepository.findByName(addRolePermission.permission)
+                ?: throw PackitException("invalidPermissionsProvided", HttpStatus.BAD_REQUEST)
+
+            RolePermission(
+                role = role,
+                permission = permission,
+                packet = addRolePermission.packetId?.let {
+                    packetRepository.findById(it)
+                        .orElseThrow { PackitException("packetNotFound", HttpStatus.BAD_REQUEST) }
+                },
+                packetGroup = addRolePermission.packetGroupId?.let {
+                    packetGroupRepository.findById(it)
+                        .orElseThrow { PackitException("packetGroupNotFound", HttpStatus.BAD_REQUEST) }
+                },
+                tag = addRolePermission.tagId?.let {
+                    tagRepository.findById(it).orElseThrow { PackitException("tagNotFound", HttpStatus.BAD_REQUEST) }
+                }
+            )
+        }
+    }
+
+    override fun removeRolePermissionsFromRole(role: Role, removeRolePermissions: List<UpdateRolePermission>)
+    {
+        val rolePermissionsToRemove = getRolePermissionsToUpdate(role, removeRolePermissions)
+
+        val matchedRolePermissionsToRemove = rolePermissionsToRemove.map { rolePermissionToRemove ->
+            val matchedPermission = role.rolePermissions.find { rolePermissionToRemove == it }
+                ?: throw PackitException("rolePermissionDoesNotExist", HttpStatus.BAD_REQUEST)
+
+            matchedPermission
+        }
+
+        rolePermissionRepository.deleteAllByIdIn(matchedRolePermissionsToRemove.map { it.id!! })
+    }
+
+    override fun getRolePermissionsToAdd(
+        role: Role,
+        addRolePermissions: List<UpdateRolePermission>
+    ): List<RolePermission>
+    {
+        val rolePermissionsToAdd = getRolePermissionsToUpdate(role, addRolePermissions)
+        if (rolePermissionsToAdd.any { role.rolePermissions.contains(it) })
+        {
+            throw PackitException("rolePermissionAlreadyExists", HttpStatus.BAD_REQUEST)
+        }
+
+        return rolePermissionsToAdd
+    }
+}