implement create state ui and test cases

build.gradle.kts

@@ -58,5 +58,5 @@ tasks.test {
 }
 
 kotlin {
-    jvmToolchain(23)
+    jvmToolchain(22)
 }

src/main/kotlin/Main.kt

@@ -4,7 +4,6 @@ import com.berlin.di.uiModule
 import com.berlin.di.useCaseModule
 import com.berlin.di.*
 import com.berlin.presentation.MainMenuUI
-import com.berlin.presentation.authService.AuthenticateUserUi
 import org.koin.core.context.startKoin
 import org.koin.mp.KoinPlatform.getKoin
 

src/main/kotlin/data/DummyData.kt

@@ -19,6 +19,7 @@ object DummyData : BaseDataSource<Task> {
     )
 
     val states = mutableListOf(
+        State("Q1","Menna","P5"),
         State("S1", "TODO", "P1"),
         State("S2", "IN_PROGRESS", "P1"),
         State("S3", "REVIEW", "P1"),

src/main/kotlin/data/state/StateRepositoryImpl.kt

@@ -2,54 +2,60 @@ package com.berlin.data.state
 
 import com.berlin.data.BaseDataSource
 import com.berlin.domain.exception.InvalidStateException
+import com.berlin.domain.exception.StateNotFoundException
 import com.berlin.domain.model.State
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.StateRepository
+import kotlin.Result.Companion.failure
+import kotlin.Result.Companion.success
 
 class StateRepositoryImpl(
     private val stateDataSource: BaseDataSource<State>,
-    private val taskDataSource: BaseDataSource<Task>
-):StateRepository {
-    override fun addState(state: State): Result<String> {
-        return if (stateDataSource.write(state))
-            Result.success(state.id)
+    private val taskDataSource: BaseDataSource<Task>,
+) : StateRepository {
+    override fun addState(state: State): Result<String> =
+         if (stateDataSource.write(state))
+            success(state.id)
         else
-            Result.failure(InvalidStateException("can not add state"))
-    }
+            failure(InvalidStateException("can not add state"))
 
-    override fun getStatesByProjectId(projectId: String): List<State>? {
-        return stateDataSource.getAll()
-            .filter { it.projectId == projectId }
-            .takeIf { it.isNotEmpty() }
-    }
 
-    override fun getTasksByStateId(stateId: String): List<Task>? {
-        return taskDataSource.getAll()
+    override fun getStatesByProjectId(projectId: String): Result<List<State>> =
+        success(stateDataSource.getAll().filter { it.projectId == projectId })
+
+
+    override fun getTasksByStateId(stateId: String): List<Task>? =
+        taskDataSource.getAll()
             .filter { it.stateId == stateId }
             .takeIf { it.isNotEmpty() }
-    }
 
-    override fun deleteState(stateId: String): Result<String> {
-        return if (stateDataSource.delete(stateId))
-            Result.success(stateId)
+
+    override fun deleteState(stateId: String): Result<String> =
+        if (stateDataSource.delete(stateId))
+            success(stateId)
         else
-            Result.failure(InvalidStateException("can not delete state"))
-    }
+            failure(InvalidStateException("can not delete state"))
 
-    override fun updateState(state: State): Result<String> {
-        return if (stateDataSource.update(state.id,state))
-            Result.success(state.id)
+
+    override fun updateState(state: State): Result<String> =
+        if (stateDataSource.update(state.id, state))
+            success(state.id)
         else
-            Result.failure(InvalidStateException("can not update state"))
-    }
+            failure(InvalidStateException("can not update state"))
+
 
     override fun getStateByTaskId(taskId: String): State? {
-       return taskDataSource
-           .getById(taskId)
-           ?.let { stateDataSource.getById(it.stateId) }
+        return taskDataSource
+            .getById(taskId)
+            ?.let { stateDataSource.getById(it.stateId) }
     }
 
-    override fun getStateById(stateId: String): State? {
-        return stateDataSource.getById(stateId)
+    override fun getStateById(stateId: String): Result<State> =
+        stateDataSource.getById(stateId)
+            ?.let { success(it) }
+            ?: failure(StateNotFoundException(stateId))
+
+    override fun getAllStates(): List<State> {
+        return stateDataSource.getAll()
     }
 }

src/main/kotlin/di/uiModule.kt

@@ -5,6 +5,7 @@ import com.berlin.domain.model.User
 import com.berlin.domain.usecase.authService.GetUserByIDUseCase
 import com.berlin.presentation.MainMenuUI
 import com.berlin.presentation.authService.*
+import com.berlin.presentation.state.*
 import com.berlin.presentation.project.*
 import com.berlin.presentation.task.*
 import org.koin.core.qualifier.named
@@ -16,13 +17,14 @@ val uiModule = module {
 
     single { CreateTaskUI(get(), get(named("currentUser")), get(), get()) }
     single { AssignTaskUI(get(), get(), get(), get()) }
-    single { DeleteTaskUI(get(), get(), get(),get()) }
+    single { DeleteTaskUI(get(), get(), get(), get()) }
     single { GetTasksByProjectIdUI(get(), get(), get()) }
     single { UpdateTaskUI(get(), get(), get(), get()) }
     single { ChangeTaskStateUI(get(), get(), get(), get()) }
     single { GetTaskByIdUI(get(), get(), get()) }
     single { GetUserByIDUseCase(get()) }
     single { GettingUsersLoggedInUI(get(), get()) }
+
     single { CreationOfMateUi(get(),get(),get()) }
     single { AuthenticateUserUi(get(),get(),get()) }
     single { FetchAllUsersUI(get(),get()) }
@@ -33,7 +35,11 @@ val uiModule = module {
     single { GetProjectByIdUi(get(),get(),get()) }
     single { UpdateProjectUi(get(),get(),get(),get(),get()) }
 
-
+    single { CreateStateUi(get(), get(), get()) }
+    single { DeleteStateUi(get(), get(), get(), get()) }
+    single { GetStateByIdUi(get(), get(), get()) }
+    single { UpdateStateUi(get(), get(), get(), get()) }
+    single { GetAllStatesByProjectIdUi(get(),get(),get()) }
     /* aggregated main menu */
     single {
         MainMenuUI(
@@ -52,6 +58,12 @@ val uiModule = module {
                 get<GettingUsersLoggedInUI>(),
                 get<GetUserByIDUI>(),
 
+                get<CreateStateUi>(),
+                get<DeleteStateUi>(),
+                get<GetStateByIdUi>(),
+                get<UpdateStateUi>(),
+                get<GetAllStatesByProjectIdUi>(),
+
                 get<CreateProjectUi>(),
                 get<DeleteProjectUi>(),
                 get<GetAllProjectsUi>(),
@@ -62,4 +74,4 @@ val uiModule = module {
             reader = get()
         )
     }
-}
+}

src/main/kotlin/di/useCaseModule.kt

@@ -9,6 +9,14 @@ import com.berlin.domain.usecase.authService.FetchAllUsersUseCase
 import com.berlin.domain.usecase.authService.GetUserByIDUseCase
 import com.berlin.domain.usecase.authService.GettingUsersLoggedInUseCase
 import com.berlin.domain.usecase.project.*
+import com.berlin.domain.usecase.state.CreateStateUseCase
+import com.berlin.domain.usecase.state.DeleteStateUseCase
+import com.berlin.domain.usecase.state.GetAllStatesByProjectIdUseCase
+import com.berlin.domain.usecase.state.GetAllStatesUseCase
+import com.berlin.domain.usecase.state.GetStateByIdUseCase
+import com.berlin.domain.usecase.state.GetStateByTaskIdUseCase
+import com.berlin.domain.usecase.state.GetTasksByStateIdUseCase
+import com.berlin.domain.usecase.state.UpdateStateUseCase
 import com.berlin.domain.usecase.task.*
 import domain.usecase.authService.AuthenticateUserUseCase
 import org.koin.dsl.module
@@ -39,4 +47,13 @@ val useCaseModule = module {
     single { FetchAllUsersUseCase(get()) }
     single { AuthenticateUserUseCase(get(), get()) }
     single { CreationOfMateUseCase(get(), get(), get()) }
-}
+
+    single { CreateStateUseCase(get(),get())}
+    single { DeleteStateUseCase(get()) }
+    single { GetAllStatesByProjectIdUseCase(get(),get()) }
+    single { GetStateByIdUseCase(get()) }
+    single { GetStateByTaskIdUseCase(get(),get()) }
+    single { GetTasksByStateIdUseCase(get()) }
+    single { UpdateStateUseCase(get()) }
+    single { GetAllStatesUseCase(get()) }
+}

src/main/kotlin/domain/exception/Exceptions.kt

@@ -20,4 +20,4 @@ class InvalidProjectException(message: String): Exception(message)
 class InvalidStateException(message: String): Exception(message)
 class InvalidAuditLogException(message: String): Exception(message)
 class InvalidStateIdException(message: String): Exception(message)
-class InvalidStateNameException(message: String): Exception(message)
+class InvalidStateNameException(message: String): Exception(message)

src/main/kotlin/domain/repository/StateRepository.kt

@@ -5,10 +5,11 @@ import com.berlin.domain.model.Task
 
 interface StateRepository {
     fun addState(state: State): Result<String>
-    fun getStatesByProjectId(projectId: String): List<State>?
+    fun getStatesByProjectId(projectId: String): Result<List<State>>
     fun getTasksByStateId(stateId: String):List<Task>?
     fun deleteState(stateId: String): Result<String>
     fun updateState(state: State): Result<String>
     fun getStateByTaskId(taskId: String): State?
-    fun getStateById(stateId: String): State?
+    fun getStateById(stateId: String): Result<State>
+    fun getAllStates(): List<State>
 }

src/main/kotlin/domain/usecase/state/DeleteStateUseCase.kt

@@ -26,6 +26,6 @@ class DeleteStateUseCase(
     private fun validateStateId(stateId: String): Boolean =
         stateId.isNotBlank() || !(stateId.all { it.isDigit() })
 
-    fun checkStateExists(stateId: String): Boolean =
-        stateRepository.getStateById(stateId) != null
+    private fun checkStateExists(stateId: String): Boolean =
+        stateRepository.getStateById(stateId).isSuccess
 }

src/main/kotlin/domain/usecase/state/GetAllStatesByProjectIdUseCase.kt

@@ -2,8 +2,6 @@ package com.berlin.domain.usecase.state
 
 
 import com.berlin.domain.exception.InvalidProjectIdException
-import com.berlin.domain.exception.ProjectNotFoundException
-import com.berlin.domain.exception.StateNotFoundException
 import com.berlin.domain.model.State
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.repository.StateRepository
@@ -13,16 +11,15 @@ class GetAllStatesByProjectIdUseCase(
     private val projectRepository: ProjectRepository
 ) {
 
-    fun getAllStatesByProjectId(projectId: String): List<State> {
+    fun getAllStatesByProjectId(projectId: String): Result<List<State>> {
 
         if (!validateProjectId(projectId))
             throw InvalidProjectIdException("Project ID must not be empty or blank")
 
         if (checkProjectExists(projectId)) {
             return stateRepository.getStatesByProjectId(projectId)
-                ?: throw StateNotFoundException("No states found for project ID $projectId")
         } else {
-            throw ProjectNotFoundException("Project with ID $projectId does not exist")
+            return Result.failure(Exception("Project with ID $projectId does not exist"))
         }
     }
 

src/main/kotlin/domain/usecase/state/GetAllStatesUseCase.kt

@@ -0,0 +1,12 @@
+package com.berlin.domain.usecase.state
+
+import com.berlin.domain.model.State
+import com.berlin.domain.repository.StateRepository
+
+class GetAllStatesUseCase(
+    private val stateRepository: StateRepository,
+) {
+    operator fun invoke(): List<State> {
+        return stateRepository.getAllStates()
+    }
+}

src/main/kotlin/domain/usecase/state/GetStateByIdUseCase.kt

@@ -8,12 +8,11 @@ class GetStateByIdUseCase(
     private val stateRepository: StateRepository
 ) {
 
-    fun getStateById(stateId: String): State {
+    fun getStateById(stateId: String): Result<State> {
         if(!validateStateId(stateId))
-            throw InvalidStateIdException("State ID must not be empty or blank")
+            throw InvalidStateIdException("State id must not be empty, blank, or purely numeric")
 
         return stateRepository.getStateById(stateId)
-            ?: throw InvalidStateIdException("State with ID $stateId does not exist")
     }
 
     private fun validateStateId(stateId: String): Boolean =

src/main/kotlin/domain/usecase/state/GetStateByTaskIdUseCase.kt

@@ -22,7 +22,7 @@ class GetStateByTaskIdUseCase(
     }
 
 
-    private fun checkTaskExists(taskId: String): Boolean = taskRepository.findById(taskId) != null
+    private fun checkTaskExists(taskId: String): Boolean = taskRepository.findById(taskId).isSuccess
 
     private fun validateTaskId(taskId: String): Boolean = taskId.isNotBlank() && !(taskId.all { it.isDigit() })
 

src/main/kotlin/domain/usecase/state/GetTasksByStateIdUseCase.kt

@@ -1,7 +1,6 @@
 package com.berlin.domain.usecase.state
 
 import com.berlin.domain.exception.InvalidStateIdException
-import com.berlin.domain.exception.InvalidTaskStateException
 import com.berlin.domain.exception.TaskNotFoundException
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.StateRepository
@@ -10,7 +9,7 @@ class GetTasksByStateIdUseCase (
     private val stateRepository: StateRepository
 ) {
 
-    fun getAllTasksByStateId(stateId: String): List<Task>? {
+    fun getAllTasksByStateId(stateId: String): List<Task> {
         if (!validateStateId(stateId)) throw InvalidStateIdException("State ID must not be empty or blank")
 
         if (checkStateExists(stateId)) {
@@ -22,7 +21,7 @@ class GetTasksByStateIdUseCase (
     }
 
 
-    private fun checkStateExists(stateId: String): Boolean = stateRepository.getStateById(stateId) != null
+    private fun checkStateExists(stateId: String): Boolean = stateRepository.getStateById(stateId).isSuccess
 
     private fun validateStateId(stateId: String): Boolean = stateId.isNotBlank() && !(stateId.all { it.isDigit() })
 }

src/main/kotlin/domain/usecase/state/UpdateStateUseCase.kt

@@ -5,13 +5,17 @@ import com.berlin.domain.model.State
 import com.berlin.domain.repository.StateRepository
 
 class UpdateStateUseCase(
-    private val stateRepository: StateRepository
+    private val stateRepository: StateRepository,
 ) {
-    fun updateState(state: State): Result<String> {
-        if(!validateStateName(state.name))
+    fun updateState(stateId: String, newStateName: String, projectId: String): Result<String> {
+        if (!validateStateName(newStateName))
             throw InvalidStateNameException("State Name must not be empty or blank")
-
-        return stateRepository.updateState(state)
+        val updatedState = State(
+            id = stateId,
+            name = newStateName,
+            projectId = projectId
+        )
+        return stateRepository.updateState(updatedState)
             .map { "Updated Successfully" }
             .recover { "Update Failed" }
     }