use validateId.kt

src/main/kotlin/di/useCaseModule.kt

@@ -53,7 +53,7 @@ val useCaseModule = module {
     single { DeleteTaskStateUseCase(get()) }
     single { GetAllTaskStatesByProjectIdUseCase(get(), get()) }
     single { GetTaskStateByIdUseCase(get()) }
-    single { GetTaskStateByTaskIdUseCase(get(), get()) }
+    single { GetTaskStateByTaskIdUseCase(get()) }
     single { GetTasksByTaskStateIdUseCase(get()) }
     single { UpdateTaskStateUseCase(get()) }
     single { GetAllTaskStatesUseCase(get()) }

src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByProjectIdUseCase.kt

@@ -3,19 +3,19 @@ package com.berlin.domain.usecase.audit_system
 import com.berlin.domain.exception.InvalidProjectIdException
 import com.berlin.domain.model.AuditLog
 import com.berlin.domain.repository.AuditRepository
+import com.berlin.domain.usecase.utils.isIDValid
 
 class GetAuditLogsByProjectIdUseCase(
     private val auditRepository: AuditRepository
 ) {
 
     operator fun invoke(projectId: String): List<AuditLog> {
 
-        if (!validateProjectId(projectId))
+        if (isIDValid(projectId).not())
             throw InvalidProjectIdException("Project ID must not be empty, blank, or purely numeric")
 
         return auditRepository.getAuditLogsByProjectId(projectId)
     }
 
-    private fun validateProjectId(projectId: String): Boolean =
-        projectId.isNotBlank() && !(projectId.all { it.isDigit() })
+
 }

src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByTaskIdUseCase.kt

@@ -3,17 +3,17 @@ package com.berlin.domain.usecase.audit_system
 import com.berlin.domain.exception.InvalidTaskIdException
 import com.berlin.domain.model.AuditLog
 import com.berlin.domain.repository.AuditRepository
+import com.berlin.domain.usecase.utils.isIDValid
 
 class GetAuditLogsByTaskIdUseCase(
     private val auditRepository: AuditRepository,
 ) {
 
     operator fun invoke(taskId: String): List<AuditLog> {
 
-        if (!validateTaskId(taskId)) throw InvalidTaskIdException("Task ID must not be empty, blank, or purely numeric")
+        if (isIDValid(taskId).not()) throw InvalidTaskIdException("Task ID must not be empty, blank, or purely numeric")
 
         return auditRepository.getAuditLogsByTaskId(taskId)
     }
 
-    private fun validateTaskId(projectId: String): Boolean = projectId.isNotBlank() && !(projectId.all { it.isDigit() })
 }

src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByUserIdUseCase.kt

@@ -3,20 +3,20 @@ package com.berlin.domain.usecase.audit_system
 import com.berlin.domain.exception.InvalidUserIdException
 import com.berlin.domain.model.AuditLog
 import com.berlin.domain.repository.AuditRepository
+import com.berlin.domain.usecase.utils.isIDValid
 
 class GetAuditLogsByUserIdUseCase(
     private val auditRepository: AuditRepository
 ) {
 
     operator fun invoke(userId:String): List<AuditLog>{
 
-        if (!validateUserId(userId))
+        if (isIDValid(userId).not())
             throw InvalidUserIdException("User ID must not be empty, blank, or purely numeric")
 
         return auditRepository.getAuditLogsByUserId(userId)
 
     }
 
-    private fun validateUserId(projectId: String): Boolean =
-        projectId.isNotBlank() && !(projectId.all { it.isDigit() })
+
 }

src/main/kotlin/domain/usecase/auth_service/GetUserByIDUseCase.kt

@@ -3,15 +3,15 @@ package com.berlin.domain.usecase.authService
 import com.berlin.domain.exception.InvalidUserIdException
 import com.berlin.domain.model.user.User
 import com.berlin.domain.repository.AuthenticationRepository
+import com.berlin.domain.usecase.utils.isIDValid
 
 class GetUserByIDUseCase(
     private val repository: AuthenticationRepository,
 ) {
     operator fun invoke(id: String): User {
-        if (!isIDValid(id))
+        if (isIDValid(id).not())
             throw InvalidUserIdException("User ID can't be empty or just digits")
         return repository.getUserById(id)
     }
-    private fun isIDValid(id: String): Boolean =
-        id.isNotBlank() && !id.all { it.isDigit() }
+
 }

src/main/kotlin/domain/usecase/project/DeleteProjectUseCase.kt

@@ -1,10 +1,10 @@
 package com.berlin.domain.usecase.project
 
 import com.berlin.domain.exception.InvalidProjectIdException
-import com.berlin.domain.exception.ProjectNotFoundException
 import com.berlin.domain.model.AuditLog
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
+import com.berlin.domain.usecase.utils.isIDValid
 import data.UserCache
 
 class DeleteProjectUseCase(
@@ -14,7 +14,7 @@ class DeleteProjectUseCase(
 ) {
     operator fun invoke(projectId: String): String {
 
-        if (!validateProjectId(projectId)) {
+        if (isIDValid(projectId).not()) {
             throw InvalidProjectIdException("Project ID must not be empty or blank")
         }
 
@@ -30,7 +30,6 @@ class DeleteProjectUseCase(
         return deletedProject
     }
 
-    private fun validateProjectId(projectId: String): Boolean =
-        projectId.isNotBlank() && !(projectId.all { it.isDigit() })
+
 
 }

src/main/kotlin/domain/usecase/project/GetProjectByIdUseCase.kt

@@ -3,19 +3,19 @@ package com.berlin.domain.usecase.project
 import com.berlin.domain.exception.InvalidProjectIdException
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.model.Project
+import com.berlin.domain.usecase.utils.isIDValid
 
 class GetProjectByIdUseCase (
     private val projectRepository: ProjectRepository
 ) {
 
     operator fun invoke(projectId: String): Project {
-        if(!validateProjectId(projectId))
+        if(isIDValid(projectId).not())
             throw InvalidProjectIdException("project id must not be empty, blank, or purely numeric")
 
         return projectRepository.getProjectById(projectId)
     }
 
-    private fun validateProjectId(projectId: String): Boolean =
-        projectId.isNotBlank() && !(projectId.all { it.isDigit() })
+
 
 }

src/main/kotlin/domain/usecase/task/ChangeTaskStateUseCase.kt

@@ -5,6 +5,7 @@ import com.berlin.domain.model.AuditLog
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
+import com.berlin.domain.usecase.utils.isIDValid
 import data.UserCache
 
 class ChangeTaskStateUseCase(
@@ -17,7 +18,7 @@ class ChangeTaskStateUseCase(
 
         val original = taskRepository.getTaskById(taskId)
 
-        if (!validateStateId(newStateId)) {
+        if (isIDValid(newStateId).not()) {
             throw InvalidTaskStateException("State id must not be empty, blank, or purely numeric")
         }
 
@@ -34,6 +35,5 @@ class ChangeTaskStateUseCase(
         return updatedTask
     }
 
-    private fun validateStateId(stateId: String): Boolean =
-        stateId.isNotBlank() && !stateId.all { it.isDigit() }
+
 }

src/main/kotlin/domain/usecase/task/DeleteTaskUseCase.kt

@@ -3,6 +3,7 @@ package com.berlin.domain.usecase.task
 import com.berlin.domain.model.AuditLog
 import com.berlin.domain.repository.TaskRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
+import com.berlin.domain.usecase.utils.isIDValid
 import data.UserCache
 
 class DeleteTaskUseCase(
@@ -11,7 +12,7 @@ class DeleteTaskUseCase(
     private val cashedUser: UserCache,
 ) {
     operator fun invoke(taskId: String) : String {
-        if (!validateTaskId(taskId)) {
+        if (isIDValid(taskId).not()) {
             throw Exception("Project ID must not be empty or blank")
         }
         taskRepository.deleteTask(taskId)
@@ -26,5 +27,4 @@ class DeleteTaskUseCase(
         return "Deleted."
     }
 
-    private fun validateTaskId(taskId: String): Boolean = taskId.isNotBlank() && !(taskId.all { it.isDigit() })
 }

src/main/kotlin/domain/usecase/task/GetTaskByIdUseCase.kt

@@ -3,20 +3,20 @@ package com.berlin.domain.usecase.task
 import com.berlin.domain.exception.InvalidTaskIdException
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskRepository
+import com.berlin.domain.usecase.utils.isIDValid
 
 class GetTaskByIdUseCase(
     private val taskRepository: TaskRepository,
 ) {
 
     operator fun invoke(taskId: String): Task {
 
-        if (!validateTaskId(taskId)) {
+        if (isIDValid(taskId).not()) {
             throw InvalidTaskIdException("Task id must not be empty, blank, or purely numeric")
         }
 
         return taskRepository.getTaskById(taskId)
     }
 
-    private fun validateTaskId(id: String): Boolean =
-        id.isNotBlank() && !id.all { it.isDigit() }
+
 }

src/main/kotlin/domain/usecase/task/GetTasksByProjectUseCase.kt

@@ -3,19 +3,19 @@ package com.berlin.domain.usecase.task
 import com.berlin.domain.exception.InvalidProjectIdException
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskRepository
+import com.berlin.domain.usecase.utils.isIDValid
 
 class GetTasksByProjectUseCase(
     private val taskRepository: TaskRepository
 ) {
 
     operator fun invoke(projectId: String): List<Task> {
 
-        if (!validateProjectId(projectId)) {
+        if (isIDValid(projectId).not()) {
             throw InvalidProjectIdException("Project id must not be empty, blank, or purely numeric")
         }
         return taskRepository.getTasksByProjectId(projectId)
     }
 
-    private fun validateProjectId(id: String): Boolean =
-        id.isNotBlank() && !id.all { it.isDigit() }
+
 }

src/main/kotlin/domain/usecase/task_state/DeleteTaskStateUseCase.kt

@@ -2,19 +2,19 @@ package com.berlin.domain.usecase.task_state
 
 import com.berlin.domain.exception.InvalidStateIdException
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.isIDValid
 
 class DeleteTaskStateUseCase(
     private val taskStateRepository: TaskStateRepository
 ) {
 
     operator fun invoke(stateId: String): String {
 
-        if(!validateStateId(stateId))
+        if(isIDValid(stateId).not())
             throw InvalidStateIdException("State ID must not be empty or blank")
 
         return taskStateRepository.deleteState(stateId)
     }
 
-    private fun validateStateId(stateId: String): Boolean =
-        stateId.isNotBlank() && !(stateId.all { it.isDigit() })
+
 }

src/main/kotlin/domain/usecase/task_state/GetAllTaskStatesByProjectIdUseCase.kt

@@ -5,6 +5,7 @@ import com.berlin.domain.exception.InvalidProjectIdException
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.isIDValid
 
 class GetAllTaskStatesByProjectIdUseCase(
     private val taskStateRepository: TaskStateRepository,
@@ -13,7 +14,7 @@ class GetAllTaskStatesByProjectIdUseCase(
 
     operator fun invoke(projectId: String): List<TaskState> {
 
-        return if (!validateProjectId(projectId)) {
+        return if (isIDValid(projectId).not()) {
             throw InvalidProjectIdException("Project ID must not be empty or blank")
 
         } else {
@@ -22,7 +23,6 @@ class GetAllTaskStatesByProjectIdUseCase(
         }
     }
 
-    private fun validateProjectId(projectId: String): Boolean =
-        projectId.isNotBlank() && !(projectId.all { it.isDigit() })
+
 
 }

src/main/kotlin/domain/usecase/task_state/GetTaskStateByIdUseCase.kt

@@ -3,19 +3,19 @@ package com.berlin.domain.usecase.task_state
 import com.berlin.domain.exception.InvalidStateIdException
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.isIDValid
 
 class GetTaskStateByIdUseCase(
     private val taskStateRepository: TaskStateRepository
 ) {
 
     operator fun invoke(stateId: String): TaskState {
-        if(!validateStateId(stateId))
+        if(isIDValid(stateId).not())
             throw InvalidStateIdException("State id must not be empty, blank, or purely numeric")
 
         return taskStateRepository.getStateById(stateId)
     }
 
-    private fun validateStateId(stateId: String): Boolean =
-        stateId.isNotBlank() && !(stateId.all { it.isDigit() })
+
 
 }

src/main/kotlin/domain/usecase/task_state/GetTaskStateByTaskIdUseCase.kt

@@ -3,22 +3,20 @@ package com.berlin.domain.usecase.task_state
 import com.berlin.domain.exception.InvalidTaskIdException
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.repository.TaskStateRepository
-import com.berlin.domain.repository.TaskRepository
+import com.berlin.domain.usecase.utils.isIDValid
 
 class GetTaskStateByTaskIdUseCase(
     private val taskStateRepository: TaskStateRepository,
-    private val taskRepository: TaskRepository
 ) {
 
     operator fun invoke(taskId: String): TaskState? {
-        if (!validateTaskId(taskId)) {
+        if (isIDValid(taskId).not()) {
             throw InvalidTaskIdException("Task ID must not be empty or blank")
 
         } else {
             return taskStateRepository.getStateByTaskId(taskId)
         }
     }
 
-    private fun validateTaskId(taskId: String): Boolean = taskId.isNotBlank() && !(taskId.all { it.isDigit() })
 
 }

src/main/kotlin/domain/usecase/task_state/GetTasksByTaskStateIdUseCase.kt

@@ -4,19 +4,19 @@ import com.berlin.domain.exception.InvalidStateIdException
 import com.berlin.domain.exception.TaskNotFoundException
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.isIDValid
 
 class GetTasksByTaskStateIdUseCase(
     private val taskStateRepository: TaskStateRepository,
 ) {
 
     operator fun invoke(stateId: String): List<Task> {
-        if (!validateStateId(stateId)) {
+        if (isIDValid(stateId).not()) {
             throw InvalidStateIdException("State ID must not be empty or blank")
         } else {
             return taskStateRepository.getTasksByStateId(stateId)
                 ?: throw TaskNotFoundException("No tasks found for state ID $stateId")
         }
     }
 
-    private fun validateStateId(stateId: String): Boolean = stateId.isNotBlank() && !(stateId.all { it.isDigit() })
 }

src/main/kotlin/domain/usecase/utils/validateId.kt

@@ -0,0 +1,4 @@
+package com.berlin.domain.usecase.utils
+
+ fun isIDValid(id: String): Boolean =
+        id.isNotBlank() && !id.all { it.isDigit() }

src/test/kotlin/domain/usecase/task_state/GetTaskStateByTaskIdUseCaseTest.kt

@@ -20,7 +20,7 @@ class GetTaskStateByTaskIdUseCaseTest {
 
     @BeforeEach
     fun setup() {
-        getTaskStateByTaskIdUseCase = GetTaskStateByTaskIdUseCase(taskStateRepository, taskRepository)
+        getTaskStateByTaskIdUseCase = GetTaskStateByTaskIdUseCase(taskStateRepository)
     }
 
     @Test