feature/general-validate-function

src/main/kotlin/data/UserCache.kt

@@ -6,7 +6,6 @@ import com.berlin.data.mapper.UserMapper
 import com.berlin.domain.model.Permission
 import com.berlin.domain.model.user.User
 import com.berlin.domain.permission.assignPermissions
-import com.berlin.domain.repository.AuthenticationRepository
 
 class UserCache(
     user: User,

src/main/kotlin/di/useCaseModule.kt

@@ -18,11 +18,16 @@ import com.berlin.domain.usecase.task_state.GetTaskStateByIdUseCase
 import com.berlin.domain.usecase.task_state.GetTaskStateByTaskIdUseCase
 import com.berlin.domain.usecase.task_state.GetTasksByTaskStateIdUseCase
 import com.berlin.domain.usecase.task_state.UpdateTaskStateUseCase
+import com.berlin.domain.usecase.utils.validation.NonBlankNonNumericValidator
+import com.berlin.domain.usecase.utils.validation.Validator
 import domain.usecase.auth_service.LoginUserUseCase
 import org.koin.core.module.dsl.singleOf
+import org.koin.dsl.bind
 import org.koin.dsl.module
 
 val useCaseModule = module {
+    singleOf(::NonBlankNonNumericValidator) bind Validator::class
+
     singleOf(::CreateTaskUseCase)
     singleOf(::AssignTaskUseCase)
     singleOf(::DeleteTaskUseCase)

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.validation.Validator
+
 
 class GetAuditLogsByProjectIdUseCase(
-    private val auditRepository: AuditRepository
+    private val auditRepository: AuditRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(projectId: String): List<AuditLog> {
 
-        if (!validateProjectId(projectId))
+        if (!validator.isValid(projectId))
             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,18 @@ 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.validation.Validator
 
 class GetAuditLogsByTaskIdUseCase(
     private val auditRepository: AuditRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(taskId: String): List<AuditLog> {
 
-        if (!validateTaskId(taskId)) throw InvalidTaskIdException("Task ID must not be empty, blank, or purely numeric")
+        if (!validator.isValid(taskId))
+            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,19 @@ 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.validation.Validator
 
 class GetAuditLogsByUserIdUseCase(
-    private val auditRepository: AuditRepository
+    private val auditRepository: AuditRepository,
+    private val validator: Validator
 ) {
 
-    operator fun invoke(userId:String): List<AuditLog>{
+    operator fun invoke(userId: String): List<AuditLog> {
 
-        if (!validateUserId(userId))
+        if (!validator.isValid(userId))
             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/project/CreateProjectUseCase.kt

@@ -5,21 +5,23 @@ import com.berlin.domain.model.Project
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
 import com.berlin.domain.usecase.utils.id_generator.IdGenerator
+import com.berlin.domain.usecase.utils.validation.Validator
 import data.UserCache
 
 class CreateProjectUseCase(
     private val projectRepository: ProjectRepository,
     private val idGenerator: IdGenerator,
     private val addAuditLogUseCase: AddAuditLogUseCase,
     private val cashedUser: UserCache,
+    private val validator: Validator
 ) {
     operator fun invoke(
         projectName: String,
         description: String?,
         stateId: List<String>?,
         taskId: List<String>?,
     ): String {
-        if (validateProjectName(projectName)) {
+        if (validator.isValid(projectName)) {
             val newProject = Project(
                 id = idGenerator.generateId(projectName),
                 title = projectName,
@@ -42,7 +44,4 @@ class CreateProjectUseCase(
             throw Exception("Project Name must not be empty or blank")
         }
     }
-
-    private fun validateProjectName(projectName: String): Boolean =
-        projectName.isNotBlank() && !(projectName.all { it.isDigit() })
 }

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

@@ -1,20 +1,21 @@
 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.validation.Validator
 import data.UserCache
 
 class DeleteProjectUseCase(
     private val projectRepository: ProjectRepository,
     private val addAuditLogUseCase: AddAuditLogUseCase,
     private val cashedUser: UserCache,
+    private val validator: Validator
 ) {
     operator fun invoke(projectId: String): String {
 
-        if (!validateProjectId(projectId)) {
+        if (!validator.isValid(projectId)) {
             throw InvalidProjectIdException("Project ID must not be empty or blank")
         }
 
@@ -29,8 +30,4 @@ 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,17 @@ 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.validation.Validator
 
 class GetProjectByIdUseCase (
-    private val projectRepository: ProjectRepository
+    private val projectRepository: ProjectRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(projectId: String): Project {
-        if(!validateProjectId(projectId))
+        if(!validator.isValid(projectId))
             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/project/UpdateProjectUseCase.kt

@@ -5,15 +5,17 @@ import com.berlin.domain.model.AuditLog
 import com.berlin.domain.model.Project
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
+import com.berlin.domain.usecase.utils.validation.Validator
 import data.UserCache
 
 class UpdateProjectUseCase(
     private val projectRepository: ProjectRepository,
     private val addAuditLogUseCase: AddAuditLogUseCase,
     private val cashedUser: UserCache,
+    private val validator: Validator
 ) {
     operator fun invoke(project: Project): String {
-        if (!validateProjectName(project.title)) throw InvalidProjectException("Project Name must not be empty or blank")
+        if (!validator.isValid(project.title)) throw InvalidProjectException("Project Name must not be empty or blank")
 
         val updatedProject = projectRepository.updateProject(project)
 
@@ -26,7 +28,4 @@ class UpdateProjectUseCase(
 
         return updatedProject
     }
-
-    private fun validateProjectName(projectName: String): Boolean =
-        projectName.isNotBlank() && !(projectName.all { it.isDigit() })
 }

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

@@ -5,19 +5,21 @@ 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.validation.Validator
 import data.UserCache
 
 class ChangeTaskStateUseCase(
     private val taskRepository: TaskRepository,
     private val addAuditLogUseCase: AddAuditLogUseCase,
     private val cashedUser: UserCache,
+    private val validator: Validator
 ) {
 
     operator fun invoke(taskId: String, newStateId: String): Task {
 
         val original = taskRepository.getTaskById(taskId)
 
-        if (!validateStateId(newStateId)) {
+        if (!validator.isValid(newStateId)) {
             throw InvalidTaskStateException("State id must not be empty, blank, or purely numeric")
         }
 
@@ -33,7 +35,4 @@ class ChangeTaskStateUseCase(
 
         return updatedTask
     }
-
-    private fun validateStateId(stateId: String): Boolean =
-        stateId.isNotBlank() && !stateId.all { it.isDigit() }
 }

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

@@ -7,11 +7,13 @@ 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.id_generator.IdGenerator
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class CreateTaskUseCase(
     private val taskRepository: TaskRepository,
     private val defaultIdGenerator: IdGenerator,
-    private val addAuditLogUseCase: AddAuditLogUseCase
+    private val addAuditLogUseCase: AddAuditLogUseCase,
+    private val validator: Validator
 ) {
     operator fun invoke(
         projectId: String,
@@ -21,7 +23,7 @@ class CreateTaskUseCase(
         createByUserId: String,
         assignedToUserId: String,
     ): Task {
-        if (validateTaskTitle(title.trim())) {
+        if (validator.isValid(title.trim())) {
             val newTask = Task(
                 id = defaultIdGenerator.generateId(title.trim()),
                 projectId = projectId,
@@ -50,10 +52,6 @@ class CreateTaskUseCase(
         }
     }
 
-    private fun validateTaskTitle(title: String): Boolean {
-        return title.isNotBlank() && !title.any { it.isDigit() }
-    }
-
     private fun validateUniqueTask(taskId: String): Boolean {
         return try {
             taskRepository.getTaskById(taskId)

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

@@ -3,15 +3,17 @@ 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.validation.Validator
 import data.UserCache
 
 class DeleteTaskUseCase(
     private val taskRepository: TaskRepository,
     private val addAuditLogUseCase: AddAuditLogUseCase,
     private val cashedUser: UserCache,
+    private val validator: Validator
 ) {
     operator fun invoke(taskId: String) : String {
-        if (!validateTaskId(taskId)) {
+        if (!validator.isValid(taskId)) {
             throw Exception("Project ID must not be empty or blank")
         }
         taskRepository.deleteTask(taskId)
@@ -25,6 +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,19 @@ 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.validation.Validator
 
 class GetTaskByIdUseCase(
     private val taskRepository: TaskRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(taskId: String): Task {
 
-        if (!validateTaskId(taskId)) {
+        if (!validator.isValid(taskId)) {
             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,18 @@ 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.validation.Validator
 
 class GetTasksByProjectUseCase(
-    private val taskRepository: TaskRepository
+    private val taskRepository: TaskRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(projectId: String): List<Task> {
 
-        if (!validateProjectId(projectId)) {
+        if (!validator.isValid(projectId)) {
             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/CreateTaskStateUseCase.kt

@@ -5,13 +5,15 @@ import com.berlin.domain.exception.InvalidStateNameException
 import com.berlin.domain.repository.TaskStateRepository
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.usecase.utils.id_generator.IdGeneratorImplementation
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class CreateTaskStateUseCase(
     private val taskStateRepository: TaskStateRepository,
     private val idGenerator: IdGeneratorImplementation,
+    private val validator: Validator
 ) {
     operator fun invoke(stateName: String, projectId: String): String {
-        if (validateStateName(stateName)) {
+        if (validator.isValid(stateName)) {
             val newState = TaskState(
                 id = idGenerator.generateId(stateName),
                 name = stateName,
@@ -22,7 +24,4 @@ class CreateTaskStateUseCase(
             throw InvalidStateNameException("State Name must not be empty or blank")
         }
     }
-
-    private fun validateStateName(stateName: String): Boolean =
-        stateName.isNotBlank() && !(stateName.all { it.isDigit() })
 }