Mrc-5298-Role Update Endpoints

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

@@ -6,6 +6,7 @@ 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.UpdateRolePermissions
 import packit.service.RoleService
 
 @Controller
@@ -21,12 +22,23 @@ 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()
     }

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/PacketGroup.kt

@@ -6,7 +6,7 @@ import jakarta.persistence.*
 @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)

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

@@ -29,3 +29,38 @@ 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
+    }
+}

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/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,7 @@ interface RoleRepository : JpaRepository<Role, Int>
     fun findByName(name: String): Role?
     fun existsByName(name: String): Boolean
     fun findByNameIn(names: List<String>): List<Role>
+
+    @Transactional
     fun deleteByName(name: String)
 }

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

@@ -0,0 +1,81 @@
+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 getRolePermissionsToUpdate(role: Role, addRolePermissions: List<UpdateRolePermission>): List<RolePermission>
+    fun removeRolePermissionsFromRole(role: Role, removeRolePermissions: List<UpdateRolePermission>)
+    fun getAddRolePermissionsFromRole(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
+{
+    override fun getRolePermissionsToUpdate(
+        role: Role,
+        addRolePermissions: List<UpdateRolePermission>
+    ): List<RolePermission>
+    {
+        return addRolePermissions.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 getAddRolePermissionsFromRole(
+        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
+    }
+}

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

@@ -4,12 +4,13 @@ import org.springframework.http.HttpStatus
 import org.springframework.security.core.GrantedAuthority
 import org.springframework.security.core.authority.SimpleGrantedAuthority
 import org.springframework.stereotype.Service
-import org.springframework.transaction.annotation.Transactional
 import packit.exceptions.PackitException
 import packit.model.Permission
 import packit.model.Role
 import packit.model.RolePermission
 import packit.model.dto.CreateRole
+import packit.model.dto.UpdateRolePermission
+import packit.model.dto.UpdateRolePermissions
 import packit.repository.RoleRepository
 
 interface RoleService
@@ -20,12 +21,14 @@ interface RoleService
     fun getGrantedAuthorities(roles: List<Role>): MutableList<GrantedAuthority>
     fun createRole(createRole: CreateRole)
     fun deleteRole(roleName: String)
+    fun updatePermissionsToRole(roleName: String, updateRolePermissions: UpdateRolePermissions)
 }
 
 @Service
 class BaseRoleService(
     private val roleRepository: RoleRepository,
-    private val permissionService: PermissionService
+    private val permissionService: PermissionService,
+    private val rolePermissionService: RolePermissionService
 ) : RoleService
 {
     override fun getUsernameRole(username: String): Role
@@ -52,17 +55,36 @@ class BaseRoleService(
         saveRole(createRole.name, permissions)
     }
 
-    @Transactional
     override fun deleteRole(roleName: String)
     {
-
         if (!roleRepository.existsByName(roleName))
         {
             throw PackitException("roleNotFound", HttpStatus.BAD_REQUEST)
         }
         roleRepository.deleteByName(roleName)
     }
 
+    override fun updatePermissionsToRole(roleName: String, updateRolePermissions: UpdateRolePermissions)
+    {
+        val role = roleRepository.findByName(roleName)
+            ?: throw PackitException("roleNotFound", HttpStatus.BAD_REQUEST)
+
+        val roleAfterPermissionAdd = addRolePermissionsToRole(role, updateRolePermissions.addPermissions)
+
+        rolePermissionService.removeRolePermissionsFromRole(
+            roleAfterPermissionAdd,
+            updateRolePermissions.removePermissions
+        )
+    }
+
+    internal fun addRolePermissionsToRole(role: Role, addRolePermissions: List<UpdateRolePermission>): Role
+    {
+        val rolePermissionsToAdd =
+            rolePermissionService.getAddRolePermissionsFromRole(role, addRolePermissions)
+        role.rolePermissions.addAll(rolePermissionsToAdd)
+        return roleRepository.save(role)
+    }
+
     internal fun saveRole(roleName: String, permissions: List<Permission> = listOf())
     {
         if (roleRepository.existsByName(roleName))

api/app/src/main/resources/errorBundle.properties

@@ -15,4 +15,9 @@ userAlreadyExists=User already exists
 userNotFound=User not found
 roleAlreadyExists=Role already exists
 roleNotFound=Role not found
+rolePermissionAlreadyExists=Role permission already exists
+packetNotFound=Packet not found
+packetGroupNotFound=Packet group not found
+tagNotFound=Tag not found
+rolePermissionDoesNotExist=Permission does not exist on Role
 adminRoleNotFound=Admin role not found, contact your administrator