diff --git a/src/main/kotlin/data/datasource/interfaces/AuthenticationDataSource.kt b/src/main/kotlin/data/datasource/AuthenticationDataSource.kt similarity index 93% rename from src/main/kotlin/data/datasource/interfaces/AuthenticationDataSource.kt rename to src/main/kotlin/data/datasource/AuthenticationDataSource.kt index a1f04920..96cb0f95 100644 --- a/src/main/kotlin/data/datasource/interfaces/AuthenticationDataSource.kt +++ b/src/main/kotlin/data/datasource/AuthenticationDataSource.kt @@ -1,4 +1,4 @@ -package data.datasource.interfaces +package data.datasource import domain.model.User diff --git a/src/main/kotlin/data/datasource/interfaces/LogDataSource.kt b/src/main/kotlin/data/datasource/LogDataSource.kt similarity index 92% rename from src/main/kotlin/data/datasource/interfaces/LogDataSource.kt rename to src/main/kotlin/data/datasource/LogDataSource.kt index e3be36a6..97ed7a84 100644 --- a/src/main/kotlin/data/datasource/interfaces/LogDataSource.kt +++ b/src/main/kotlin/data/datasource/LogDataSource.kt @@ -1,4 +1,4 @@ -package data.datasource.interfaces +package data.datasource import domain.model.ProjectLog import domain.model.TaskLog diff --git a/src/main/kotlin/data/datasource/interfaces/ProjectDataSource.kt b/src/main/kotlin/data/datasource/ProjectDataSource.kt similarity index 62% rename from src/main/kotlin/data/datasource/interfaces/ProjectDataSource.kt rename to src/main/kotlin/data/datasource/ProjectDataSource.kt index bed6e5ca..5d1e84c7 100644 --- a/src/main/kotlin/data/datasource/interfaces/ProjectDataSource.kt +++ b/src/main/kotlin/data/datasource/ProjectDataSource.kt @@ -1,7 +1,7 @@ -package data.datasource.interfaces +package data.datasource import domain.model.Project -import domain.model.State +import domain.model.TaskState import domain.model.User import java.util.* @@ -11,9 +11,9 @@ interface ProjectDataSource { suspend fun deleteProject(id: UUID) suspend fun getAllProjects(): List suspend fun getProject(id: UUID): Project - suspend fun addState(projectId: UUID, state: State): Project - suspend fun editState(projectId: UUID, state: State): Project - suspend fun deleteState(projectId: UUID, state: State): Project + suspend fun addState(projectId: UUID, taskState: TaskState): Project + suspend fun editState(projectId: UUID, taskState: TaskState): Project + suspend fun deleteState(projectId: UUID, taskState: TaskState): Project suspend fun addMate(projectId: UUID, user: User): Project suspend fun getUserProjectsById(userId: UUID): List diff --git a/src/main/kotlin/data/datasource/interfaces/TaskDataSource.kt b/src/main/kotlin/data/datasource/TaskDataSource.kt similarity index 92% rename from src/main/kotlin/data/datasource/interfaces/TaskDataSource.kt rename to src/main/kotlin/data/datasource/TaskDataSource.kt index c73616ec..a5f931db 100644 --- a/src/main/kotlin/data/datasource/interfaces/TaskDataSource.kt +++ b/src/main/kotlin/data/datasource/TaskDataSource.kt @@ -1,4 +1,4 @@ -package data.datasource.interfaces +package data.datasource import domain.model.Task import java.util.* diff --git a/src/main/kotlin/data/datasource/csv/implementation/AuthenticationDataSourceImplementation.kt b/src/main/kotlin/data/datasource/csv/AuthenticationDataSourceImpl.kt similarity index 66% rename from src/main/kotlin/data/datasource/csv/implementation/AuthenticationDataSourceImplementation.kt rename to src/main/kotlin/data/datasource/csv/AuthenticationDataSourceImpl.kt index e8708e08..9184c315 100644 --- a/src/main/kotlin/data/datasource/csv/implementation/AuthenticationDataSourceImplementation.kt +++ b/src/main/kotlin/data/datasource/csv/AuthenticationDataSourceImpl.kt @@ -1,39 +1,53 @@ -package data.datasource.csv.implementation +package data.datasource.csv import data.datasource.csv.helper.FileName import data.datasource.csv.reader.CsvReader import data.datasource.csv.writer.CsvWriter -import data.datasource.interfaces.AuthenticationDataSource +import data.datasource.AuthenticationDataSource import ui.common.exception.EmailAlreadyExistsException import ui.common.exception.InvalidCredentialsException import ui.common.exception.UserNotLoggedInException -import domain.model.Role +import domain.model.UserRole import domain.model.User import java.util.* -class AuthenticationDataSourceImplementation( +class AuthenticationDataSourceImpl( private val csvWriter: CsvWriter, private val csvReader: CsvReader, ) : AuthenticationDataSource { - override suspend fun login(email: String, password: String): User { + override suspend fun login( + email: String, + password: String + ): User { val users = readUsersFromCsv() val user = users.find { it.email == email && it.password == password } ?: throw InvalidCredentialsException() saveCurrentUser(user) return user } - override suspend fun isValidEmail(email: String): Boolean { + override suspend fun isValidEmail( + email: String + ): Boolean { val users = readUsersFromCsv() return users.none { it.email == email } } - override suspend fun registerMate(name: String, password: String, email: String): User { + override suspend fun registerMate( + name: String, + password: String, + email: String + ): User { val users = readUsersFromCsv() - validateUniqueEmail(users, email) + validateUniqueEmail(users = users, email = email) val newUser = User( - id = UUID.randomUUID(), name = name, password = password, email = email, role = Role.MATE, isDeleted = false + id = UUID.randomUUID(), + name = name, + password = password, + email = email, + userRole = UserRole.MATE, + isDeleted = false ) addUserToCsv(newUser) @@ -42,15 +56,20 @@ class AuthenticationDataSourceImplementation( return newUser } - override suspend fun registerAdmin(name: String, password: String, email: String): User { + override suspend fun registerAdmin( + name: String, + password: String, + email: String + ): User { val users = readUsersFromCsv() validateUniqueEmail(users, email) + val newAdmin = User( id = UUID.randomUUID(), name = name, password = password, email = email, - role = Role.ADMIN, + userRole = UserRole.ADMIN, isDeleted = false ) addUserToCsv(newAdmin) @@ -58,7 +77,10 @@ class AuthenticationDataSourceImplementation( return newAdmin } - private fun validateUniqueEmail(users: List, email: String) { + private fun validateUniqueEmail( + users: List, + email: String + ) { if (users.any { it.email == email }) { throw EmailAlreadyExistsException() } @@ -81,7 +103,9 @@ class AuthenticationDataSourceImplementation( } override suspend fun getCurrentUser(): User { - return readUsersFromCsv().singleOrNull() ?: throw UserNotLoggedInException() + return readUsersFromCsv() + .singleOrNull() + ?: throw UserNotLoggedInException() } override suspend fun getUsers(): List { @@ -98,6 +122,9 @@ class AuthenticationDataSourceImplementation( } private suspend fun writeUsersToCsv(users: List) { - csvWriter.writeToFile(users, FileName.REGISTERED_USERS_FILE) + csvWriter.writeToFile( + items = users, + filePath = FileName.REGISTERED_USERS_FILE + ) } } \ No newline at end of file diff --git a/src/main/kotlin/data/datasource/csv/implementation/LogDataSourceImplementation.kt b/src/main/kotlin/data/datasource/csv/LogDataSourceImpl.kt similarity index 65% rename from src/main/kotlin/data/datasource/csv/implementation/LogDataSourceImplementation.kt rename to src/main/kotlin/data/datasource/csv/LogDataSourceImpl.kt index 067844fa..d38bfa57 100644 --- a/src/main/kotlin/data/datasource/csv/implementation/LogDataSourceImplementation.kt +++ b/src/main/kotlin/data/datasource/csv/LogDataSourceImpl.kt @@ -1,16 +1,16 @@ -package data.datasource.csv.implementation +package data.datasource.csv import data.datasource.csv.helper.FileName import data.datasource.csv.reader.CsvReader import data.datasource.csv.writer.CsvWriter -import data.datasource.interfaces.LogDataSource +import data.datasource.LogDataSource import ui.common.exception.NoProjectLogsFoundException import ui.common.exception.NoTaskLogsFoundException import domain.model.ProjectLog import domain.model.TaskLog import java.util.* -class LogDataSourceImplementation( +class LogDataSourceImpl( private val csvProjectLogReader: CsvReader, private val csvProjectLogWriter: CsvWriter, private val csvTaskLogReader: CsvReader, @@ -18,35 +18,49 @@ class LogDataSourceImplementation( ) : LogDataSource { override suspend fun getProjectLogs(id: UUID): List { - return csvProjectLogReader.read(FileName.PROJECT_LOG).filter { it.entityId == id }.takeIf { it.isNotEmpty() } + return csvProjectLogReader + .read(FileName.PROJECT_LOG) + .filter { it.entityId == id } + .takeIf { it.isNotEmpty() } ?: throw NoProjectLogsFoundException() } override suspend fun getTaskLogs(id: UUID): List { - return csvTaskLogReader.read(FileName.TASK_LOG).filter { it.entityId == id }.takeIf { it.isNotEmpty() } + return csvTaskLogReader + .read(FileName.TASK_LOG) + .filter { it.entityId == id } + .takeIf { it.isNotEmpty() } ?: throw NoTaskLogsFoundException() } override suspend fun saveProjectLog(projectLog: ProjectLog) { val logs = csvProjectLogReader.read(FileName.PROJECT_LOG).toMutableList() logs.add(projectLog) - csvProjectLogWriter.writeToFile(logs, FileName.PROJECT_LOG) + csvProjectLogWriter.writeToFile( + items = logs, + filePath = FileName.PROJECT_LOG + ) } override suspend fun saveTaskLog(taskLog: TaskLog) { val logs = csvTaskLogReader.read(FileName.TASK_LOG).toMutableList() logs.add(taskLog) - csvTaskLogWriter.writeToFile(logs, FileName.TASK_LOG) + csvTaskLogWriter.writeToFile( + items = logs, + filePath = FileName.TASK_LOG + ) } override suspend fun getAllProjectLogs(): List { - return csvProjectLogReader.read(FileName.PROJECT_LOG) + return csvProjectLogReader + .read(FileName.PROJECT_LOG) .takeIf { it.isNotEmpty() } ?: throw NoProjectLogsFoundException() } override suspend fun getAllTaskLogs(): List { - return csvTaskLogReader.read(FileName.TASK_LOG) + return csvTaskLogReader + .read(FileName.TASK_LOG) .takeIf { it.isNotEmpty() } ?: throw NoTaskLogsFoundException() } diff --git a/src/main/kotlin/data/datasource/csv/implementation/ProjectDataSourceImplementation.kt b/src/main/kotlin/data/datasource/csv/ProjectDataSourceImpl.kt similarity index 61% rename from src/main/kotlin/data/datasource/csv/implementation/ProjectDataSourceImplementation.kt rename to src/main/kotlin/data/datasource/csv/ProjectDataSourceImpl.kt index 1356406f..6bd3404a 100644 --- a/src/main/kotlin/data/datasource/csv/implementation/ProjectDataSourceImplementation.kt +++ b/src/main/kotlin/data/datasource/csv/ProjectDataSourceImpl.kt @@ -1,18 +1,18 @@ -package data.datasource.csv.implementation +package data.datasource.csv import data.datasource.csv.helper.FileName import data.datasource.csv.reader.CsvReader import data.datasource.csv.writer.CsvWriter -import data.datasource.interfaces.ProjectDataSource +import data.datasource.ProjectDataSource import domain.model.Project -import domain.model.State +import domain.model.TaskState import domain.model.User import ui.common.exception.* import java.io.FileNotFoundException import java.time.LocalDateTime import java.util.* -class ProjectDataSourceImplementation( +class ProjectDataSourceImpl( private val csvReader: CsvReader, private val csvWriter: CsvWriter, private val fileName: String = FileName.PROJECTS @@ -38,46 +38,52 @@ class ProjectDataSourceImplementation( override suspend fun getProject(id: UUID): Project { - return csvReader.read(fileName).find { it.id == id } ?: throw ProjectNotFoundException() + return csvReader + .read(fileName) + .find { it.id == id } + ?: throw ProjectNotFoundException() } - override suspend fun addState(projectId: UUID, state: State): Project { + override suspend fun addState(projectId: UUID, taskState: TaskState): Project { return modifyProjectState(projectId) { states -> - if (states.any { oldState -> haveSameStateName(oldState, state) }) { - throw DuplicateStateException() - } - states + state + if (states.any { oldState -> + haveSameStateName( + oldTaskState = oldState, + newTaskState = taskState + ) + }) throw DuplicateStateException() + states + taskState } } - override suspend fun editState(projectId: UUID, state: State): Project { + override suspend fun editState(projectId: UUID, taskState: TaskState): Project { return modifyProjectState(projectId) { states -> - val updatedStates = mutableListOf() + val updatedTaskStates = mutableListOf() var notFoundState = true states.forEach { oldState -> - if (haveSameStateName(oldState, state)) throw DuplicateStateException() - updatedStates += if (oldState.id == state.id) { + if (haveSameStateName(oldState, taskState)) throw DuplicateStateException() + updatedTaskStates += if (oldState.id == taskState.id) { notFoundState = false - state + taskState } else oldState } if (notFoundState) throw StateNotFoundException() - updatedStates + updatedTaskStates } } - override suspend fun deleteState(projectId: UUID, state: State): Project { + override suspend fun deleteState(projectId: UUID, taskState: TaskState): Project { return modifyProjectState(projectId) { states -> - val updatedStates = mutableListOf() + val updatedTaskStates = mutableListOf() var notFoundState = true states.forEach { oldState -> - if (oldState.id == state.id) { + if (oldState.id == taskState.id) { notFoundState = false - } else updatedStates += oldState + } else updatedTaskStates += oldState } if (notFoundState) throw StateNotFoundException() - updatedStates + updatedTaskStates } } @@ -86,28 +92,38 @@ class ProjectDataSourceImplementation( val updatedUser = mutableListOf() var notFoundUser = true users.forEach { oldUsers -> - if (haveSameUserID(oldUsers, user)) throw DuplicateStateException() + if (haveSameUserID(oldUser = oldUsers, newUser = user)) + throw DuplicateStateException() updatedUser += if (oldUsers.id == user.id) { notFoundUser = false user } else oldUsers } - if (notFoundUser) throw StateNotFoundException() + if (notFoundUser) + throw StateNotFoundException() updatedUser } } override suspend fun getUserProjectsById(userId: UUID): List { - val project = csvReader.read(fileName).filter { it.creatorUserID == userId } + val project = csvReader + .read(fileName) + .filter { it.creatorUserID == userId } return project.ifEmpty { throw ProjectNotFoundException() } } - private suspend fun modifyProjectUser(projectId: UUID, userModifier: (List) -> List): Project { + private suspend fun modifyProjectUser( + projectId: UUID, + userModifier: (List) -> List + ): Project { val projects = getAllProjects() - val (updatedProjects, updatedProject) = findAndUpdateProject(projects, projectId) { project -> + val (updatedProjects, updatedProject) = findAndUpdateProject( + projects = projects, + projectId = projectId + ) { project -> project.copy( users = userModifier(project.users), updatedAt = LocalDateTime.now() @@ -120,11 +136,18 @@ class ProjectDataSourceImplementation( private suspend fun modifyProjectState( - projectId: UUID, stateModifier: (List) -> List + projectId: UUID, + taskStateModifier: (List) -> List ): Project { val projects = getAllProjects() - val (updatedProject, project) = findAndUpdateProject(projects, projectId) { project -> - project.copy(states = stateModifier(project.states), updatedAt = LocalDateTime.now()) + val (updatedProject, project) = findAndUpdateProject( + projects = projects, + projectId = projectId + ) { project -> + project.copy( + taskStates = taskStateModifier(project.taskStates), + updatedAt = LocalDateTime.now() + ) } csvWriter.writeToFile(updatedProject, fileName) @@ -134,7 +157,9 @@ class ProjectDataSourceImplementation( private fun findAndUpdateProject( - projects: List, projectId: UUID, projectModifier: (Project) -> Project + projects: List, + projectId: UUID, + projectModifier: (Project) -> Project ): Pair, Project?> { var updatedProject: Project? = null val updated = projects.map { project -> @@ -149,17 +174,28 @@ class ProjectDataSourceImplementation( return Pair(updated.toList(), updatedProject) } - private fun haveSameStateName(oldState: State, newState: State): Boolean { - return oldState.name.equals(newState.name, ignoreCase = true) + private fun haveSameStateName( + oldTaskState: TaskState, + newTaskState: TaskState + ): Boolean { + return oldTaskState.name.equals(newTaskState.name, ignoreCase = true) } - private fun haveSameUserID(oldUser: User, newUser: User): Boolean { + private fun haveSameUserID( + oldUser: User, + newUser: User + ): Boolean { return oldUser.id == newUser.id } private suspend fun buildSuccessCreate(project: Project) { val existingProjects = getAllProjects() - if (existingProjects.any { it.title == project.title && it.creatorUserID == project.creatorUserID }) { + if (existingProjects.any + { + it.title == project.title + && it.creatorUserID == project.creatorUserID + } + ) { throw ProjectCreationFailedException() } csvWriter.writeToFile(existingProjects + project, fileName) diff --git a/src/main/kotlin/data/datasource/csv/implementation/TaskDataSourceImplementation.kt b/src/main/kotlin/data/datasource/csv/TaskDataSourceImpl.kt similarity index 86% rename from src/main/kotlin/data/datasource/csv/implementation/TaskDataSourceImplementation.kt rename to src/main/kotlin/data/datasource/csv/TaskDataSourceImpl.kt index ab8bb978..4f79efdb 100644 --- a/src/main/kotlin/data/datasource/csv/implementation/TaskDataSourceImplementation.kt +++ b/src/main/kotlin/data/datasource/csv/TaskDataSourceImpl.kt @@ -1,14 +1,14 @@ -package data.datasource.csv.implementation +package data.datasource.csv import domain.model.Task import data.datasource.csv.helper.FileName import data.datasource.csv.reader.CsvReader import data.datasource.csv.writer.CsvWriter -import data.datasource.interfaces.TaskDataSource +import data.datasource.TaskDataSource import ui.common.exception.* import java.util.UUID -class TaskDataSourceImplementation( +class TaskDataSourceImpl( private val csvReader: CsvReader, private val csvWriter: CsvWriter, private val taskFile: String = FileName.TASKS @@ -59,10 +59,13 @@ class TaskDataSourceImplementation( return tasks.find { it.id == id } ?: throw TaskNotFoundException() } - override suspend fun getTasksByStateAndProjectIds(projectId: UUID, stateId: UUID): List { + override suspend fun getTasksByStateAndProjectIds( + projectId: UUID, + stateId: UUID + ): List { val tasks = getAllTasks() - val filteredTasks = tasks.filter { it.projectId == projectId && it.state.id == stateId } + val filteredTasks = tasks.filter { it.projectId == projectId && it.taskState.id == stateId } return filteredTasks.ifEmpty { throw TaskNotFoundException() } @@ -96,13 +99,20 @@ class TaskDataSourceImplementation( } } - private fun updateTaskInList(tasks: List, index: Int, updatedTask: Task): List { + private fun updateTaskInList( + tasks: List, + index: Int, + updatedTask: Task + ): List { return tasks.toMutableList().apply { this[index] = updatedTask } } - private fun removeTaskFromList(tasks: List, index: Int): List { + private fun removeTaskFromList( + tasks: List, + index: Int + ): List { return tasks.toMutableList().apply { removeAt(index) } diff --git a/src/main/kotlin/data/datasource/csv/parser/ProjectLogParser.kt b/src/main/kotlin/data/datasource/csv/parser/ProjectLogParser.kt index 77cfe5e5..b48ba6fc 100644 --- a/src/main/kotlin/data/datasource/csv/parser/ProjectLogParser.kt +++ b/src/main/kotlin/data/datasource/csv/parser/ProjectLogParser.kt @@ -22,7 +22,8 @@ class ProjectLogParser(private val projectParser: ProjectParser): CsvParser, + private val taskStateCsvParser: CsvParser, private val userCsvParser: CsvParser ) : CsvParser { @@ -29,7 +29,7 @@ class ProjectParser( cleanedLine = line.removeSurrounding("[", "]") val parts = data.datasource.csv.helper.smartCsvSplit(cleanedLine) - if (stateCsvParser.parseLine(parts[ProjectColumnIndex.STATE]) == null) { + if (taskStateCsvParser.parseLine(parts[ProjectColumnIndex.STATE]) == null) { throw StateNotFoundException() } return Project( @@ -40,13 +40,13 @@ class ProjectParser( createdAt = LocalDateTime.parse(parts[ProjectColumnIndex.CREATED_AT]), updatedAt = LocalDateTime.parse(parts[ProjectColumnIndex.UPDATED_AT]), users = parseMultiUser(parts[ProjectColumnIndex.USER]), - states = parseMultiStates(parts[ProjectColumnIndex.STATE]), + taskStates = parseMultiStates(parts[ProjectColumnIndex.STATE]), ) } - private suspend fun parseMultiStates(line: String): List { + private suspend fun parseMultiStates(line: String): List { val statesLines = data.datasource.csv.helper.smartCsvSplit(line) - return stateCsvParser.parseFile(statesLines) + return taskStateCsvParser.parseFile(statesLines) } private suspend fun parseMultiUser(line: String): List { diff --git a/src/main/kotlin/data/datasource/csv/parser/StateParser.kt b/src/main/kotlin/data/datasource/csv/parser/StateParser.kt index eab19b9d..6120831a 100644 --- a/src/main/kotlin/data/datasource/csv/parser/StateParser.kt +++ b/src/main/kotlin/data/datasource/csv/parser/StateParser.kt @@ -1,22 +1,26 @@ package data.datasource.csv.parser import data.datasource.csv.column_index.StateColumnIndex -import domain.model.State +import domain.model.TaskState import java.util.* -class StateParser : CsvParser { +class StateParser : CsvParser { - override suspend fun parseFile(csvLines: List): List { + override suspend fun parseFile( + csvLines: List + ): List { if (csvLines.isEmpty()) return emptyList() return csvLines.map { parseLine(it) } } - override suspend fun parseLine(line: String): State { + override suspend fun parseLine( + line: String + ): TaskState { val cleanLine = line.removeSurrounding("[", "]") val parts = cleanLine.split(",").map { it.trim() } - return State( + return TaskState( id = UUID.fromString(parts[StateColumnIndex.ID]), name = parts[StateColumnIndex.NAME] ) diff --git a/src/main/kotlin/data/datasource/csv/parser/TaskLogParser.kt b/src/main/kotlin/data/datasource/csv/parser/TaskLogParser.kt index 95404509..958735c0 100644 --- a/src/main/kotlin/data/datasource/csv/parser/TaskLogParser.kt +++ b/src/main/kotlin/data/datasource/csv/parser/TaskLogParser.kt @@ -5,18 +5,20 @@ import domain.model.TaskLog import java.time.LocalDateTime import java.util.* -class TaskLogParser (private val taskParser: TaskParser): CsvParser { +class TaskLogParser ( + private val taskParser: TaskParser +): CsvParser { - - - override suspend fun parseFile(csvLines: List): List { + override suspend fun parseFile(csvLines: List) + : List { if (csvLines.isEmpty()) return emptyList() csvLines.drop(1) return csvLines.mapNotNull { parseLine(it) } } - override suspend fun parseLine(line: String): TaskLog? { + override suspend fun parseLine(line: String) + : TaskLog? { var cleanedLine = line.replace(" ", "") if (cleanedLine == "[]" || cleanedLine == "") diff --git a/src/main/kotlin/data/datasource/csv/parser/TaskParser.kt b/src/main/kotlin/data/datasource/csv/parser/TaskParser.kt index 05e883ae..cf51761c 100644 --- a/src/main/kotlin/data/datasource/csv/parser/TaskParser.kt +++ b/src/main/kotlin/data/datasource/csv/parser/TaskParser.kt @@ -2,23 +2,25 @@ package data.datasource.csv.parser import data.datasource.csv.column_index.TaskColumnIndex import ui.common.exception.StateNotFoundException -import domain.model.State +import domain.model.TaskState import domain.model.Task import java.time.LocalDateTime import java.util.* class TaskParser( - private val stateCsvParser: CsvParser + private val taskStateCsvParser: CsvParser ) : CsvParser { - override suspend fun parseFile(csvLines: List): List { + override suspend fun parseFile(csvLines: List) + : List { if (csvLines.isEmpty()) return emptyList() csvLines.drop(1) return csvLines.mapNotNull { parseLine(it) } } - override suspend fun parseLine(line: String): Task? { + override suspend fun parseLine(line: String) + : Task? { var cleanedLine = line.replace(" ", "") if (cleanedLine == "[]" || cleanedLine == "") @@ -27,7 +29,7 @@ class TaskParser( cleanedLine = line.removeSurrounding("[", "]") val parts = data.datasource.csv.helper.smartCsvSplit(cleanedLine) - if (stateCsvParser.parseLine(parts[TaskColumnIndex.STATE]) == null) { + if (taskStateCsvParser.parseLine(parts[TaskColumnIndex.STATE]) == null) { throw StateNotFoundException() } @@ -36,7 +38,7 @@ class TaskParser( projectId = UUID.fromString(parts[TaskColumnIndex.PROJECT_ID]), title = parts[TaskColumnIndex.NAME], description = parts[TaskColumnIndex.DESCRIPTION], - state = stateCsvParser.parseLine(parts[TaskColumnIndex.STATE])!!, + taskState = taskStateCsvParser.parseLine(parts[TaskColumnIndex.STATE])!!, creatorUserID = UUID.fromString(parts[TaskColumnIndex.CREATOR_USER_ID]), createdAt = LocalDateTime.parse(parts[TaskColumnIndex.CREATED_AT]), updatedAt = LocalDateTime.parse(parts[TaskColumnIndex.UPDATED_AT]) diff --git a/src/main/kotlin/data/datasource/csv/parser/UserParser.kt b/src/main/kotlin/data/datasource/csv/parser/UserParser.kt index a5cbd561..e7549e60 100644 --- a/src/main/kotlin/data/datasource/csv/parser/UserParser.kt +++ b/src/main/kotlin/data/datasource/csv/parser/UserParser.kt @@ -2,7 +2,7 @@ package data.datasource.csv.parser import ui.common.exception.EmptyCSVFileException import ui.common.exception.InvalidDataFileException -import domain.model.Role +import domain.model.UserRole import domain.model.User import java.util.* @@ -12,21 +12,32 @@ class UserParser : CsvParser { if (trimmedLine.isBlank()) { throw EmptyCSVFileException() } - val fields = data.datasource.csv.helper.smartCsvSplit(trimmedLine).map { it.trim().removeSurrounding("[", "]").removeSurrounding("\"") } + val fields = data.datasource.csv.helper.smartCsvSplit(trimmedLine) + .map { it.trim() + .removeSurrounding("[", "]") + .removeSurrounding("\"") } val stringIdToUUID = UUID.fromString(fields[data.datasource.csv.column_index.UserColumnIndex.ID]) val name = fields[data.datasource.csv.column_index.UserColumnIndex.NAME] val password = fields[data.datasource.csv.column_index.UserColumnIndex.PASSWORD] val email = fields[data.datasource.csv.column_index.UserColumnIndex.EMAIL] - val role = Role.valueOf(fields[data.datasource.csv.column_index.UserColumnIndex.ROLE]) + val userRole = UserRole.valueOf(fields[data.datasource.csv.column_index.UserColumnIndex.ROLE]) val isDeleted = fields[data.datasource.csv.column_index.UserColumnIndex.IS_DELETED].toBoolean() - if (stringIdToUUID == UUID( - 0, 0 - ) || name.isBlank() || password.isBlank() || email.isBlank() || role.toString().isBlank() + + if (stringIdToUUID == UUID(0, 0) + || name.isBlank() + || password.isBlank() + || email.isBlank() + || userRole.toString().isBlank() ) { throw InvalidDataFileException() } return User( - id = stringIdToUUID, name = name, password = password, email = email, role = role, isDeleted = isDeleted + id = stringIdToUUID, + name = name, + password = password, + email = email, + userRole = userRole, + isDeleted = isDeleted ) } diff --git a/src/main/kotlin/data/datasource/csv/reader/CsvReader.kt b/src/main/kotlin/data/datasource/csv/reader/CsvReader.kt index 01773d41..1b33ffad 100644 --- a/src/main/kotlin/data/datasource/csv/reader/CsvReader.kt +++ b/src/main/kotlin/data/datasource/csv/reader/CsvReader.kt @@ -5,7 +5,9 @@ import data.datasource.csv.helper.FileName import data.datasource.csv.parser.CsvParser import java.io.File -class CsvReader(private val parser: CsvParser){ +class CsvReader( + private val parser: CsvParser +){ suspend fun read(fileName: String): List{ if (fileName !in FileName.allFiles) throw InvalidFileNameException() diff --git a/src/main/kotlin/data/datasource/csv/writer/ProjectLogWriter.kt b/src/main/kotlin/data/datasource/csv/writer/ProjectLogWriter.kt index 88eff006..ce013683 100644 --- a/src/main/kotlin/data/datasource/csv/writer/ProjectLogWriter.kt +++ b/src/main/kotlin/data/datasource/csv/writer/ProjectLogWriter.kt @@ -1,8 +1,8 @@ package data.datasource.csv.writer import data.datasource.csv.helper.isValidFileName -import ui.common.exception.InvalidFileNameException import domain.model.ProjectLog +import ui.common.exception.InvalidFileNameException import java.io.BufferedWriter import java.io.File import java.io.FileWriter diff --git a/src/main/kotlin/data/datasource/csv/writer/ProjectWriter.kt b/src/main/kotlin/data/datasource/csv/writer/ProjectWriter.kt index 549f1ab4..13abf9c9 100644 --- a/src/main/kotlin/data/datasource/csv/writer/ProjectWriter.kt +++ b/src/main/kotlin/data/datasource/csv/writer/ProjectWriter.kt @@ -22,18 +22,23 @@ class ProjectWriter : CsvWriter { private fun writeProject(items: List, writer: BufferedWriter) { items.forEach { project -> if (isValidProject(project)) - writer.write("[${project.id},${project.title},${project.description},${project.createdAt},${project.updatedAt},${project.states},${project.users}]\n") + writer.write( + "[${project.id}," + + "${project.title}," + + "${project.description}," + + "${project.createdAt}," + + "${project.updatedAt}," + + "${project.taskStates}," + + "${project.users}]\n") } } private fun isValidProject(project: Project): Boolean { - return project.id != UUID( - 0, - 0 - ) && project.title.isNotBlank() && project.description.isNotBlank() && project.creatorUserID != UUID( - 0, - 0 - ) && project.states.isNotEmpty() + return project.id != UUID(0,0) + && project.title.isNotBlank() + && project.description.isNotBlank() + && project.creatorUserID != UUID(0, 0) + && project.taskStates.isNotEmpty() } } diff --git a/src/main/kotlin/data/datasource/csv/writer/StateWriter.kt b/src/main/kotlin/data/datasource/csv/writer/StateWriter.kt index 9a3e3ec3..6d442429 100644 --- a/src/main/kotlin/data/datasource/csv/writer/StateWriter.kt +++ b/src/main/kotlin/data/datasource/csv/writer/StateWriter.kt @@ -2,14 +2,14 @@ package data.datasource.csv.writer import ui.common.exception.InvalidFileNameException import data.datasource.csv.helper.isValidFileName -import domain.model.State +import domain.model.TaskState import java.io.BufferedWriter import java.io.File import java.io.FileWriter import java.util.UUID -class StateWriter : CsvWriter { - override suspend fun writeToFile(items: List, filePath: String) { +class StateWriter : CsvWriter { + override suspend fun writeToFile(items: List, filePath: String) { val file = File(filePath) if (!isValidFileName(file.name)) throw InvalidFileNameException() @@ -21,14 +21,14 @@ class StateWriter : CsvWriter { writer.close() } - private fun writeState(items: List, writer: BufferedWriter) { + private fun writeState(items: List, writer: BufferedWriter) { items.forEach { state -> if (isValidState(state)) writer.write("[${state.id},${state.name}]\n") } } - private fun isValidState(state: State): Boolean { - return state.name.isNotBlank() && state.id != UUID(0, 0) + private fun isValidState(taskState: TaskState): Boolean { + return taskState.name.isNotBlank() && taskState.id != UUID(0, 0) } } \ No newline at end of file diff --git a/src/main/kotlin/data/datasource/csv/writer/TaskLogWriter.kt b/src/main/kotlin/data/datasource/csv/writer/TaskLogWriter.kt index da4db10b..4e73325d 100644 --- a/src/main/kotlin/data/datasource/csv/writer/TaskLogWriter.kt +++ b/src/main/kotlin/data/datasource/csv/writer/TaskLogWriter.kt @@ -24,11 +24,20 @@ class TaskLogWriter : CsvWriter { private fun writeTaskLog(items: List, writer: BufferedWriter) { items.forEach { taskLog -> if (isValidTaskLog(taskLog)) - writer.write("${taskLog.id},${taskLog.userId},${taskLog.entityId},${taskLog.currentEntity},${taskLog.currentEntity},${taskLog.createdAt}\n") + writer.write( + "${taskLog.id}," + + "${taskLog.userId}," + + "${taskLog.entityId}," + + "${taskLog.currentEntity}," + + "${taskLog.currentEntity}," + + "${taskLog.createdAt}\n" + ) } } private fun isValidTaskLog(taskLog: TaskLog): Boolean { - return taskLog.id != UUID(0, 0) && taskLog.userId != UUID(0, 0) && taskLog.entityId != UUID(0, 0) + return taskLog.id != UUID(0, 0) + && taskLog.userId != UUID(0, 0) + && taskLog.entityId != UUID(0, 0) } } \ No newline at end of file diff --git a/src/main/kotlin/data/datasource/csv/writer/TaskWriter.kt b/src/main/kotlin/data/datasource/csv/writer/TaskWriter.kt index 73e2985a..1e1bc8a1 100644 --- a/src/main/kotlin/data/datasource/csv/writer/TaskWriter.kt +++ b/src/main/kotlin/data/datasource/csv/writer/TaskWriter.kt @@ -27,7 +27,7 @@ class TaskWriter : CsvWriter { "${task.projectId}," + "${task.title}," + "${task.description}," + - "[${task.state.id},${task.state.name}]," + + "[${task.taskState.id},${task.taskState.name}]," + "${task.creatorUserID}," + "${task.createdAt}," + "${task.updatedAt}\n" diff --git a/src/main/kotlin/data/datasource/csv/writer/UserWriter.kt b/src/main/kotlin/data/datasource/csv/writer/UserWriter.kt index 9b9f88e7..95470df3 100644 --- a/src/main/kotlin/data/datasource/csv/writer/UserWriter.kt +++ b/src/main/kotlin/data/datasource/csv/writer/UserWriter.kt @@ -16,11 +16,21 @@ class UserWriter : CsvWriter { private fun writeUser(items: List, file: File) { file.writeText("") items.forEach { user -> - file.appendText("[${user.id},${user.name},${user.password},${user.email},${user.role},${user.isDeleted}]\n") + file.appendText("[" + + "${user.id}," + + "${user.name}," + + "${user.password}," + + "${user.email}," + + "${user.userRole}," + + "${user.isDeleted}]\n" + ) } } internal fun isValidUser(user: User): Boolean { - return user.id != UUID(0, 0) && user.name.isNotBlank() && user.password.isNotBlank() && user.email.isNotBlank() + return user.id != UUID(0, 0) + && user.name.isNotBlank() + && user.password.isNotBlank() + && user.email.isNotBlank() } } \ No newline at end of file diff --git a/src/main/kotlin/data/datasource/fake/AuthenticationDataSourceFake.kt b/src/main/kotlin/data/datasource/fake/AuthenticationDataSource.kt similarity index 64% rename from src/main/kotlin/data/datasource/fake/AuthenticationDataSourceFake.kt rename to src/main/kotlin/data/datasource/fake/AuthenticationDataSource.kt index c9fc1a2d..438b9b72 100644 --- a/src/main/kotlin/data/datasource/fake/AuthenticationDataSourceFake.kt +++ b/src/main/kotlin/data/datasource/fake/AuthenticationDataSource.kt @@ -3,12 +3,12 @@ package data.datasource.fake import ui.common.exception.EmailAlreadyExistsException import ui.common.exception.InvalidCredentialsException import ui.common.exception.UserNotLoggedInException -import data.datasource.interfaces.AuthenticationDataSource -import domain.model.Role +import data.datasource.AuthenticationDataSource +import domain.model.UserRole import domain.model.User import java.util.* -class AuthenticationDataSourceFake : AuthenticationDataSource { +class AuthenticationDataSource : AuthenticationDataSource { private val users = mutableListOf() private var currentUser: User? = null @@ -26,24 +26,32 @@ class AuthenticationDataSourceFake : AuthenticationDataSource { } - override suspend fun registerMate(name: String, password: String, email: String): User { - if (users.any { it.email == email }) { + override suspend fun registerMate( + name: String, + password: String, + email: String + ): User { + if (users.any { it.email == email }) { throw EmailAlreadyExistsException() - }else{ - val user = User( - id = UUID.randomUUID(), - name = name, - password = password, - email = email, - role = Role.MATE - ) - users.add(user) - currentUser = user - return user + } else { + val user = User( + id = UUID.randomUUID(), + name = name, + password = password, + email = email, + userRole = UserRole.MATE + ) + users.add(user) + currentUser = user + return user } } - override suspend fun registerAdmin(name: String, password: String, email: String): User { + override suspend fun registerAdmin( + name: String, + password: String, + email: String + ): User { if (users.any { it.email == email }) { throw EmailAlreadyExistsException() } else { @@ -52,7 +60,7 @@ class AuthenticationDataSourceFake : AuthenticationDataSource { name = name, password = password, email = email, - role = Role.ADMIN + userRole = UserRole.ADMIN ) users.add(user) currentUser = user @@ -60,7 +68,7 @@ class AuthenticationDataSourceFake : AuthenticationDataSource { } } - override suspend fun logout(){ + override suspend fun logout() { if (currentUser == null) { throw UserNotLoggedInException() } @@ -68,7 +76,7 @@ class AuthenticationDataSourceFake : AuthenticationDataSource { } override suspend fun isFirstRegister(): Boolean { - return users.isNotEmpty() + return users.isNotEmpty() } override suspend fun getCurrentUser(): User { diff --git a/src/main/kotlin/data/datasource/fake/LogDataSourceFake.kt b/src/main/kotlin/data/datasource/fake/LogDataSource.kt similarity index 82% rename from src/main/kotlin/data/datasource/fake/LogDataSourceFake.kt rename to src/main/kotlin/data/datasource/fake/LogDataSource.kt index 7d999cbc..b2705490 100644 --- a/src/main/kotlin/data/datasource/fake/LogDataSourceFake.kt +++ b/src/main/kotlin/data/datasource/fake/LogDataSource.kt @@ -3,21 +3,23 @@ package data.datasource.fake import ui.common.exception.NoProjectLogsFoundException import domain.model.ProjectLog import domain.model.TaskLog -import data.datasource.interfaces.LogDataSource +import data.datasource.LogDataSource import java.util.* -class LogDataSourceFake : LogDataSource { +class LogDataSource : LogDataSource { private val projectLogs = mutableListOf() private val taskLogs = mutableListOf() override suspend fun getProjectLogs(id: UUID): List { - return projectLogs.filter { it.entityId == id } + return projectLogs + .filter { it.entityId == id } .takeIf { it.isNotEmpty() } ?: throw NoProjectLogsFoundException() } override suspend fun getTaskLogs(id: UUID): List { - return taskLogs.filter { it.entityId == id } + return taskLogs + .filter { it.entityId == id } .takeIf { it.isNotEmpty() } ?: throw NoProjectLogsFoundException() } diff --git a/src/main/kotlin/data/datasource/fake/ProjectFake.kt b/src/main/kotlin/data/datasource/fake/ProjectDataSource.kt similarity index 59% rename from src/main/kotlin/data/datasource/fake/ProjectFake.kt rename to src/main/kotlin/data/datasource/fake/ProjectDataSource.kt index ea1e4180..05219a3f 100644 --- a/src/main/kotlin/data/datasource/fake/ProjectFake.kt +++ b/src/main/kotlin/data/datasource/fake/ProjectDataSource.kt @@ -1,21 +1,21 @@ package data.datasource.fake -import data.datasource.interfaces.ProjectDataSource +import data.datasource.ProjectDataSource import ui.common.exception.ProjectNotFoundException import domain.model.Project -import domain.model.State +import domain.model.TaskState import domain.model.User import java.time.LocalDateTime import java.util.* -class ProjectFakeDataSource : ProjectDataSource { +class ProjectDataSource : ProjectDataSource { private val projects = mutableListOf() - override suspend fun createProject(project: domain.model.Project) { + override suspend fun createProject(project: Project) { projects.add(project) } - override suspend fun editProject(project: domain.model.Project) { + override suspend fun editProject(project: Project) { val wasRemoved = projects.removeIf { it.id == project.id } if (wasRemoved) { projects.add(project) @@ -33,35 +33,37 @@ class ProjectFakeDataSource : ProjectDataSource { } - override suspend fun getAllProjects(): List { + override suspend fun getAllProjects(): List { return projects } - override suspend fun getProject(id: UUID): domain.model.Project { - return projects.find { it.id == id } ?: throw ProjectNotFoundException() + override suspend fun getProject(id: UUID): Project { + return projects + .find { it.id == id } + ?: throw ProjectNotFoundException() } - override suspend fun addState(projectId: UUID, state: State): domain.model.Project { - return updateProjectState(projectId, state) + override suspend fun addState(projectId: UUID, taskState: TaskState): Project { + return updateProjectState(projectId, taskState) } - override suspend fun editState(projectId: UUID, state: State): domain.model.Project { - return editProjectState(projectId, state) + override suspend fun editState(projectId: UUID, taskState: TaskState): Project { + return editProjectState(projectId, taskState) } - override suspend fun deleteState(projectId: UUID, state: State): domain.model.Project { - return deleteProjectState(projectId, state) + override suspend fun deleteState(projectId: UUID, taskState: TaskState): Project { + return deleteProjectState(projectId, taskState) } - override suspend fun getUserProjectsById(userId: UUID): List { + override suspend fun getUserProjectsById(userId: UUID): List { return projects.filter { project -> project.users.any { user -> user.id == userId } } } - override suspend fun addMate(projectId: UUID, user: User): domain.model.Project { - var updatedProject: domain.model.Project? = null + override suspend fun addMate(projectId: UUID, user: User): Project { + var updatedProject: Project? = null projects.replaceAll { project -> if (project.id == projectId) { val updatedUsers = if (user in project.users) project.users else project.users + user @@ -79,12 +81,15 @@ class ProjectFakeDataSource : ProjectDataSource { } - private fun updateProjectState(projectId: UUID, state: State): domain.model.Project { - var updatedProject: domain.model.Project? = null + private fun updateProjectState( + projectId: UUID, + taskState: TaskState + ): Project { + var updatedProject: Project? = null projects.replaceAll { project -> if (project.id == projectId) { val projectUpdated = project.copy( - states = project.states + listOf(state), + taskStates = project.taskStates + listOf(taskState), updatedAt = LocalDateTime.now() ) updatedProject = projectUpdated @@ -96,15 +101,18 @@ class ProjectFakeDataSource : ProjectDataSource { return updatedProject ?: throw ProjectNotFoundException() } - private fun editProjectState(projectId: UUID, updatedState: State): domain.model.Project { - var updatedProject: domain.model.Project? = null + private fun editProjectState( + projectId: UUID, + updatedTaskState: TaskState + ): Project { + var updatedProject: Project? = null projects.replaceAll { project -> if (project.id == projectId) { - val updatedStates = project.states.map { existingState -> - if (existingState.id == updatedState.id) updatedState else existingState + val updatedStates = project.taskStates.map { existingState -> + if (existingState.id == updatedTaskState.id) updatedTaskState else existingState } val projectUpdated = project.copy( - states = updatedStates, + taskStates = updatedStates, updatedAt = LocalDateTime.now() ) updatedProject = projectUpdated @@ -116,12 +124,15 @@ class ProjectFakeDataSource : ProjectDataSource { return updatedProject ?: throw ProjectNotFoundException() } - private fun deleteProjectState(projectId: UUID, state: State): domain.model.Project { - var updatedProject: domain.model.Project? = null + private fun deleteProjectState( + projectId: UUID, + taskState: TaskState + ): Project { + var updatedProject: Project? = null projects.replaceAll { project -> if (project.id == projectId) { val projectUpdated = project.copy( - states = project.states.filterNot { it.id == state.id }, + taskStates = project.taskStates.filterNot { it.id == taskState.id }, updatedAt = LocalDateTime.now() ) updatedProject = projectUpdated diff --git a/src/main/kotlin/data/datasource/fake/TaskFakeDataSource.kt b/src/main/kotlin/data/datasource/fake/TaskFakeDataSource.kt index ee4b0c38..4ca5fb98 100644 --- a/src/main/kotlin/data/datasource/fake/TaskFakeDataSource.kt +++ b/src/main/kotlin/data/datasource/fake/TaskFakeDataSource.kt @@ -2,7 +2,7 @@ package data.datasource.fake import ui.common.exception.StateNotFoundException import ui.common.exception.TaskNotFoundException -import data.datasource.interfaces.TaskDataSource +import data.datasource.TaskDataSource import domain.model.Task import java.util.* @@ -44,12 +44,15 @@ class TaskFakeDataSource : TaskDataSource { ): List { val tasks = getAllTasks() - val filteredTasks = tasks.filter { it.projectId == projectId && it.state.id == stateId } + val filteredTasks = tasks.filter { + it.projectId == projectId && it.taskState.id == stateId + } return filteredTasks.ifEmpty { throw StateNotFoundException() } } override suspend fun getAllTasksForProject(projectId: UUID): List { - return tasks.filter { it.projectId == projectId }.ifEmpty { throw TaskNotFoundException() } + return tasks.filter { it.projectId == projectId } + .ifEmpty { throw TaskNotFoundException() } } } diff --git a/src/main/kotlin/data/datasource/mongo/implementation/AuthenticationDataSourceMongoImpl.kt b/src/main/kotlin/data/datasource/mongo/AuthenticationDataSourceMongoImpl.kt similarity index 83% rename from src/main/kotlin/data/datasource/mongo/implementation/AuthenticationDataSourceMongoImpl.kt rename to src/main/kotlin/data/datasource/mongo/AuthenticationDataSourceMongoImpl.kt index 771f04ea..185d6dd3 100644 --- a/src/main/kotlin/data/datasource/mongo/implementation/AuthenticationDataSourceMongoImpl.kt +++ b/src/main/kotlin/data/datasource/mongo/AuthenticationDataSourceMongoImpl.kt @@ -1,11 +1,11 @@ -package data.datasource.mongo.implementation +package data.datasource.mongo -import data.datasource.interfaces.AuthenticationDataSource +import data.datasource.AuthenticationDataSource import data.datasource.mongo.mapper.toDocument import data.datasource.mongo.mapper.toUser import data.datasource.mongo.mongo_db_connection.MongoConnection import ui.common.exception.EmailAlreadyExistsException -import domain.model.Role +import domain.model.UserRole import domain.model.User import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext @@ -18,7 +18,8 @@ import java.util.* class AuthenticationMongoDataSourceImpl( private val mongoConnection: MongoConnection, ) : AuthenticationDataSource { - override suspend fun login(email: String, password: String): User { + override suspend fun login(email: String, password: String) + : User { return withContext(Dispatchers.IO) { val filter = Document(EMAIL_FILED, email).append(PASSWORD_FILED, password) val document = mongoConnection.users.find(filter).firstOrNull() @@ -30,17 +31,19 @@ class AuthenticationMongoDataSourceImpl( } } - override suspend fun isValidEmail(email: String): Boolean { + override suspend fun isValidEmail(email: String) + : Boolean { return withContext(Dispatchers.IO) { val filter = Document(EMAIL_FILED, email) mongoConnection.users.find(filter).firstOrNull() != null } } - override suspend fun registerMate(name: String, password: String, email: String): User { + override suspend fun registerMate(name: String, password: String, email: String) + : User { return withContext(Dispatchers.IO) { if (!isEmailExists(email)) { - val newUser = createUser(name, password, email, Role.MATE) + val newUser = createUser(name, password, email, UserRole.MATE) mongoConnection.users.insertOne(newUser.toDocument()) saveCurrentUser(newUser) newUser @@ -49,10 +52,11 @@ class AuthenticationMongoDataSourceImpl( } } - override suspend fun registerAdmin(name: String, password: String, email: String): User { + override suspend fun registerAdmin(name: String, password: String, email: String) + : User { return withContext(Dispatchers.IO) { if (!isEmailExists(email)) { - val newAdmin = createUser(name, password, email, Role.ADMIN) + val newAdmin = createUser(name, password, email, UserRole.ADMIN) mongoConnection.users.insertOne(newAdmin.toDocument()) saveCurrentUser(newAdmin) newAdmin @@ -65,7 +69,6 @@ class AuthenticationMongoDataSourceImpl( override suspend fun logout() { withContext(Dispatchers.IO) { -// val currentUser = mongoConnection.currentUser.find().firstOrNull() ?: throw UserNotLoggedInException() mongoConnection.currentUser.deleteMany(Document()) } } @@ -101,19 +104,28 @@ class AuthenticationMongoDataSourceImpl( } } - private fun createUser(name: String, password: String, email: String, role: Role): User { + private fun createUser( + name: String, + password: String, + email: String, + userRole: UserRole + ): User { return User( id = UUID.randomUUID(), name = name, password = password, email = email, - role = role, + userRole = userRole, isDeleted = false ) } - private fun isEmailExists(email: String):Boolean { - return mongoConnection.users.find(Document(EMAIL_FILED, email)).first() != null + private fun isEmailExists(email: String) + :Boolean { + return mongoConnection + .users + .find(Document(EMAIL_FILED, email)) + .first() != null } companion object { diff --git a/src/main/kotlin/data/datasource/mongo/implementation/LogDataSourceMongoImpl.kt b/src/main/kotlin/data/datasource/mongo/LogDataSourceMongoImpl.kt similarity index 66% rename from src/main/kotlin/data/datasource/mongo/implementation/LogDataSourceMongoImpl.kt rename to src/main/kotlin/data/datasource/mongo/LogDataSourceMongoImpl.kt index ac2d8c3d..cea4ae10 100644 --- a/src/main/kotlin/data/datasource/mongo/implementation/LogDataSourceMongoImpl.kt +++ b/src/main/kotlin/data/datasource/mongo/LogDataSourceMongoImpl.kt @@ -1,4 +1,4 @@ -package data.datasource.mongo.implementation +package data.datasource.mongo import com.mongodb.client.model.Filters import ui.common.exception.NoProjectLogsFoundException @@ -11,7 +11,7 @@ import domain.model.ProjectLog import domain.model.TaskLog import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext -import data.datasource.interfaces.LogDataSource +import data.datasource.LogDataSource import java.util.UUID class LogDataSourceMongoImpl( @@ -19,35 +19,56 @@ class LogDataSourceMongoImpl( ) : LogDataSource { override suspend fun getProjectLogs(id: UUID): List = withContext(Dispatchers.IO) { - val logs = mongoConnection.projectLogs.find(Filters.eq(ENTITY_ID_FILED, id.toString())).toList() + val logs = mongoConnection.projectLogs + .find(Filters.eq(ENTITY_ID_FILED, id.toString())) + .toList() + if (logs.isEmpty()) throw NoProjectLogsFoundException() logs.map { it.toProjectLog() } } override suspend fun getTaskLogs(id: UUID): List = withContext(Dispatchers.IO) { - val logs = mongoConnection.taskLogs.find(Filters.eq(ENTITY_ID_FILED, id.toString())).toList() + val logs = mongoConnection + .taskLogs + .find(Filters.eq(ENTITY_ID_FILED, id.toString())) + .toList() + if (logs.isEmpty()) throw NoTaskLogsFoundException() logs.map { it.toTaskLog() } } override suspend fun saveProjectLog(projectLog: ProjectLog) { withContext(Dispatchers.IO) { - mongoConnection.projectLogs.insertOne(projectLog.toDocument()) + mongoConnection + .projectLogs + .insertOne(projectLog.toDocument()) } } override suspend fun saveTaskLog(taskLog: TaskLog) { withContext(Dispatchers.IO) { - mongoConnection.taskLogs.insertOne(taskLog.toDocument()) + mongoConnection + .taskLogs + .insertOne(taskLog.toDocument()) } } override suspend fun getAllProjectLogs(): List = withContext(Dispatchers.IO) { - mongoConnection.projectLogs.find().toList().map { it.toProjectLog() } + mongoConnection + .projectLogs + .find() + .toList() + .map { + it.toProjectLog() + } } override suspend fun getAllTaskLogs(): List = withContext(Dispatchers.IO) { - val logs = mongoConnection.taskLogs.find().toList() + val logs = mongoConnection + .taskLogs + .find() + .toList() + if (logs.isEmpty()) throw NoTaskLogsFoundException() logs.map { it.toTaskLog() } } diff --git a/src/main/kotlin/data/datasource/mongo/implementation/ProjectDataSourceMongoImpl.kt b/src/main/kotlin/data/datasource/mongo/ProjectDataSourceMongoImpl.kt similarity index 67% rename from src/main/kotlin/data/datasource/mongo/implementation/ProjectDataSourceMongoImpl.kt rename to src/main/kotlin/data/datasource/mongo/ProjectDataSourceMongoImpl.kt index 24f92bd2..cac15285 100644 --- a/src/main/kotlin/data/datasource/mongo/implementation/ProjectDataSourceMongoImpl.kt +++ b/src/main/kotlin/data/datasource/mongo/ProjectDataSourceMongoImpl.kt @@ -1,14 +1,14 @@ -package data.datasource.mongo.implementation +package data.datasource.mongo import com.mongodb.client.model.Filters import com.mongodb.client.model.Updates -import data.datasource.interfaces.ProjectDataSource +import data.datasource.ProjectDataSource import data.datasource.mongo.mapper.toDocument import data.datasource.mongo.mapper.toProject import ui.common.exception.ProjectNotFoundException import ui.common.exception.StateNotFoundException import domain.model.Project -import domain.model.State +import domain.model.TaskState import domain.model.User import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext @@ -22,7 +22,6 @@ class ProjectDataSourceMongoImpl( override suspend fun createProject(project: Project) { withContext(Dispatchers.IO) { mongoConnection.projects.insertOne(project.toDocument()) - } } @@ -32,19 +31,24 @@ class ProjectDataSourceMongoImpl( Filters.eq(ID_FILED, project.id.toString()), project.toDocument() ) ?: throw ProjectNotFoundException() - } } override suspend fun deleteProject(id: UUID) { withContext(Dispatchers.IO) { - mongoConnection.projects.deleteOne(Filters.eq(ID_FILED, id.toString())) + mongoConnection + .projects. + deleteOne(Filters.eq(ID_FILED, id.toString())) } } override suspend fun getAllProjects(): List { return withContext(Dispatchers.IO) { - val projectsDoc = mongoConnection.projects.find().toList() + val projectsDoc = mongoConnection + .projects + .find() + .toList() + projectsDoc.map { it?.toProject() ?: throw ProjectNotFoundException() } @@ -54,18 +58,23 @@ class ProjectDataSourceMongoImpl( override suspend fun getProject(id: UUID): Project { return withContext(Dispatchers.IO) { - val document = mongoConnection.projects.find(Filters.eq(ID_FILED, id.toString())).firstOrNull() + val document = mongoConnection + .projects + .find(Filters.eq(ID_FILED, id.toString())) + .firstOrNull() ?: throw ProjectNotFoundException() document.toProject() } } - override suspend fun addState(projectId: UUID, state: State): Project { + override suspend fun addState(projectId: UUID, taskState: TaskState): Project { return withContext(Dispatchers.IO) { - val stateDoc = Updates.push(STATE_FILED, state.toDocument()) + val stateDoc = Updates.push(STATE_FILED, taskState.toDocument()) - mongoConnection.projects.updateOne(Filters.eq(ID_FILED, projectId.toString()), stateDoc) + mongoConnection + .projects + .updateOne(Filters.eq(ID_FILED, projectId.toString()), stateDoc) val updatedDoc = mongoConnection.projects.find(Filters.eq(ID_FILED, projectId.toString())).firstOrNull() ?: throw ProjectNotFoundException() @@ -74,19 +83,22 @@ class ProjectDataSourceMongoImpl( } } - override suspend fun editState(projectId: UUID, state: State): Project { + override suspend fun editState(projectId: UUID, taskState: TaskState): Project { return withContext(Dispatchers.IO) { - val project = mongoConnection.projects.find(Filters.eq(ID_FILED, projectId.toString())).firstOrNull() + val project = mongoConnection + .projects + .find(Filters.eq(ID_FILED, projectId.toString())) + .firstOrNull() ?: throw ProjectNotFoundException() val states = (project[STATE_FILED] as? List<*>)?.mapNotNull { (it as? Document) }?.toMutableList() ?: mutableListOf() - val index = states.indexOfFirst { it.getString(ID_FILED) == state.id.toString() } + val index = states.indexOfFirst { it.getString(ID_FILED) == taskState.id.toString() } if (index == -1) throw StateNotFoundException() - states[index] = state.toDocument() + states[index] = taskState.toDocument() val update = Updates.set(STATE_FILED, states) mongoConnection.projects.updateOne(Filters.eq(ID_FILED, projectId.toString()), update) @@ -96,16 +108,19 @@ class ProjectDataSourceMongoImpl( } } - override suspend fun deleteState(projectId: UUID, state: State): Project { + override suspend fun deleteState(projectId: UUID, taskState: TaskState): Project { return withContext(Dispatchers.IO) { val filter = Filters.eq(ID_FILED, projectId.toString()) - val update = Updates.pull(STATE_FILED, Document(ID_FILED, state.id.toString())) + val update = Updates.pull(STATE_FILED, Document(ID_FILED, taskState.id.toString())) val result = mongoConnection.projects.updateOne(filter, update) if (result.modifiedCount == 0L) { throw StateNotFoundException() } - val updatedDoc = mongoConnection.projects.find(Filters.eq(ID_FILED, projectId.toString())).firstOrNull() + val updatedDoc = mongoConnection + .projects + .find(Filters.eq(ID_FILED, projectId.toString())) + .firstOrNull() ?: throw ProjectNotFoundException() updatedDoc.toProject() @@ -117,13 +132,18 @@ class ProjectDataSourceMongoImpl( return withContext(Dispatchers.IO) { val update = Updates.push(USERS_FILED, user.toDocument()) - val result = mongoConnection.projects.updateOne(Filters.eq(ID_FILED, projectId.toString()), update) + val result = mongoConnection + .projects + .updateOne(Filters.eq(ID_FILED, projectId.toString()), update) if (result.matchedCount == 0L) { throw ProjectNotFoundException() } - val updatedDoc = mongoConnection.projects.find(Filters.eq(ID_FILED, projectId.toString())).firstOrNull() + val updatedDoc = mongoConnection + .projects + .find(Filters.eq(ID_FILED, projectId.toString())) + .firstOrNull() ?: throw ProjectNotFoundException() updatedDoc.toProject() @@ -133,7 +153,11 @@ class ProjectDataSourceMongoImpl( override suspend fun getUserProjectsById(userId: UUID): List { return withContext(Dispatchers.IO) { val filter = Filters.elemMatch(USERS_FILED, Filters.eq(ID_FILED, userId.toString())) - val projectDocs = mongoConnection.projects.find(filter).toList() + val projectDocs = mongoConnection + .projects + .find(filter) + .toList() + projectDocs.mapNotNull { it?.toProject() } } } diff --git a/src/main/kotlin/data/datasource/mongo/implementation/TaskMongoDataSourceImpl.kt b/src/main/kotlin/data/datasource/mongo/TaskMongoDataSourceImpl.kt similarity index 77% rename from src/main/kotlin/data/datasource/mongo/implementation/TaskMongoDataSourceImpl.kt rename to src/main/kotlin/data/datasource/mongo/TaskMongoDataSourceImpl.kt index e10df09f..79c57c13 100644 --- a/src/main/kotlin/data/datasource/mongo/implementation/TaskMongoDataSourceImpl.kt +++ b/src/main/kotlin/data/datasource/mongo/TaskMongoDataSourceImpl.kt @@ -1,6 +1,7 @@ -package data.datasource.mongo.implementation +package data.datasource.mongo import com.mongodb.client.model.Filters +import com.mongodb.client.model.Filters.and import data.datasource.mongo.mapper.toDocument import data.datasource.mongo.mapper.toTask import ui.common.exception.TaskDeletionFailedException @@ -11,7 +12,7 @@ import domain.model.Task import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext import org.bson.Document -import data.datasource.interfaces.TaskDataSource +import data.datasource.TaskDataSource import java.util.UUID class TaskMongoDataSourceImpl( @@ -26,9 +27,12 @@ class TaskMongoDataSourceImpl( override suspend fun editTask(task: Task) { withContext(Dispatchers.IO) { - val updatedTask = mongoConnection.tasks.replaceOne( - Filters.eq(ID_FILED, task.id.toString()), - task.toDocument() + val updatedTask = mongoConnection + .tasks + .replaceOne(Filters.eq( + ID_FILED, + task.id.toString()), + task.toDocument() ) if (updatedTask.modifiedCount == 0L) { throw TaskEditFailedException() @@ -49,7 +53,7 @@ class TaskMongoDataSourceImpl( return withContext(Dispatchers.IO) { val documents = mongoConnection.tasks.find().toList() - documents.map {document -> + documents.map { document -> document?.toTask() ?: throw TaskNotFoundException() } } @@ -66,12 +70,13 @@ class TaskMongoDataSourceImpl( override suspend fun getTasksByStateAndProjectIds(projectId: UUID, stateId: UUID): List { return withContext(Dispatchers.IO) { - val filter = Document(PROJECT_ID_FILED, projectId.toString()) - .append(ID_FILED, stateId.toString()) - + val filter = and( + Document(PROJECT_ID_FILED, projectId.toString()), + Document("$STATE_FILED.$ID_FILED", stateId.toString()) + ) val documents = mongoConnection.tasks.find(filter).toList() - documents.map {document -> + documents.map { document -> document?.toTask() ?: throw TaskNotFoundException() } } @@ -82,14 +87,15 @@ class TaskMongoDataSourceImpl( val filter = Document(PROJECT_ID_FILED, projectId.toString()) val documents = mongoConnection.tasks.find(filter).toList() - documents.map {document -> + documents.map { document -> document?.toTask() ?: throw TaskNotFoundException() } } } companion object { - const val ID_FILED = "_id" - const val PROJECT_ID_FILED = "projectId" + private const val ID_FILED = "_id" + private const val PROJECT_ID_FILED = "projectId" + const val STATE_FILED = "state" } } \ No newline at end of file diff --git a/src/main/kotlin/data/datasource/mongo/mapper/DocumentsMappers.kt b/src/main/kotlin/data/datasource/mongo/mapper/DocumentMappers.kt similarity index 65% rename from src/main/kotlin/data/datasource/mongo/mapper/DocumentsMappers.kt rename to src/main/kotlin/data/datasource/mongo/mapper/DocumentMappers.kt index c6d71b0f..9ee86779 100644 --- a/src/main/kotlin/data/datasource/mongo/mapper/DocumentsMappers.kt +++ b/src/main/kotlin/data/datasource/mongo/mapper/DocumentMappers.kt @@ -6,8 +6,11 @@ import java.time.LocalDateTime import java.util.UUID fun User.toDocument(): Document { - return Document(ID_FILED, this.id.toString()).append(NAME_FILED, this.name).append(EMAIL_FILED, this.email) - .append(PASSWORD_FILED, this.password).append(ROLE_FILED, this.role.name) + return Document(ID_FILED, this.id.toString()) + .append(NAME_FILED, this.name) + .append(EMAIL_FILED, this.email) + .append(PASSWORD_FILED, this.password) + .append(ROLE_FILED, this.userRole.name) .append(IS_DELETED_FILED, this.isDeleted) } @@ -17,19 +20,27 @@ fun Document.toUser(): User { name = this.getString(NAME_FILED), password = this.getString(PASSWORD_FILED), email = this.getString(EMAIL_FILED), - role = Role.valueOf(this.getString(ROLE_FILED)), + userRole = UserRole.valueOf(this.getString(ROLE_FILED)), isDeleted = this.getBoolean(IS_DELETED_FILED, false) ) } fun ProjectLog.toDocument(): Document = - Document().append(ID_FILED, id.toString()).append(USER_ID_FILED, userId.toString()) - .append(ENTITY_ID_FILED, entityId.toString()).append(PREVIOUS_ENTITY_FILED, previousEntity?.toDocument()) - .append(CURRENT_ENTITY_FILED, currentEntity?.toDocument()).append(CREATED_AT_FILED, createdAt.toString()) - -fun TaskLog.toDocument(): Document = Document().append(ID_FILED, id.toString()).append(USER_ID_FILED, userId.toString()) - .append(ENTITY_ID_FILED, entityId.toString()).append(PREVIOUS_ENTITY_FILED, previousEntity?.toDocument()) - .append(CURRENT_ENTITY_FILED, currentEntity?.toDocument()).append(CREATED_AT_FILED, createdAt.toString()) + Document() + .append(ID_FILED, id.toString()) + .append(USER_ID_FILED, userId.toString()) + .append(ENTITY_ID_FILED, entityId.toString()) + .append(PREVIOUS_ENTITY_FILED, previousEntity?.toDocument()) + .append(CURRENT_ENTITY_FILED, currentEntity?.toDocument()) + .append(CREATED_AT_FILED, createdAt.toString()) + +fun TaskLog.toDocument(): Document = Document() + .append(ID_FILED, id.toString()) + .append(USER_ID_FILED, userId.toString()) + .append(ENTITY_ID_FILED, entityId.toString()) + .append(PREVIOUS_ENTITY_FILED, previousEntity?.toDocument()) + .append(CURRENT_ENTITY_FILED, currentEntity?.toDocument()) + .append(CREATED_AT_FILED, createdAt.toString()) fun Document.toProjectLog(): ProjectLog = ProjectLog( id = UUID.fromString(getString(ID_FILED)), @@ -50,9 +61,13 @@ fun Document.toTaskLog(): TaskLog = TaskLog( ) fun Task.toDocument(): Document { - return Document(ID_FILED, id.toString()).append(PROJECT_ID_FILED, projectId.toString()).append(TITLE_FILED, title) - .append(DESCRIPTION_FILED, description).append(STATE_FILED, state.toDocument()) - .append(CREATOR_USER_ID_FILED, creatorUserID.toString()).append(CREATED_AT_FILED, createdAt.toString()) + return Document(ID_FILED, id.toString()) + .append(PROJECT_ID_FILED, projectId.toString()) + .append(TITLE_FILED, title) + .append(DESCRIPTION_FILED, description) + .append(STATE_FILED, taskState.toDocument()) + .append(CREATOR_USER_ID_FILED, creatorUserID.toString()) + .append(CREATED_AT_FILED, createdAt.toString()) .append(UPDATED_AT_FILED, updatedAt.toString()) } @@ -62,15 +77,15 @@ fun Document.toTask(): Task { projectId = UUID.fromString(this.getString(PROJECT_ID_FILED)), title = this.getString(TITLE_FILED), description = this.getString(DESCRIPTION_FILED), - state = this.toState(), + taskState = this.toState(), creatorUserID = UUID.fromString(this.getString(CREATOR_USER_ID_FILED)), createdAt = LocalDateTime.parse(this.getString(CREATED_AT_FILED)), updatedAt = LocalDateTime.parse(this.getString(UPDATED_AT_FILED)) ) } -fun Document.toState(): State { +fun Document.toState(): TaskState { val state = this[STATE_FILED] as Document - return State( + return TaskState( id = UUID.fromString(state.getString(ID_FILED)), name = state.getString(NAME_FILED) ) @@ -86,24 +101,35 @@ fun Document.toProject(): Project { creatorUserID = UUID.fromString(this.getString(CREATOR_USER_ID_FILED)), createdAt = LocalDateTime.parse(this.getString(CREATED_AT_FILED)), updatedAt = LocalDateTime.parse(this.getString(UPDATED_AT_FILED)), - states = states, + taskStates = states, users = users ) } fun Project.toDocument(): Document { - return Document(ID_FILED, id.toString()).append(NAME_FILED, title).append(DESCRIPTION_FILED, description) - .append(CREATOR_USER_ID_FILED, creatorUserID.toString()).append(CREATED_AT_FILED, createdAt.toString()) - .append(UPDATED_AT_FILED, updatedAt.toString()).append(STATE_FILED, states.map { - Document(ID_FILED, it.id.toString()).append(NAME_FILED, it.name) + return Document(ID_FILED, id.toString()) + .append(NAME_FILED, title) + .append(DESCRIPTION_FILED, description) + .append(CREATOR_USER_ID_FILED, creatorUserID.toString()) + .append(CREATED_AT_FILED, createdAt.toString()) + .append(UPDATED_AT_FILED, updatedAt.toString()) + .append(STATE_FILED, taskStates.map { + Document(ID_FILED, it.id.toString()) + .append(NAME_FILED, it.name) }).append(USERS_FILED, users.map { - Document(ID_FILED, it.id.toString()).append(NAME_FILED, it.name).append(PASSWORD_FILED, it.password) - .append(EMAIL_FILED, it.email).append(ROLE_FILED, it.role.name).append(IS_DELETED_FILED, it.isDeleted) + Document(ID_FILED, it.id.toString()) + .append(NAME_FILED, it.name) + .append(PASSWORD_FILED, it.password) + .append(EMAIL_FILED, it.email) + .append(ROLE_FILED, it.userRole.name) + .append(IS_DELETED_FILED, it.isDeleted) }) } -fun State.toDocument(): Document { - return Document().append(ID_FILED, this.id.toString()).append(NAME_FILED, this.name) +fun TaskState.toDocument(): Document { + return Document() + .append(ID_FILED, this.id.toString()) + .append(NAME_FILED, this.name) } fun Document.toUserList(filedName: String = USERS_FILED): List { @@ -114,18 +140,19 @@ fun Document.toUserList(filedName: String = USERS_FILED): List { name = it.getString(NAME_FILED), password = it.getString(PASSWORD_FILED), email = it.getString(EMAIL_FILED), - role = Role.valueOf(it.getString(ROLE_FILED)), + userRole = UserRole.valueOf(it.getString(ROLE_FILED)), isDeleted = it.getBoolean(IS_DELETED_FILED) ) } } ?: emptyList() } -private fun Document.toStateList(): List { +private fun Document.toStateList(): List { return (this[STATE_FILED] as? List<*>)?.mapNotNull { stateDoc -> (stateDoc as? Document)?.let { - State( - id = UUID.fromString(it.getString(ID_FILED)), name = it.getString(NAME_FILED) + TaskState( + id = UUID.fromString(it.getString(ID_FILED)), + name = it.getString(NAME_FILED) ) } } ?: emptyList() diff --git a/src/main/kotlin/data/repository/AuthenticationRepositoryImpl.kt b/src/main/kotlin/data/repository/AuthenticationRepositoryImpl.kt index bb23f0bd..4f5eaf45 100644 --- a/src/main/kotlin/data/repository/AuthenticationRepositoryImpl.kt +++ b/src/main/kotlin/data/repository/AuthenticationRepositoryImpl.kt @@ -1,37 +1,59 @@ package data.repository -import data.datasource.interfaces.AuthenticationDataSource +import data.datasource.AuthenticationDataSource import domain.model.User import domain.repository.AuthenticationRepository class AuthenticationRepositoryImpl( private val authenticationDataSource: AuthenticationDataSource ) : AuthenticationRepository { - override suspend fun login(email: String, password: String): User { - return authenticationDataSource.login(email = email, password = password) + override suspend fun login( + email: String, + password: String + ): User { + return authenticationDataSource.login( + email = email, + password = password + ) } override suspend fun checkEmail(email: String) { - authenticationDataSource.isValidEmail(email) + authenticationDataSource.isValidEmail(email) } - override suspend fun registerMate(name: String, password: String, email: String): User { - return authenticationDataSource.registerMate(email = email, password = password, name = name) + override suspend fun registerMate( + name: String, + password: String, + email: String + ): User { + return authenticationDataSource.registerMate( + email = email, + password = password, + name = name + ) } - override suspend fun registerAdmin(name: String, password: String, email: String): User { - return authenticationDataSource.registerAdmin(email = email, password = password, name = name) + override suspend fun registerAdmin( + name: String, + password: String, + email: String + ): User { + return authenticationDataSource.registerAdmin( + email = email, + password = password, + name = name + ) } override suspend fun logout() { - authenticationDataSource.logout() + authenticationDataSource.logout() } override suspend fun isFirstRegister(): Boolean { - return authenticationDataSource.isFirstRegister() + return authenticationDataSource.isFirstRegister() } - override suspend fun getCurrentLoggedInUser(): User { + override suspend fun getCurrentUser(): User { return authenticationDataSource.getCurrentUser() } diff --git a/src/main/kotlin/data/repository/LogRepositoryImpl.kt b/src/main/kotlin/data/repository/LogRepositoryImpl.kt index 7dc6fe4c..155a720b 100644 --- a/src/main/kotlin/data/repository/LogRepositoryImpl.kt +++ b/src/main/kotlin/data/repository/LogRepositoryImpl.kt @@ -1,6 +1,6 @@ package data.repository -import data.datasource.interfaces.LogDataSource +import data.datasource.LogDataSource import domain.model.ProjectLog import domain.model.TaskLog import domain.repository.LogRepository diff --git a/src/main/kotlin/data/repository/ProjectRepositoryImpl.kt b/src/main/kotlin/data/repository/ProjectRepositoryImpl.kt index 00f3d9f8..2abc65a8 100644 --- a/src/main/kotlin/data/repository/ProjectRepositoryImpl.kt +++ b/src/main/kotlin/data/repository/ProjectRepositoryImpl.kt @@ -1,9 +1,9 @@ package data.repository import domain.model.Project -import domain.model.State +import domain.model.TaskState import domain.model.User -import data.datasource.interfaces.ProjectDataSource +import data.datasource.ProjectDataSource import domain.repository.ProjectRepository import java.util.* @@ -31,23 +31,23 @@ class ProjectRepositoryImpl( return projectDataSource.getProject(id) } - override suspend fun addStateToProject(projectId: UUID, state: State): Project { - return projectDataSource.addState(projectId, state) + override suspend fun addStateToProject(projectId: UUID, taskState: TaskState): Project { + return projectDataSource.addState(projectId, taskState) } - override suspend fun editStateToProject(projectId: UUID, state: State): Project { - return projectDataSource.editState(projectId, state) + override suspend fun editStateToProject(projectId: UUID, taskState: TaskState): Project { + return projectDataSource.editState(projectId, taskState) } - override suspend fun removeStateFromProject(projectId: UUID, state: State): Project { - return projectDataSource.deleteState(projectId, state) + override suspend fun deleteStateFromProject(projectId: UUID, taskState: TaskState): Project { + return projectDataSource.deleteState(projectId, taskState) } override suspend fun addMateToProject(projectId: UUID, user: User): Project { return projectDataSource.addMate(projectId, user) } - override suspend fun getProjectsForUserById(userid: UUID): List { + override suspend fun getUserProjectsById(userid: UUID): List { return projectDataSource.getUserProjectsById(userid) } diff --git a/src/main/kotlin/data/repository/TaskRepositoryImpl.kt b/src/main/kotlin/data/repository/TaskRepositoryImpl.kt index ab0c606c..beef85ad 100644 --- a/src/main/kotlin/data/repository/TaskRepositoryImpl.kt +++ b/src/main/kotlin/data/repository/TaskRepositoryImpl.kt @@ -1,6 +1,6 @@ package data.repository -import data.datasource.interfaces.TaskDataSource +import data.datasource.TaskDataSource import domain.model.Task import domain.repository.TaskRepository import java.util.* @@ -32,7 +32,7 @@ class TaskRepositoryImpl( return taskDataSource.getTasksByStateAndProjectIds(projectId, stateId) } - override suspend fun getAllTasksForProject(projectId: UUID): List { + override suspend fun getAllProjectTasks(projectId: UUID): List { return taskDataSource.getAllTasksForProject(projectId) } } \ No newline at end of file diff --git a/src/main/kotlin/di/DataModule.kt b/src/main/kotlin/di/DataModule.kt index c1586e3a..411df222 100644 --- a/src/main/kotlin/di/DataModule.kt +++ b/src/main/kotlin/di/DataModule.kt @@ -1,13 +1,13 @@ package di -import data.datasource.interfaces.AuthenticationDataSource -import data.datasource.mongo.implementation.AuthenticationMongoDataSourceImpl -import data.datasource.mongo.implementation.LogDataSourceMongoImpl -import data.datasource.interfaces.LogDataSource -import data.datasource.interfaces.ProjectDataSource -import data.datasource.interfaces.TaskDataSource -import data.datasource.mongo.implementation.ProjectDataSourceMongoImpl -import data.datasource.mongo.implementation.TaskMongoDataSourceImpl +import data.datasource.AuthenticationDataSource +import data.datasource.mongo.AuthenticationMongoDataSourceImpl +import data.datasource.mongo.LogDataSourceMongoImpl +import data.datasource.LogDataSource +import data.datasource.ProjectDataSource +import data.datasource.TaskDataSource +import data.datasource.mongo.ProjectDataSourceMongoImpl +import data.datasource.mongo.TaskMongoDataSourceImpl import data.repository.AuthenticationRepositoryImpl import data.datasource.mongo.mongo_db_connection.MongoConnection import data.repository.LogRepositoryImpl diff --git a/src/main/kotlin/di/LogicModule.kt b/src/main/kotlin/di/LogicModule.kt index 7aa8c432..04c0f20d 100644 --- a/src/main/kotlin/di/LogicModule.kt +++ b/src/main/kotlin/di/LogicModule.kt @@ -1,20 +1,20 @@ package di import ui.common.exception.handler.SafeExecutor -import domain.use_case.authentication.* -import domain.use_case.log.CreateProjectLogUseCase -import domain.use_case.log.CreateTaskLogUseCase -import domain.use_case.log.GetAllProjectLogsUseCase -import domain.use_case.log.GetAllTaskLogsUseCase -import domain.use_case.project.* -import domain.use_case.state.CreateStateUseCase -import domain.use_case.state.DeleteStateUseCase -import domain.use_case.state.EditStateUseCase -import domain.use_case.task.* +import domain.useCase.authentication.* +import domain.useCase.log.CreateProjectLogUseCase +import domain.useCase.log.CreateTaskLogUseCase +import domain.useCase.log.GetAllProjectLogsUseCase +import domain.useCase.log.GetAllTaskLogsUseCase +import domain.useCase.project.* +import domain.useCase.state.CreateStateUseCase +import domain.useCase.state.DeleteStateUseCase +import domain.useCase.state.EditStateUseCase +import domain.useCase.task.* import ui.common.exception.handler.ExceptionHandler -import org.example.domain.use_cases.authentication.encryption.EncryptPassword -import org.example.domain.use_cases.authentication.encryption.Encryptor -import org.example.domain.use_cases.authentication.encryption.EncryptorMD5Impl +import domain.useCase.authentication.encryption.EncryptPassword +import domain.useCase.authentication.encryption.Encryptor +import domain.useCase.authentication.encryption.EncryptorMD5Impl import org.koin.core.module.dsl.singleOf import org.koin.dsl.module diff --git a/src/main/kotlin/di/UiModule.kt b/src/main/kotlin/di/UiModule.kt index b61acc06..13a32aff 100644 --- a/src/main/kotlin/di/UiModule.kt +++ b/src/main/kotlin/di/UiModule.kt @@ -1,7 +1,7 @@ package di -import domain.use_case.project.GetAllProjectsUseCase -import domain.use_case.project.GetProjectByIdUseCase +import domain.useCase.project.GetAllProjectsUseCase +import domain.useCase.project.GetProjectByIdUseCase import org.koin.core.module.dsl.singleOf import org.koin.dsl.module import ui.common.Colors diff --git a/src/main/kotlin/domain/model/Project.kt b/src/main/kotlin/domain/model/Project.kt index f867d91f..fadb03d8 100644 --- a/src/main/kotlin/domain/model/Project.kt +++ b/src/main/kotlin/domain/model/Project.kt @@ -11,4 +11,5 @@ data class Project( val createdAt: LocalDateTime = LocalDateTime.now(), val updatedAt: LocalDateTime = LocalDateTime.now(), val users: List, - val states: List) + val taskStates: List +) diff --git a/src/main/kotlin/domain/model/Task.kt b/src/main/kotlin/domain/model/Task.kt index c8f881c8..2a5ad03d 100644 --- a/src/main/kotlin/domain/model/Task.kt +++ b/src/main/kotlin/domain/model/Task.kt @@ -4,11 +4,11 @@ import java.time.LocalDateTime import java.util.UUID data class Task( - val id: UUID, + val id: UUID = UUID.randomUUID(), val projectId: UUID, val title: String, val description: String, - val state: State, + val taskState: TaskState, val creatorUserID: UUID, val createdAt: LocalDateTime = LocalDateTime.now(), val updatedAt: LocalDateTime = LocalDateTime.now() diff --git a/src/main/kotlin/domain/model/State.kt b/src/main/kotlin/domain/model/TaskState.kt similarity index 79% rename from src/main/kotlin/domain/model/State.kt rename to src/main/kotlin/domain/model/TaskState.kt index 67ddaffd..66f8c425 100644 --- a/src/main/kotlin/domain/model/State.kt +++ b/src/main/kotlin/domain/model/TaskState.kt @@ -2,7 +2,7 @@ package domain.model import java.util.UUID -data class State( +data class TaskState( val id: UUID, var name: String ) diff --git a/src/main/kotlin/domain/model/User.kt b/src/main/kotlin/domain/model/User.kt index 026c30a1..9c604b74 100644 --- a/src/main/kotlin/domain/model/User.kt +++ b/src/main/kotlin/domain/model/User.kt @@ -7,11 +7,11 @@ data class User( val name: String, val password: String, val email: String, - val role: Role, + val userRole: UserRole, val isDeleted: Boolean = false ) -enum class Role { +enum class UserRole { ADMIN, MATE } diff --git a/src/main/kotlin/domain/repository/AuthenticationRepository.kt b/src/main/kotlin/domain/repository/AuthenticationRepository.kt index f01dfd5b..dce32428 100644 --- a/src/main/kotlin/domain/repository/AuthenticationRepository.kt +++ b/src/main/kotlin/domain/repository/AuthenticationRepository.kt @@ -10,6 +10,6 @@ interface AuthenticationRepository { suspend fun registerAdmin(name: String, password: String, email: String): User suspend fun logout() suspend fun isFirstRegister(): Boolean - suspend fun getCurrentLoggedInUser(): User + suspend fun getCurrentUser(): User suspend fun getUsers(): List } \ No newline at end of file diff --git a/src/main/kotlin/domain/repository/ProjectRepository.kt b/src/main/kotlin/domain/repository/ProjectRepository.kt index 0993c0cc..f35e27db 100644 --- a/src/main/kotlin/domain/repository/ProjectRepository.kt +++ b/src/main/kotlin/domain/repository/ProjectRepository.kt @@ -1,7 +1,7 @@ package domain.repository import domain.model.Project -import domain.model.State +import domain.model.TaskState import domain.model.User import java.util.UUID @@ -11,9 +11,9 @@ interface ProjectRepository { suspend fun deleteProject(id: UUID) suspend fun getAllProjects() : List suspend fun getProject(id:UUID) : Project - suspend fun addStateToProject(projectId: UUID, state: State): Project - suspend fun editStateToProject(projectId: UUID, state: State): Project - suspend fun removeStateFromProject(projectId: UUID, state: State): Project + suspend fun addStateToProject(projectId: UUID, taskState: TaskState): Project + suspend fun editStateToProject(projectId: UUID, taskState: TaskState): Project + suspend fun deleteStateFromProject(projectId: UUID, taskState: TaskState): Project suspend fun addMateToProject(projectId: UUID, user: User): Project - suspend fun getProjectsForUserById(userid : UUID): List + suspend fun getUserProjectsById(userid : UUID): List } \ No newline at end of file diff --git a/src/main/kotlin/domain/repository/TaskRepository.kt b/src/main/kotlin/domain/repository/TaskRepository.kt index d6838f02..2669e1d5 100644 --- a/src/main/kotlin/domain/repository/TaskRepository.kt +++ b/src/main/kotlin/domain/repository/TaskRepository.kt @@ -10,5 +10,5 @@ interface TaskRepository { suspend fun getAllTasks(): List suspend fun getTask(id: UUID): Task suspend fun getTaskByStateIdAndProjectId(projectId: UUID, stateId: UUID): List - suspend fun getAllTasksForProject(projectId: UUID): List + suspend fun getAllProjectTasks(projectId: UUID): List } \ No newline at end of file diff --git a/src/main/kotlin/domain/use_case/authentication/GetAllUsersUseCase.kt b/src/main/kotlin/domain/useCase/authentication/GetAllUsersUseCase.kt similarity index 87% rename from src/main/kotlin/domain/use_case/authentication/GetAllUsersUseCase.kt rename to src/main/kotlin/domain/useCase/authentication/GetAllUsersUseCase.kt index 47e5f120..44f2ec7f 100644 --- a/src/main/kotlin/domain/use_case/authentication/GetAllUsersUseCase.kt +++ b/src/main/kotlin/domain/useCase/authentication/GetAllUsersUseCase.kt @@ -1,4 +1,4 @@ -package domain.use_case.authentication +package domain.useCase.authentication import domain.model.User import domain.repository.AuthenticationRepository diff --git a/src/main/kotlin/domain/use_case/authentication/GetCurrentUserUseCase.kt b/src/main/kotlin/domain/useCase/authentication/GetCurrentUserUseCase.kt similarity index 68% rename from src/main/kotlin/domain/use_case/authentication/GetCurrentUserUseCase.kt rename to src/main/kotlin/domain/useCase/authentication/GetCurrentUserUseCase.kt index 04f2c712..da50ba34 100644 --- a/src/main/kotlin/domain/use_case/authentication/GetCurrentUserUseCase.kt +++ b/src/main/kotlin/domain/useCase/authentication/GetCurrentUserUseCase.kt @@ -1,4 +1,4 @@ -package domain.use_case.authentication +package domain.useCase.authentication import domain.model.User import domain.repository.AuthenticationRepository @@ -6,8 +6,7 @@ import domain.repository.AuthenticationRepository class GetCurrentUserUseCase( private val authenticationRepository: AuthenticationRepository, ) { - suspend fun getCurrentUser(): User { - return authenticationRepository.getCurrentLoggedInUser() + return authenticationRepository.getCurrentUser() } } \ No newline at end of file diff --git a/src/main/kotlin/domain/use_case/authentication/GetUserByIdUseCase.kt b/src/main/kotlin/domain/useCase/authentication/GetUserByIdUseCase.kt similarity index 91% rename from src/main/kotlin/domain/use_case/authentication/GetUserByIdUseCase.kt rename to src/main/kotlin/domain/useCase/authentication/GetUserByIdUseCase.kt index 740aac64..9896e91c 100644 --- a/src/main/kotlin/domain/use_case/authentication/GetUserByIdUseCase.kt +++ b/src/main/kotlin/domain/useCase/authentication/GetUserByIdUseCase.kt @@ -1,4 +1,4 @@ -package domain.use_case.authentication +package domain.useCase.authentication import domain.model.User import ui.common.exception.UserNotFoundException diff --git a/src/main/kotlin/domain/use_case/authentication/LoginUseCase.kt b/src/main/kotlin/domain/useCase/authentication/LoginUseCase.kt similarity index 82% rename from src/main/kotlin/domain/use_case/authentication/LoginUseCase.kt rename to src/main/kotlin/domain/useCase/authentication/LoginUseCase.kt index 4b70703e..83c33457 100644 --- a/src/main/kotlin/domain/use_case/authentication/LoginUseCase.kt +++ b/src/main/kotlin/domain/useCase/authentication/LoginUseCase.kt @@ -1,8 +1,8 @@ -package domain.use_case.authentication +package domain.useCase.authentication import domain.model.User import domain.repository.AuthenticationRepository -import org.example.domain.use_cases.authentication.encryption.EncryptPassword +import domain.useCase.authentication.encryption.EncryptPassword class LoginUseCase( private val authenticationRepository: AuthenticationRepository, diff --git a/src/main/kotlin/domain/use_case/authentication/RegisterUserUseCase.kt b/src/main/kotlin/domain/useCase/authentication/RegisterUserUseCase.kt similarity index 87% rename from src/main/kotlin/domain/use_case/authentication/RegisterUserUseCase.kt rename to src/main/kotlin/domain/useCase/authentication/RegisterUserUseCase.kt index 0dddb3d8..98aa948e 100644 --- a/src/main/kotlin/domain/use_case/authentication/RegisterUserUseCase.kt +++ b/src/main/kotlin/domain/useCase/authentication/RegisterUserUseCase.kt @@ -1,7 +1,7 @@ -package domain.use_case.authentication +package domain.useCase.authentication import domain.repository.AuthenticationRepository -import org.example.domain.use_cases.authentication.encryption.EncryptPassword +import domain.useCase.authentication.encryption.EncryptPassword class RegisterUserUseCase( private val authenticationRepository: AuthenticationRepository, diff --git a/src/main/kotlin/domain/use_case/authentication/encryption/EncryptPassword.kt b/src/main/kotlin/domain/useCase/authentication/encryption/EncryptPassword.kt similarity index 74% rename from src/main/kotlin/domain/use_case/authentication/encryption/EncryptPassword.kt rename to src/main/kotlin/domain/useCase/authentication/encryption/EncryptPassword.kt index a7320b5c..1eff296c 100644 --- a/src/main/kotlin/domain/use_case/authentication/encryption/EncryptPassword.kt +++ b/src/main/kotlin/domain/useCase/authentication/encryption/EncryptPassword.kt @@ -1,4 +1,4 @@ -package org.example.domain.use_cases.authentication.encryption +package domain.useCase.authentication.encryption class EncryptPassword( private val encryptor: Encryptor diff --git a/src/main/kotlin/domain/use_case/authentication/encryption/Encryptor.kt b/src/main/kotlin/domain/useCase/authentication/encryption/Encryptor.kt similarity index 56% rename from src/main/kotlin/domain/use_case/authentication/encryption/Encryptor.kt rename to src/main/kotlin/domain/useCase/authentication/encryption/Encryptor.kt index 2add75c8..ae2255da 100644 --- a/src/main/kotlin/domain/use_case/authentication/encryption/Encryptor.kt +++ b/src/main/kotlin/domain/useCase/authentication/encryption/Encryptor.kt @@ -1,4 +1,4 @@ -package org.example.domain.use_cases.authentication.encryption +package domain.useCase.authentication.encryption interface Encryptor { suspend fun encodePassword(password: String): String diff --git a/src/main/kotlin/domain/use_case/authentication/encryption/EncryptorMD5Impl.kt b/src/main/kotlin/domain/useCase/authentication/encryption/EncryptorMD5Impl.kt similarity index 80% rename from src/main/kotlin/domain/use_case/authentication/encryption/EncryptorMD5Impl.kt rename to src/main/kotlin/domain/useCase/authentication/encryption/EncryptorMD5Impl.kt index ede8d224..ca3346aa 100644 --- a/src/main/kotlin/domain/use_case/authentication/encryption/EncryptorMD5Impl.kt +++ b/src/main/kotlin/domain/useCase/authentication/encryption/EncryptorMD5Impl.kt @@ -1,11 +1,10 @@ -package org.example.domain.use_cases.authentication.encryption +package domain.useCase.authentication.encryption import java.security.MessageDigest class EncryptorMD5Impl : Encryptor { - override suspend fun encodePassword(password: String): String { - return makeMD5Hash(password) - } + override suspend fun encodePassword(password: String): String = makeMD5Hash(password) + private fun makeMD5Hash(password: String): String { val md = MessageDigest.getInstance(MD5_ALGORITHM_NAME) diff --git a/src/main/kotlin/domain/use_case/log/CreateProjectLogUseCase.kt b/src/main/kotlin/domain/useCase/log/CreateProjectLogUseCase.kt similarity index 97% rename from src/main/kotlin/domain/use_case/log/CreateProjectLogUseCase.kt rename to src/main/kotlin/domain/useCase/log/CreateProjectLogUseCase.kt index 301e4ee1..d048d6e5 100644 --- a/src/main/kotlin/domain/use_case/log/CreateProjectLogUseCase.kt +++ b/src/main/kotlin/domain/useCase/log/CreateProjectLogUseCase.kt @@ -1,4 +1,4 @@ -package domain.use_case.log +package domain.useCase.log import domain.model.Project import domain.model.ProjectLog diff --git a/src/main/kotlin/domain/use_case/log/CreateTaskLogUseCase.kt b/src/main/kotlin/domain/useCase/log/CreateTaskLogUseCase.kt similarity index 96% rename from src/main/kotlin/domain/use_case/log/CreateTaskLogUseCase.kt rename to src/main/kotlin/domain/useCase/log/CreateTaskLogUseCase.kt index c7d128a3..88cc180b 100644 --- a/src/main/kotlin/domain/use_case/log/CreateTaskLogUseCase.kt +++ b/src/main/kotlin/domain/useCase/log/CreateTaskLogUseCase.kt @@ -1,4 +1,4 @@ -package domain.use_case.log +package domain.useCase.log import domain.model.Task import domain.model.TaskLog diff --git a/src/main/kotlin/domain/use_case/log/GetAllProjectLogsUseCase.kt b/src/main/kotlin/domain/useCase/log/GetAllProjectLogsUseCase.kt similarity index 90% rename from src/main/kotlin/domain/use_case/log/GetAllProjectLogsUseCase.kt rename to src/main/kotlin/domain/useCase/log/GetAllProjectLogsUseCase.kt index 7dc3569c..0118b5c5 100644 --- a/src/main/kotlin/domain/use_case/log/GetAllProjectLogsUseCase.kt +++ b/src/main/kotlin/domain/useCase/log/GetAllProjectLogsUseCase.kt @@ -1,4 +1,4 @@ -package domain.use_case.log +package domain.useCase.log import domain.model.ProjectLog import domain.repository.LogRepository diff --git a/src/main/kotlin/domain/use_case/log/GetAllTaskLogsUseCase.kt b/src/main/kotlin/domain/useCase/log/GetAllTaskLogsUseCase.kt similarity index 89% rename from src/main/kotlin/domain/use_case/log/GetAllTaskLogsUseCase.kt rename to src/main/kotlin/domain/useCase/log/GetAllTaskLogsUseCase.kt index 9cc79f45..87ddbae9 100644 --- a/src/main/kotlin/domain/use_case/log/GetAllTaskLogsUseCase.kt +++ b/src/main/kotlin/domain/useCase/log/GetAllTaskLogsUseCase.kt @@ -1,4 +1,4 @@ -package domain.use_case.log +package domain.useCase.log import domain.model.TaskLog import domain.repository.LogRepository diff --git a/src/main/kotlin/domain/use_case/project/AddProjectMateUseCase.kt b/src/main/kotlin/domain/useCase/project/AddProjectMateUseCase.kt similarity index 85% rename from src/main/kotlin/domain/use_case/project/AddProjectMateUseCase.kt rename to src/main/kotlin/domain/useCase/project/AddProjectMateUseCase.kt index 61b5c31e..c3bd80e6 100644 --- a/src/main/kotlin/domain/use_case/project/AddProjectMateUseCase.kt +++ b/src/main/kotlin/domain/useCase/project/AddProjectMateUseCase.kt @@ -1,8 +1,8 @@ -package domain.use_case.project +package domain.useCase.project import domain.model.User -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.log.CreateProjectLogUseCase import domain.repository.ProjectRepository import java.util.* diff --git a/src/main/kotlin/domain/use_case/project/AddProjectStateUseCase.kt b/src/main/kotlin/domain/useCase/project/AddProjectStateUseCase.kt similarity index 67% rename from src/main/kotlin/domain/use_case/project/AddProjectStateUseCase.kt rename to src/main/kotlin/domain/useCase/project/AddProjectStateUseCase.kt index abf3c075..899f91b5 100644 --- a/src/main/kotlin/domain/use_case/project/AddProjectStateUseCase.kt +++ b/src/main/kotlin/domain/useCase/project/AddProjectStateUseCase.kt @@ -1,9 +1,9 @@ -package domain.use_case.project +package domain.useCase.project import ui.common.exception.EmptyStateNameException -import domain.model.State +import domain.model.TaskState import domain.model.Project -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.log.CreateProjectLogUseCase import domain.repository.ProjectRepository import java.util.* @@ -11,11 +11,11 @@ class AddProjectStateUseCase( private val repository: ProjectRepository, private val logUseCase: CreateProjectLogUseCase ) { - suspend fun addStateToProject(currentUserID: UUID, project: Project, state: State): Project { - if (state.name.isBlank()) { + suspend fun addStateToProject(currentUserID: UUID, project: Project, taskState: TaskState): Project { + if (taskState.name.isBlank()) { throw EmptyStateNameException() } - return repository.addStateToProject(project.id, state).also { updatedProject -> + return repository.addStateToProject(project.id, taskState).also { updatedProject -> logUseCase.createProjectLog( userId = currentUserID, previousProject = project, diff --git a/src/main/kotlin/domain/use_case/project/CreateProjectUseCase.kt b/src/main/kotlin/domain/useCase/project/CreateProjectUseCase.kt similarity index 84% rename from src/main/kotlin/domain/use_case/project/CreateProjectUseCase.kt rename to src/main/kotlin/domain/useCase/project/CreateProjectUseCase.kt index 87db557c..cd9295b8 100644 --- a/src/main/kotlin/domain/use_case/project/CreateProjectUseCase.kt +++ b/src/main/kotlin/domain/useCase/project/CreateProjectUseCase.kt @@ -1,9 +1,9 @@ -package domain.use_case.project +package domain.useCase.project import domain.model.Project -import domain.model.State -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.log.CreateProjectLogUseCase +import domain.model.TaskState +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.log.CreateProjectLogUseCase import ui.common.exception.EmptyProjectDescriptionException import ui.common.exception.EmptyProjectTitleException import domain.repository.ProjectRepository @@ -32,7 +32,7 @@ class CreateProjectUseCase( id = UUID.randomUUID(), title = name, description = description, - states = stateNames.map { State(id = UUID.randomUUID(), name = it) }, + taskStates = stateNames.map { TaskState(id = UUID.randomUUID(), name = it) }, creatorUserID = creatorUserID, createdAt = LocalDateTime.now(), updatedAt = LocalDateTime.now(), diff --git a/src/main/kotlin/domain/use_case/project/DeleteProjectStateUseCase.kt b/src/main/kotlin/domain/useCase/project/DeleteProjectStateUseCase.kt similarity index 64% rename from src/main/kotlin/domain/use_case/project/DeleteProjectStateUseCase.kt rename to src/main/kotlin/domain/useCase/project/DeleteProjectStateUseCase.kt index 676c25df..c9bce796 100644 --- a/src/main/kotlin/domain/use_case/project/DeleteProjectStateUseCase.kt +++ b/src/main/kotlin/domain/useCase/project/DeleteProjectStateUseCase.kt @@ -1,9 +1,9 @@ -package domain.use_case.project +package domain.useCase.project import ui.common.exception.EmptyStateNameException import domain.model.Project -import domain.model.State -import domain.use_case.log.CreateProjectLogUseCase +import domain.model.TaskState +import domain.useCase.log.CreateProjectLogUseCase import domain.repository.ProjectRepository import java.util.* @@ -12,11 +12,11 @@ class DeleteProjectStateUseCase( private val logUseCase: CreateProjectLogUseCase ) { - suspend fun removeStateFromProject(currentUserID: UUID, project: Project, state: State): Project { - if (state.name.isBlank()) { + suspend fun removeStateFromProject(currentUserID: UUID, project: Project, taskState: TaskState): Project { + if (taskState.name.isBlank()) { throw EmptyStateNameException() } - return repository.removeStateFromProject(project.id, state).also { updatedProject -> + return repository.deleteStateFromProject(project.id, taskState).also { updatedProject -> logUseCase.createProjectLog(userId = currentUserID, previousProject = project, currentProject = updatedProject) } } diff --git a/src/main/kotlin/domain/use_case/project/DeleteProjectUseCase.kt b/src/main/kotlin/domain/useCase/project/DeleteProjectUseCase.kt similarity index 83% rename from src/main/kotlin/domain/use_case/project/DeleteProjectUseCase.kt rename to src/main/kotlin/domain/useCase/project/DeleteProjectUseCase.kt index 936c77d8..0f05cec5 100644 --- a/src/main/kotlin/domain/use_case/project/DeleteProjectUseCase.kt +++ b/src/main/kotlin/domain/useCase/project/DeleteProjectUseCase.kt @@ -1,7 +1,7 @@ -package domain.use_case.project +package domain.useCase.project import domain.model.Project -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.log.CreateProjectLogUseCase import domain.repository.ProjectRepository import java.util.* diff --git a/src/main/kotlin/domain/use_case/project/EditProjectDescriptionUseCase.kt b/src/main/kotlin/domain/useCase/project/EditProjectDescriptionUseCase.kt similarity index 92% rename from src/main/kotlin/domain/use_case/project/EditProjectDescriptionUseCase.kt rename to src/main/kotlin/domain/useCase/project/EditProjectDescriptionUseCase.kt index ef2bd992..85ebd601 100644 --- a/src/main/kotlin/domain/use_case/project/EditProjectDescriptionUseCase.kt +++ b/src/main/kotlin/domain/useCase/project/EditProjectDescriptionUseCase.kt @@ -1,8 +1,8 @@ -package domain.use_case.project +package domain.useCase.project import ui.common.exception.DuplicateDescriptionException import domain.model.Project -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.log.CreateProjectLogUseCase import ui.common.exception.EmptyProjectDescriptionException import domain.repository.ProjectRepository import java.time.LocalDateTime diff --git a/src/main/kotlin/domain/use_case/project/EditProjectStateUseCase.kt b/src/main/kotlin/domain/useCase/project/EditProjectStateUseCase.kt similarity index 65% rename from src/main/kotlin/domain/use_case/project/EditProjectStateUseCase.kt rename to src/main/kotlin/domain/useCase/project/EditProjectStateUseCase.kt index 8eb92eed..77b6096a 100644 --- a/src/main/kotlin/domain/use_case/project/EditProjectStateUseCase.kt +++ b/src/main/kotlin/domain/useCase/project/EditProjectStateUseCase.kt @@ -1,21 +1,21 @@ -package domain.use_case.project +package domain.useCase.project import ui.common.exception.EmptyStateNameException import domain.model.Project -import domain.model.State +import domain.model.TaskState import domain.repository.ProjectRepository -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.log.CreateProjectLogUseCase import java.util.* class EditProjectStateUseCase( private val repository: ProjectRepository, private val logUseCase: CreateProjectLogUseCase ) { - suspend fun editStateToProject(currentUserID: UUID, project: Project, state: State): Project { - if (state.name.isBlank()) { + suspend fun editStateToProject(currentUserID: UUID, project: Project, taskState: TaskState): Project { + if (taskState.name.isBlank()) { throw EmptyStateNameException() } - return repository.editStateToProject(project.id, state).also { updatedProject -> + return repository.editStateToProject(project.id, taskState).also { updatedProject -> logUseCase.createProjectLog(userId = currentUserID, previousProject = project, currentProject = updatedProject) } } diff --git a/src/main/kotlin/domain/use_case/project/EditProjectTitleUseCase.kt b/src/main/kotlin/domain/useCase/project/EditProjectTitleUseCase.kt similarity index 92% rename from src/main/kotlin/domain/use_case/project/EditProjectTitleUseCase.kt rename to src/main/kotlin/domain/useCase/project/EditProjectTitleUseCase.kt index 64c0b034..43852461 100644 --- a/src/main/kotlin/domain/use_case/project/EditProjectTitleUseCase.kt +++ b/src/main/kotlin/domain/useCase/project/EditProjectTitleUseCase.kt @@ -1,8 +1,8 @@ -package domain.use_case.project +package domain.useCase.project import ui.common.exception.DuplicateTitleException import domain.model.Project -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.log.CreateProjectLogUseCase import ui.common.exception.EmptyProjectTitleException import domain.repository.ProjectRepository import java.time.LocalDateTime diff --git a/src/main/kotlin/domain/use_case/project/GetAllProjectsUseCase.kt b/src/main/kotlin/domain/useCase/project/GetAllProjectsUseCase.kt similarity index 89% rename from src/main/kotlin/domain/use_case/project/GetAllProjectsUseCase.kt rename to src/main/kotlin/domain/useCase/project/GetAllProjectsUseCase.kt index 4f43e306..7333df6f 100644 --- a/src/main/kotlin/domain/use_case/project/GetAllProjectsUseCase.kt +++ b/src/main/kotlin/domain/useCase/project/GetAllProjectsUseCase.kt @@ -1,4 +1,4 @@ -package domain.use_case.project +package domain.useCase.project import domain.model.Project import domain.repository.ProjectRepository diff --git a/src/main/kotlin/domain/use_case/project/GetProjectByIdUseCase.kt b/src/main/kotlin/domain/useCase/project/GetProjectByIdUseCase.kt similarity index 89% rename from src/main/kotlin/domain/use_case/project/GetProjectByIdUseCase.kt rename to src/main/kotlin/domain/useCase/project/GetProjectByIdUseCase.kt index 2a58905f..59457014 100644 --- a/src/main/kotlin/domain/use_case/project/GetProjectByIdUseCase.kt +++ b/src/main/kotlin/domain/useCase/project/GetProjectByIdUseCase.kt @@ -1,4 +1,4 @@ -package domain.use_case.project +package domain.useCase.project import domain.model.Project import domain.repository.ProjectRepository diff --git a/src/main/kotlin/domain/use_case/project/GetUserProjectsByIdUseCase.kt b/src/main/kotlin/domain/useCase/project/GetUserProjectsByIdUseCase.kt similarity index 73% rename from src/main/kotlin/domain/use_case/project/GetUserProjectsByIdUseCase.kt rename to src/main/kotlin/domain/useCase/project/GetUserProjectsByIdUseCase.kt index 64ee26be..8fa68be1 100644 --- a/src/main/kotlin/domain/use_case/project/GetUserProjectsByIdUseCase.kt +++ b/src/main/kotlin/domain/useCase/project/GetUserProjectsByIdUseCase.kt @@ -1,4 +1,4 @@ -package domain.use_case.project +package domain.useCase.project import domain.model.Project import domain.repository.ProjectRepository @@ -6,6 +6,6 @@ import java.util.* class GetUserProjectsByIdUseCase(private val repository: ProjectRepository) { suspend fun getProjectForUserById(userID: UUID): List { - return repository.getProjectsForUserById(userID) + return repository.getUserProjectsById(userID) } } \ No newline at end of file diff --git a/src/main/kotlin/domain/use_case/state/CreateStateUseCase.kt b/src/main/kotlin/domain/useCase/state/CreateStateUseCase.kt similarity index 52% rename from src/main/kotlin/domain/use_case/state/CreateStateUseCase.kt rename to src/main/kotlin/domain/useCase/state/CreateStateUseCase.kt index a4a69b8f..1ae142ab 100644 --- a/src/main/kotlin/domain/use_case/state/CreateStateUseCase.kt +++ b/src/main/kotlin/domain/useCase/state/CreateStateUseCase.kt @@ -1,21 +1,21 @@ -package domain.use_case.state +package domain.useCase.state import ui.common.exception.EmptyStateNameException import domain.model.Project -import domain.model.State -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.AddProjectStateUseCase +import domain.model.TaskState +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.AddProjectStateUseCase import java.util.* class CreateStateUseCase( private val addProjectStateUseCase: AddProjectStateUseCase, private val getCurrentUserUseCase: GetCurrentUserUseCase ) { - suspend fun createState(name: String, project: Project): State { + suspend fun createState(name: String, project: Project): TaskState { if (name.isBlank()) throw EmptyStateNameException() - val newState = State(id = UUID.randomUUID(), name = name) + val newTaskState = TaskState(id = UUID.randomUUID(), name = name) val currentUserId = getCurrentUserUseCase.getCurrentUser().id - addProjectStateUseCase.addStateToProject(currentUserID = currentUserId, project = project, state = newState) - return newState + addProjectStateUseCase.addStateToProject(currentUserID = currentUserId, project = project, taskState = newTaskState) + return newTaskState } } \ No newline at end of file diff --git a/src/main/kotlin/domain/use_case/state/DeleteStateUseCase.kt b/src/main/kotlin/domain/useCase/state/DeleteStateUseCase.kt similarity index 58% rename from src/main/kotlin/domain/use_case/state/DeleteStateUseCase.kt rename to src/main/kotlin/domain/useCase/state/DeleteStateUseCase.kt index 8ffceb1e..de538f07 100644 --- a/src/main/kotlin/domain/use_case/state/DeleteStateUseCase.kt +++ b/src/main/kotlin/domain/useCase/state/DeleteStateUseCase.kt @@ -1,18 +1,18 @@ -package domain.use_case.state +package domain.useCase.state import domain.model.Project -import domain.model.State -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.DeleteProjectStateUseCase +import domain.model.TaskState +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.DeleteProjectStateUseCase class DeleteStateUseCase( private val deleteProjectStateUseCase: DeleteProjectStateUseCase, private val getCurrentUserUseCase: GetCurrentUserUseCase ) { - suspend fun deleteState(project: Project, state: State): Project { + suspend fun deleteState(project: Project, taskState: TaskState): Project { val currentUserId = getCurrentUserUseCase.getCurrentUser().id return deleteProjectStateUseCase - .removeStateFromProject(currentUserId, project, state) + .removeStateFromProject(currentUserId, project, taskState) } } \ No newline at end of file diff --git a/src/main/kotlin/domain/useCase/state/EditStateUseCase.kt b/src/main/kotlin/domain/useCase/state/EditStateUseCase.kt new file mode 100644 index 00000000..40afcaf9 --- /dev/null +++ b/src/main/kotlin/domain/useCase/state/EditStateUseCase.kt @@ -0,0 +1,28 @@ +package domain.useCase.state + +import ui.common.exception.EmptyStateNameException +import domain.model.Project +import domain.model.TaskState +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.EditProjectStateUseCase + +class EditStateUseCase( + private val editProjectStateUseCase: EditProjectStateUseCase, + private val getCurrentUserUseCase: GetCurrentUserUseCase +) { + suspend fun editState(taskStateToEdit: TaskState, newName: String, project: Project): Project { + if (newName.isEmpty()) throw EmptyStateNameException() + + val currentUserId = getCurrentUserUseCase.getCurrentUser().id + + val updatedState = taskStateToEdit.copy(name = newName) + + val updatedStates = project.taskStates.map { state -> + if (state.id == taskStateToEdit.id) updatedState else state + } + + editProjectStateUseCase.editStateToProject(currentUserId, project, updatedState) + + return project.copy(taskStates = updatedStates) + } +} \ No newline at end of file diff --git a/src/main/kotlin/domain/use_case/task/CreateTaskUseCase.kt b/src/main/kotlin/domain/useCase/task/CreateTaskUseCase.kt similarity index 57% rename from src/main/kotlin/domain/use_case/task/CreateTaskUseCase.kt rename to src/main/kotlin/domain/useCase/task/CreateTaskUseCase.kt index 1540be31..4f342188 100644 --- a/src/main/kotlin/domain/use_case/task/CreateTaskUseCase.kt +++ b/src/main/kotlin/domain/useCase/task/CreateTaskUseCase.kt @@ -1,21 +1,26 @@ -package domain.use_case.task +package domain.useCase.task -import domain.model.State +import domain.model.TaskState import domain.model.Task -import domain.use_case.log.CreateTaskLogUseCase +import domain.useCase.log.CreateTaskLogUseCase import ui.common.exception.EmptyTaskDescriptionException import ui.common.exception.EmptyTaskTitleException import domain.repository.TaskRepository -import java.time.LocalDateTime import java.util.* class CreateTaskUseCase( private val taskRepository: TaskRepository, private val createTaskLogUseCase: CreateTaskLogUseCase, ) { - suspend fun createTask(title: String, description: String, state: State, projectId : UUID, creatorUserID : UUID) { + suspend fun createTask(title: String, description: String, taskState: TaskState, projectId : UUID, creatorUserID : UUID) { validateFields(title, description) - val task = buildTask(title, description, state,projectId,creatorUserID) + val task = Task( + projectId = projectId, + title = title, + description = description, + taskState = taskState, + creatorUserID = creatorUserID + ) saveTaskAndLog(task) } @@ -26,19 +31,6 @@ class CreateTaskUseCase( } } - private fun buildTask(title: String, description: String, state: State, projectId : UUID, creatorUserID : UUID): Task { - return Task( - id = UUID.randomUUID(), - projectId = projectId, - title = title, - description = description, - state = state, - creatorUserID = creatorUserID, - createdAt = LocalDateTime.now(), - updatedAt = LocalDateTime.now() - - ) - } private suspend fun saveTaskAndLog(task: Task) { taskRepository.createTask(task) createTaskLogUseCase.createTaskLog(task.creatorUserID, null, task) diff --git a/src/main/kotlin/domain/use_case/task/DeleteTaskUseCase.kt b/src/main/kotlin/domain/useCase/task/DeleteTaskUseCase.kt similarity index 83% rename from src/main/kotlin/domain/use_case/task/DeleteTaskUseCase.kt rename to src/main/kotlin/domain/useCase/task/DeleteTaskUseCase.kt index 022e212c..02499b37 100644 --- a/src/main/kotlin/domain/use_case/task/DeleteTaskUseCase.kt +++ b/src/main/kotlin/domain/useCase/task/DeleteTaskUseCase.kt @@ -1,7 +1,7 @@ -package domain.use_case.task +package domain.useCase.task import domain.model.Task -import domain.use_case.log.CreateTaskLogUseCase +import domain.useCase.log.CreateTaskLogUseCase import domain.repository.TaskRepository import java.util.* diff --git a/src/main/kotlin/domain/use_case/task/EditTaskUseCase.kt b/src/main/kotlin/domain/useCase/task/EditTaskUseCase.kt similarity index 63% rename from src/main/kotlin/domain/use_case/task/EditTaskUseCase.kt rename to src/main/kotlin/domain/useCase/task/EditTaskUseCase.kt index ed28d145..dc826da2 100644 --- a/src/main/kotlin/domain/use_case/task/EditTaskUseCase.kt +++ b/src/main/kotlin/domain/useCase/task/EditTaskUseCase.kt @@ -1,9 +1,9 @@ -package domain.use_case.task +package domain.useCase.task import ui.common.exception.EmptyFieldException import domain.model.Task -import domain.model.State -import domain.use_case.log.CreateTaskLogUseCase +import domain.model.TaskState +import domain.useCase.log.CreateTaskLogUseCase import domain.repository.TaskRepository import java.time.LocalDateTime @@ -13,32 +13,28 @@ class EditTaskUseCase( private val taskRepository: TaskRepository, private val createTaskLogUseCase: CreateTaskLogUseCase, ) { - suspend fun editTask(task: Task, newTitle: String?, newDescription: String?, newState: State, editorUserId: UUID) { - validateInputFields(newTitle, newDescription,newState,task) + suspend fun editTask(task: Task, newTitle: String?, newDescription: String?, newTaskState: TaskState, editorUserId: UUID) { + validateInputFields(newTitle, newDescription,newTaskState,task) - val updatedTask = createUpdatedTask(task, newTitle, newDescription, newState) + val updatedTask = createUpdatedTask(task, newTitle, newDescription, newTaskState) - saveUpdatedTask(updatedTask) + taskRepository.editTask(updatedTask) createTaskLogUseCase.createTaskLog(editorUserId, task, updatedTask) } - private fun validateInputFields(newTitle: String?, newDescription: String?,newState: State,task : Task) { - if (newState == task.state && newTitle.isNullOrBlank() && newDescription.isNullOrBlank()){ + private fun validateInputFields(newTitle: String?, newDescription: String?, newTaskState: TaskState, task : Task) { + if (newTaskState == task.taskState && newTitle.isNullOrBlank() && newDescription.isNullOrBlank()){ throw EmptyFieldException() } } - private fun createUpdatedTask(task: Task, newTitle: String?, newDescription: String?, newState: State): Task { + private fun createUpdatedTask(task: Task, newTitle: String?, newDescription: String?, newTaskState: TaskState): Task { return task.copy( title = newTitle?.takeIf { it.isNotBlank() } ?: task.title, description = newDescription?.takeIf { it.isNotBlank() } ?: task.description, - state = newState, + taskState = newTaskState, updatedAt = LocalDateTime.now() ) } - - private suspend fun saveUpdatedTask(updatedTask: Task) { - taskRepository.editTask(updatedTask) - } } \ No newline at end of file diff --git a/src/main/kotlin/domain/use_case/task/GetProjectTasksUseCase.kt b/src/main/kotlin/domain/useCase/task/GetProjectTasksUseCase.kt similarity index 72% rename from src/main/kotlin/domain/use_case/task/GetProjectTasksUseCase.kt rename to src/main/kotlin/domain/useCase/task/GetProjectTasksUseCase.kt index 48eade9d..1621b58e 100644 --- a/src/main/kotlin/domain/use_case/task/GetProjectTasksUseCase.kt +++ b/src/main/kotlin/domain/useCase/task/GetProjectTasksUseCase.kt @@ -1,4 +1,4 @@ -package domain.use_case.task +package domain.useCase.task import domain.model.Task import domain.repository.TaskRepository @@ -8,7 +8,7 @@ class GetProjectTasksUseCase( private val taskRepository: TaskRepository, ) { suspend fun getProjectTasks(projectId: UUID): List { - return taskRepository.getAllTasksForProject(projectId) + return taskRepository.getAllProjectTasks(projectId) } } \ No newline at end of file diff --git a/src/main/kotlin/domain/use_case/task/GetTaskByStateIdAndProjectId.kt b/src/main/kotlin/domain/useCase/task/GetTaskByStateIdAndProjectId.kt similarity index 92% rename from src/main/kotlin/domain/use_case/task/GetTaskByStateIdAndProjectId.kt rename to src/main/kotlin/domain/useCase/task/GetTaskByStateIdAndProjectId.kt index fb992d30..47a756b9 100644 --- a/src/main/kotlin/domain/use_case/task/GetTaskByStateIdAndProjectId.kt +++ b/src/main/kotlin/domain/useCase/task/GetTaskByStateIdAndProjectId.kt @@ -1,4 +1,4 @@ -package domain.use_case.task +package domain.useCase.task import domain.model.Task import domain.repository.TaskRepository diff --git a/src/main/kotlin/domain/use_case/state/EditStateUseCase.kt b/src/main/kotlin/domain/use_case/state/EditStateUseCase.kt deleted file mode 100644 index d6fea80d..00000000 --- a/src/main/kotlin/domain/use_case/state/EditStateUseCase.kt +++ /dev/null @@ -1,28 +0,0 @@ -package domain.use_case.state - -import ui.common.exception.EmptyStateNameException -import domain.model.Project -import domain.model.State -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.EditProjectStateUseCase - -class EditStateUseCase( - private val editProjectStateUseCase: EditProjectStateUseCase, - private val getCurrentUserUseCase: GetCurrentUserUseCase -) { - suspend fun editState(stateToEdit: State, newName: String, project: Project): Project { - if (newName.isEmpty()) throw EmptyStateNameException() - - val currentUserId = getCurrentUserUseCase.getCurrentUser().id - - val updatedState = stateToEdit.copy(name = newName) - - val updatedStates = project.states.map { state -> - if (state.id == stateToEdit.id) updatedState else state - } - - editProjectStateUseCase.editStateToProject(currentUserId, project, updatedState) - - return project.copy(states = updatedStates) - } -} \ No newline at end of file diff --git a/src/main/kotlin/ui/common/Colors.kt b/src/main/kotlin/ui/common/Colors.kt index 71d59558..b3855803 100644 --- a/src/main/kotlin/ui/common/Colors.kt +++ b/src/main/kotlin/ui/common/Colors.kt @@ -1,8 +1,14 @@ package ui.common class Colors { + fun red(text: String): String = "$RED$text$RESET" + fun green(text: String): String = "$GREEN$text$RESET" + fun yellow(text: String): String = "$YELLOW$text$RESET" + fun blue(text: String): String = "$BLUE$text$RESET" + fun purple(text: String): String = "$PURPLE$text$RESET" + fun cyan(text: String): String = "$CYAN$text$RESET" - companion object { + private companion object { const val RED = "\u001B[31m" const val GREEN = "\u001B[32m" const val YELLOW = "\u001B[33m" @@ -10,14 +16,6 @@ class Colors { const val PURPLE = "\u001B[35m" const val CYAN = "\u001B[36m" const val RESET = "\u001B[0m" - } - - fun red(text: String): String = "$RED$text$RESET" - fun green(text: String): String = "$GREEN$text$RESET" - fun yellow(text: String): String = "$YELLOW$text$RESET" - fun blue(text: String): String = "$BLUE$text$RESET" - fun purple(text: String): String = "$PURPLE$text$RESET" - fun cyan(text: String): String = "$CYAN$text$RESET" - +} } \ No newline at end of file diff --git a/src/main/kotlin/ui/common/UiScreen.kt b/src/main/kotlin/ui/common/UiScreen.kt index 4f6273fd..f97de3c9 100644 --- a/src/main/kotlin/ui/common/UiScreen.kt +++ b/src/main/kotlin/ui/common/UiScreen.kt @@ -1,6 +1,5 @@ package ui.common interface UiScreen { - suspend fun show() } \ No newline at end of file diff --git a/src/main/kotlin/ui/view/authentication/LoginUi.kt b/src/main/kotlin/ui/view/authentication/LoginUi.kt index 6a9029ff..efa1e3fc 100644 --- a/src/main/kotlin/ui/view/authentication/LoginUi.kt +++ b/src/main/kotlin/ui/view/authentication/LoginUi.kt @@ -3,9 +3,9 @@ package ui.view.authentication import ui.common.exception.EmptyFieldException import ui.common.exception.handler.ExceptionHandler import ui.common.exception.handler.SafeExecutor -import domain.model.Role +import domain.model.UserRole import domain.model.User -import domain.use_case.authentication.LoginUseCase +import domain.useCase.authentication.LoginUseCase import ui.view.user.mate.MateUi import ui.common.Printer import ui.common.Reader @@ -60,7 +60,7 @@ class LoginUi( } private suspend fun checkAdminOrMate(user: User) { - if (user.role == Role.ADMIN) { + if (user.userRole == UserRole.ADMIN) { goToAminHomeScreen() } else { goToMateHomeScreen() diff --git a/src/main/kotlin/ui/view/authentication/RegisterUi.kt b/src/main/kotlin/ui/view/authentication/RegisterUi.kt index 98dc1308..1b218045 100644 --- a/src/main/kotlin/ui/view/authentication/RegisterUi.kt +++ b/src/main/kotlin/ui/view/authentication/RegisterUi.kt @@ -2,7 +2,7 @@ package ui.view.authentication import ui.common.exception.EmptyFieldException import ui.common.exception.handler.SafeExecutor -import domain.use_case.authentication.RegisterUserUseCase +import domain.useCase.authentication.RegisterUserUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader diff --git a/src/main/kotlin/ui/view/project/ProjectMateUi.kt b/src/main/kotlin/ui/view/project/ProjectMateUi.kt index f4154fae..0fbd648c 100644 --- a/src/main/kotlin/ui/view/project/ProjectMateUi.kt +++ b/src/main/kotlin/ui/view/project/ProjectMateUi.kt @@ -2,7 +2,7 @@ package ui.view.project import ui.common.exception.handler.SafeExecutor import domain.model.Project -import domain.use_case.project.GetProjectByIdUseCase +import domain.useCase.project.GetProjectByIdUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader @@ -11,6 +11,7 @@ import ui.view.task.CreateTaskUi import ui.view.user.mate.UserProjectsUi import org.koin.core.component.KoinComponent import org.koin.core.component.inject +import ui.extensions.formatDateTime import java.util.* class ProjectMateUi( @@ -22,6 +23,8 @@ class ProjectMateUi( private val executor: SafeExecutor by inject() private val handler: ExceptionHandler by inject() + var running = true + override suspend fun show() { executor.tryToExecute( action = { @@ -37,19 +40,22 @@ class ProjectMateUi( } private suspend fun displayProjectOptions(project: Project) { - while (true) { + + while (running) { printer.printInfoLine( """ - Project Name : ${project.title} - Description : ${project.description} - - Created At : ${project.createdAt} + - Created At : ${project.createdAt.formatDateTime()} """.trimIndent() ) printer.printInfoLine("Choose an option :") printer.printOptions( - "View state for project", "View all task for project", "Create new task", "" + - "Enter Any Thing To Go Back" + "View state for project", + "View all task for project", + "Create new task", + "Go Back" ) val option = reader.readInt() @@ -67,15 +73,20 @@ class ProjectMateUi( } 3 -> { - if (project.states.isEmpty()) { + if (project.taskStates.isEmpty()) { printer.printError("Can't create a task because this project has no states.") UserProjectsUi().show() } else { CreateTaskUi(projectId).show() } } + + 4 -> { + running = false + } + else -> { - break + printer.printError("Invalid option") } } } diff --git a/src/main/kotlin/ui/view/project/ProjectStateSelectedUi.kt b/src/main/kotlin/ui/view/project/ProjectStateSelectedUi.kt index f715e3c8..cc9d7d0d 100644 --- a/src/main/kotlin/ui/view/project/ProjectStateSelectedUi.kt +++ b/src/main/kotlin/ui/view/project/ProjectStateSelectedUi.kt @@ -1,9 +1,9 @@ package ui.view.project import ui.common.exception.handler.SafeExecutor -import domain.model.State -import domain.use_case.project.GetProjectByIdUseCase -import domain.use_case.task.GetTaskByStateIdAndProjectId +import domain.model.TaskState +import domain.useCase.project.GetProjectByIdUseCase +import domain.useCase.task.GetTaskByStateIdAndProjectId import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.UiScreen @@ -34,43 +34,47 @@ class ProjectStateSelectedUi( } } - private suspend fun getProjectStates(): List { + private suspend fun getProjectStates(): List { printer.printTitle("State Details") - return getProjectByIdUseCase.getProjectById(projectId).states + return getProjectByIdUseCase.getProjectById(projectId).taskStates } - private fun displayStateOptions(states: List) { - states.forEachIndexed { index, state -> + private fun displayStateOptions(taskStates: List) { + taskStates.forEachIndexed { index, state -> printer.printInfoLine("${index + 1}. ${state.name}") } + printer.printOption("${taskStates.size + 1}. Go Back") } - private suspend fun handleUserSelection(states: List) { + private suspend fun handleUserSelection(taskStates: List) { val choice = printer.readIntInput( - "Enter the number of the state to view (Enter Any Thing To Go Back): " + "Enter the number of the state to view: " ) when { - choice != null && choice in 1..states.size -> { - val selectedState = states[choice - 1] + choice != null && choice in 1..taskStates.size -> { + val selectedState = taskStates[choice - 1] printStateDetails(selectedState) running = false } - else -> { - printer.printGoodbyeMessage("Goodbye") + choice == taskStates.size + 1 -> { running = false } + + else -> { + printer.printError("Invalid option") + } } } - private suspend fun printStateDetails(selectedState: State) { + private suspend fun printStateDetails(selectedTaskState: TaskState) { printer.printTitle("State Details") - printer.printInfoLine("Name: ${selectedState.name}") + printer.printInfoLine("Name: ${selectedTaskState.name}") executor.tryToExecute( action = { val tasks = getTaskByStateIdAndProjectId - .getTaskByStateIdAndProjectId(projectId, selectedState.id) + .getTaskByStateIdAndProjectId(projectId, selectedTaskState.id) if (tasks.isNotEmpty()) { printer.printInfoLine("Tasks:") diff --git a/src/main/kotlin/ui/view/project/ProjectTasksUi.kt b/src/main/kotlin/ui/view/project/ProjectTasksUi.kt index 5b01b6ea..dac68cf0 100644 --- a/src/main/kotlin/ui/view/project/ProjectTasksUi.kt +++ b/src/main/kotlin/ui/view/project/ProjectTasksUi.kt @@ -2,14 +2,13 @@ package ui.view.project import ui.common.exception.handler.SafeExecutor import domain.model.Task -import domain.use_case.task.GetProjectTasksUseCase +import domain.useCase.task.GetProjectTasksUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader import ui.common.UiScreen import ui.view.task.DeleteTaskUI import ui.view.task.EditTaskUi -import ui.view.user.mate.UserProjectsUi import org.koin.core.component.KoinComponent import org.koin.core.component.inject import java.util.* @@ -37,20 +36,26 @@ class ProjectTasksUi( } displayTasksInColumns(it) printer.printInfoLine("Please choose an option:") - printer.printOptions("Edit a task", "Delete a task", "Enter Any Thing To Go Back") + printer.printOptions("Edit a task", "Delete a task", "Go Back") val choice = reader.readInput()?.toIntOrNull() - when (choice) { - 1 -> { - EditTaskUi(projectId).show() - } - 2 -> { - DeleteTaskUI(projectId).show() - } + while (true) { + when (choice) { + 1 -> { + EditTaskUi(projectId).show() + } + + 2 -> { + DeleteTaskUI(projectId).show() + } + + 3 -> { + break + } - else -> { - printer.printGoodbyeMessage("Goodbye") - UserProjectsUi().show() + else -> { + printer.printError("Invalid option") + } } } } @@ -58,7 +63,7 @@ class ProjectTasksUi( } private fun displayTasksInColumns(tasks: List) { - val groupedTasks = tasks.groupBy { it.state.name } + val groupedTasks = tasks.groupBy { it.taskState.name } val stateNames = groupedTasks.keys.toList() diff --git a/src/main/kotlin/ui/view/project/ViewProjectsUi.kt b/src/main/kotlin/ui/view/project/ViewProjectsUi.kt index 5f5b5279..57eba90d 100644 --- a/src/main/kotlin/ui/view/project/ViewProjectsUi.kt +++ b/src/main/kotlin/ui/view/project/ViewProjectsUi.kt @@ -1,10 +1,11 @@ package ui.view.project import ui.common.exception.handler.SafeExecutor -import domain.use_case.project.GetAllProjectsUseCase +import domain.useCase.project.GetAllProjectsUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.UiScreen +import ui.extensions.formatDateTime class ViewProjectsUi( private val printer: Printer, @@ -33,8 +34,8 @@ class ViewProjectsUi( - Made by: ${project.creatorUserID} - Name: ${project.title} - Description: ${project.description} - - Creation Date: ${project.createdAt} - - Update Date: ${project.updatedAt} + - Creation Date: ${project.createdAt.formatDateTime()} + - Update Date: ${project.updatedAt.formatDateTime()} """.trimIndent() ) } diff --git a/src/main/kotlin/ui/view/task/CreateTaskUi.kt b/src/main/kotlin/ui/view/task/CreateTaskUi.kt index 6327864e..dbbed358 100644 --- a/src/main/kotlin/ui/view/task/CreateTaskUi.kt +++ b/src/main/kotlin/ui/view/task/CreateTaskUi.kt @@ -2,9 +2,9 @@ package ui.view.task import ui.common.exception.handler.SafeExecutor import domain.model.Project -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.GetProjectByIdUseCase -import domain.use_case.task.CreateTaskUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.GetProjectByIdUseCase +import domain.useCase.task.CreateTaskUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader @@ -38,7 +38,7 @@ class CreateTaskUi( val selectedStateIndex = getValidStateInput(selectedProject) - val selectedState = selectedProject.states[selectedStateIndex] + val selectedState = selectedProject.taskStates[selectedStateIndex] createTaskUseCase.createTask(name, description, selectedState, selectedProject.id, user.id) }, onError = { @@ -64,7 +64,7 @@ class CreateTaskUi( var selectedStateIndex: Int? = null do { printer.printInfoLine("Choose a state for the task:") - selectedProject.states.forEachIndexed { index, state -> + selectedProject.taskStates.forEachIndexed { index, state -> printer.printInfoLine("${index + 1}. ${state.name}") } @@ -77,10 +77,10 @@ class CreateTaskUi( selectedStateIndex = stateIndexInput.toIntOrNull()?.minus(1) - if (selectedStateIndex == null || selectedStateIndex !in selectedProject.states.indices) { - printer.printError("Invalid state selection. Please choose a valid number between 1 and ${selectedProject.states.size}.") + if (selectedStateIndex == null || selectedStateIndex !in selectedProject.taskStates.indices) { + printer.printError("Invalid state selection. Please choose a valid number between 1 and ${selectedProject.taskStates.size}.") } - } while (selectedStateIndex == null || selectedStateIndex !in selectedProject.states.indices) + } while (selectedStateIndex == null || selectedStateIndex !in selectedProject.taskStates.indices) return selectedStateIndex } diff --git a/src/main/kotlin/ui/view/task/DeleteTaskUi.kt b/src/main/kotlin/ui/view/task/DeleteTaskUi.kt index 27cd5ad6..1baae2fb 100644 --- a/src/main/kotlin/ui/view/task/DeleteTaskUi.kt +++ b/src/main/kotlin/ui/view/task/DeleteTaskUi.kt @@ -3,9 +3,9 @@ package ui.view.task import ui.common.exception.handler.SafeExecutor import domain.model.Task import domain.model.User -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.task.DeleteTaskUseCase -import domain.use_case.task.GetProjectTasksUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.task.DeleteTaskUseCase +import domain.useCase.task.GetProjectTasksUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader @@ -49,7 +49,7 @@ class DeleteTaskUI( Task #${index + 1} - Title: ${task.title} - Description: ${task.description} - - State: ${task.state.name} + - State: ${task.taskState.name} """.trimIndent() ) } diff --git a/src/main/kotlin/ui/view/task/EditTaskUi.kt b/src/main/kotlin/ui/view/task/EditTaskUi.kt index 4bc95231..c18d275b 100644 --- a/src/main/kotlin/ui/view/task/EditTaskUi.kt +++ b/src/main/kotlin/ui/view/task/EditTaskUi.kt @@ -4,10 +4,10 @@ import ui.common.exception.handler.SafeExecutor import domain.model.Project import domain.model.Task import domain.model.User -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.GetProjectByIdUseCase -import domain.use_case.task.EditTaskUseCase -import domain.use_case.task.GetProjectTasksUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.GetProjectByIdUseCase +import domain.useCase.task.EditTaskUseCase +import domain.useCase.task.GetProjectTasksUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader @@ -15,6 +15,7 @@ import ui.common.UiScreen import ui.view.user.mate.UserProjectsUi import org.koin.core.component.KoinComponent import org.koin.core.component.inject +import ui.view.project.ProjectTasksUi import java.util.* class EditTaskUi( @@ -52,10 +53,11 @@ class EditTaskUi( Task #${index + 1} - Title: ${task.title} - Description: ${task.description} - - State: ${task.state.name} + - State: ${task.taskState.name} """.trimIndent() ) } + printer.printOption("${tasks.size + 1}. Go Back") handleEditTask(tasks, user) } ) @@ -65,17 +67,29 @@ class EditTaskUi( tasks: List, user: User ) { - printer.printLoader("Enter the task number to edit(or any thing to Go Back ):") - val input = reader.readInput()?.trim() - val number = input?.toIntOrNull() + printer.printLoader("Enter the task number to edit:") - if (number == null || number !in 1..tasks.size) { - printer.printError("Invalid input. Returning to the projects screen.") - return - } + var running = true + while (running) { + val input = reader.readInt() + + when { + input != null && input in 1..tasks.size -> { + val selectedTask = tasks[input - 1] + editSelectedTask(selectedTask, user.id) + } + + input == tasks.size + 1 -> { + ProjectTasksUi(projectId).show() + running = false + } - val selectedTask = tasks[number - 1] - editSelectedTask(selectedTask, user.id) + else -> { + printer.printError("Invalid option") + break + } + } + } } private suspend fun editSelectedTask(task: Task, currentUser: UUID) { @@ -93,7 +107,7 @@ class EditTaskUi( """ Title: ${task.title} Description: ${task.description} - State: ${task.state.name} + State: ${task.taskState.name} """.trimIndent() ) @@ -101,8 +115,8 @@ class EditTaskUi( val newDescription = getValidInput("Enter new Description (Leave empty to keep the current):", task.description) - val selectedStateIndex = getValidStateInput(selectedProject, task.state.name) - val selectedState = selectedStateIndex?.let { selectedProject.states[it] } ?: task.state + val selectedStateIndex = getValidStateInput(selectedProject, task.taskState.name) + val selectedState = selectedStateIndex?.let { selectedProject.taskStates[it] } ?: task.taskState executor.tryToExecute( action = { @@ -120,16 +134,16 @@ class EditTaskUi( private fun getValidInput(message: String, currentValue: String): String? { - printer.printLoader("$message (Current value: $currentValue)") - val input = reader.readInput()?.trim() - return input + printer.printLoader("$message (Current value: $currentValue)") + val input = reader.readInput()?.trim() + return input } private fun getValidStateInput(selectedProject: Project, currentStateName: String): Int? { printer.printOptions("Choose a state for the task (Current: $currentStateName):") - selectedProject.states.forEachIndexed { index, state -> + selectedProject.taskStates.forEachIndexed { index, state -> printer.printInfoLine("${index + 1}. ${state.name}") } printer.printLoader("Enter a number from the list above, or any other number to keep the current state.") @@ -137,7 +151,7 @@ class EditTaskUi( val input = reader.readInput()?.trim() val selectedIndex = input?.toIntOrNull()?.minus(1) - return if (selectedIndex != null && selectedIndex in selectedProject.states.indices) { + return if (selectedIndex != null && selectedIndex in selectedProject.taskStates.indices) { selectedIndex } else { printer.printInfoLine("Keeping the current state: $currentStateName") diff --git a/src/main/kotlin/ui/view/user/admin/home/AdminUi.kt b/src/main/kotlin/ui/view/user/admin/home/AdminUi.kt index 5e172c15..c88a2146 100644 --- a/src/main/kotlin/ui/view/user/admin/home/AdminUi.kt +++ b/src/main/kotlin/ui/view/user/admin/home/AdminUi.kt @@ -49,10 +49,13 @@ class AdminUi : UiScreen, KoinComponent { } 5 -> { - printer.printGoodbyeMessage("Goodbye") break } + else -> { + printer.printError("Invalid option") + } + } } } diff --git a/src/main/kotlin/ui/view/user/admin/log/project/ProjectLogUi.kt b/src/main/kotlin/ui/view/user/admin/log/project/ProjectLogUi.kt index 88079411..de6c7727 100644 --- a/src/main/kotlin/ui/view/user/admin/log/project/ProjectLogUi.kt +++ b/src/main/kotlin/ui/view/user/admin/log/project/ProjectLogUi.kt @@ -2,8 +2,8 @@ package ui.view.user.admin.log.project import domain.model.Project import domain.model.ProjectLog -import domain.model.State -import domain.use_case.authentication.GetUserByIdUseCase +import domain.model.TaskState +import domain.useCase.authentication.GetUserByIdUseCase import ui.common.Printer import ui.extensions.formatDateTime import java.util.* @@ -85,8 +85,8 @@ open class ProjectLogUi( private fun handleStateChanges( index: Int, userName: String?, previousProject: Project, currentProject: Project ) { - val previousStates = previousProject.states - val currentStates = currentProject.states + val previousStates = previousProject.taskStates + val currentStates = currentProject.taskStates when { previousStates.size < currentStates.size -> handleStateAddition(index, userName, currentProject) previousStates.size == currentStates.size -> handleStateEdition( @@ -104,7 +104,7 @@ open class ProjectLogUi( ) { val projectName = currentProject.title printer.printCorrectOutput( - "${index + 1}. User $userName added new state ${currentProject.states.last().name} to project $projectName at ${currentProject.updatedAt.formatDateTime()}" + "${index + 1}. User $userName added new state ${currentProject.taskStates.last().name} to project $projectName at ${currentProject.updatedAt.formatDateTime()}" ) } @@ -112,18 +112,18 @@ open class ProjectLogUi( index: Int, userName: String?, previousProject: Project, currentProject: Project ) { val projectName = currentProject.title - val previousState = previousProject.states - val currentState = currentProject.states - findFirstStateChange(oldStates = previousState, updatedStates = currentState)?.let { (oldState, newState) -> + val previousState = previousProject.taskStates + val currentState = currentProject.taskStates + findFirstStateChange(oldTaskStates = previousState, updatedTaskStates = currentState)?.let { (oldState, newState) -> printer.printCorrectOutput( "${index + 1}. User $userName edited state form ${oldState.name} to ${newState.name} project $projectName at ${currentProject.updatedAt.formatDateTime()}" ) } } - private fun findFirstStateChange(oldStates: List, updatedStates: List): Pair? { - updatedStates.forEach { updatedState -> - oldStates.find { it.id == updatedState.id }?.let { oldState -> + private fun findFirstStateChange(oldTaskStates: List, updatedTaskStates: List): Pair? { + updatedTaskStates.forEach { updatedState -> + oldTaskStates.find { it.id == updatedState.id }?.let { oldState -> if (oldState.name != updatedState.name) return oldState to updatedState } } @@ -134,7 +134,7 @@ open class ProjectLogUi( index: Int, userName: String?, previousProject: Project, currentProject: Project ) { val projectName = currentProject.title - val deletedState = (previousProject.states - currentProject.states.toSet()).first() + val deletedState = (previousProject.taskStates - currentProject.taskStates.toSet()).first() printer.printCorrectOutput( "${index + 1}. User $userName deleted state ${deletedState.name} from project $projectName at ${currentProject.updatedAt.formatDateTime()}" ) diff --git a/src/main/kotlin/ui/view/user/admin/log/project/ProjectLogsUi.kt b/src/main/kotlin/ui/view/user/admin/log/project/ProjectLogsUi.kt index 1b0b806e..a334219d 100644 --- a/src/main/kotlin/ui/view/user/admin/log/project/ProjectLogsUi.kt +++ b/src/main/kotlin/ui/view/user/admin/log/project/ProjectLogsUi.kt @@ -2,8 +2,8 @@ package ui.view.user.admin.log.project import ui.common.exception.handler.ExceptionHandler import ui.common.exception.handler.SafeExecutor -import domain.use_case.authentication.GetUserByIdUseCase -import domain.use_case.log.GetAllProjectLogsUseCase +import domain.useCase.authentication.GetUserByIdUseCase +import domain.useCase.log.GetAllProjectLogsUseCase import ui.common.Printer import ui.common.UiScreen diff --git a/src/main/kotlin/ui/view/user/admin/log/task/TaskLogUi.kt b/src/main/kotlin/ui/view/user/admin/log/task/TaskLogUi.kt index 7d306375..844cef4a 100644 --- a/src/main/kotlin/ui/view/user/admin/log/task/TaskLogUi.kt +++ b/src/main/kotlin/ui/view/user/admin/log/task/TaskLogUi.kt @@ -2,7 +2,7 @@ package ui.view.user.admin.log.task import domain.model.Task import domain.model.TaskLog -import domain.use_case.authentication.GetUserByIdUseCase +import domain.useCase.authentication.GetUserByIdUseCase import ui.common.Printer import ui.extensions.formatDateTime import java.util.* @@ -82,8 +82,8 @@ open class TaskLogUi( index: Int, userName: String?, previousTask: Task, currentTask: Task ) { val taskName = currentTask.title - val previousStates = previousTask.state - val currentStates = currentTask.state + val previousStates = previousTask.taskState + val currentStates = currentTask.taskState printer.printCorrectOutput( "${index + 1}. User $userName changed state from ${previousStates.name} to ${currentStates.name} in task $taskName at ${currentTask.updatedAt.formatDateTime()}" ) diff --git a/src/main/kotlin/ui/view/user/admin/log/task/TaskLogsUi.kt b/src/main/kotlin/ui/view/user/admin/log/task/TaskLogsUi.kt index 2b81fcbc..9c2057a8 100644 --- a/src/main/kotlin/ui/view/user/admin/log/task/TaskLogsUi.kt +++ b/src/main/kotlin/ui/view/user/admin/log/task/TaskLogsUi.kt @@ -1,8 +1,8 @@ package ui.view.user.admin.log.task import ui.common.exception.handler.SafeExecutor -import domain.use_case.authentication.GetUserByIdUseCase -import domain.use_case.log.GetAllTaskLogsUseCase +import domain.useCase.authentication.GetUserByIdUseCase +import domain.useCase.log.GetAllTaskLogsUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.UiScreen diff --git a/src/main/kotlin/ui/view/user/admin/project/AddProjectUserUi.kt b/src/main/kotlin/ui/view/user/admin/project/AddProjectUserUi.kt index b9a5cf91..1a31bfa8 100644 --- a/src/main/kotlin/ui/view/user/admin/project/AddProjectUserUi.kt +++ b/src/main/kotlin/ui/view/user/admin/project/AddProjectUserUi.kt @@ -2,8 +2,8 @@ package ui.view.user.admin.project import ui.common.exception.handler.SafeExecutor import domain.model.User -import domain.use_case.authentication.GetAllUsersUseCase -import domain.use_case.project.AddProjectMateUseCase +import domain.useCase.authentication.GetAllUsersUseCase +import domain.useCase.project.AddProjectMateUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader diff --git a/src/main/kotlin/ui/view/user/admin/project/CreateProjectStateUi.kt b/src/main/kotlin/ui/view/user/admin/project/CreateProjectStateUi.kt index 827b0414..e601264b 100644 --- a/src/main/kotlin/ui/view/user/admin/project/CreateProjectStateUi.kt +++ b/src/main/kotlin/ui/view/user/admin/project/CreateProjectStateUi.kt @@ -2,7 +2,7 @@ package ui.view.user.admin.project import ui.common.exception.handler.SafeExecutor import domain.model.Project -import domain.use_case.state.CreateStateUseCase +import domain.useCase.state.CreateStateUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Reader import ui.common.UiScreen diff --git a/src/main/kotlin/ui/view/user/admin/project/CreateProjectUi.kt b/src/main/kotlin/ui/view/user/admin/project/CreateProjectUi.kt index f21c3c72..f649cd82 100644 --- a/src/main/kotlin/ui/view/user/admin/project/CreateProjectUi.kt +++ b/src/main/kotlin/ui/view/user/admin/project/CreateProjectUi.kt @@ -2,7 +2,7 @@ package ui.view.user.admin.project import ui.common.exception.handler.ExceptionHandler import ui.common.exception.handler.SafeExecutor -import domain.use_case.project.CreateProjectUseCase +import domain.useCase.project.CreateProjectUseCase import ui.common.Printer import ui.common.Reader import ui.common.UiScreen diff --git a/src/main/kotlin/ui/view/user/admin/project/DeleteProjectStateUi.kt b/src/main/kotlin/ui/view/user/admin/project/DeleteProjectStateUi.kt index f193e3b1..aa8fdb0e 100644 --- a/src/main/kotlin/ui/view/user/admin/project/DeleteProjectStateUi.kt +++ b/src/main/kotlin/ui/view/user/admin/project/DeleteProjectStateUi.kt @@ -3,8 +3,8 @@ package ui.view.user.admin.project import ui.common.exception.NullInputException import ui.common.exception.handler.SafeExecutor import domain.model.Project -import domain.model.State -import domain.use_case.state.DeleteStateUseCase +import domain.model.TaskState +import domain.useCase.state.DeleteStateUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader @@ -13,7 +13,7 @@ import org.koin.core.component.KoinComponent import org.koin.core.component.inject class DeleteProjectStateUi( - private val project: Project, private val state: State + private val project: Project, private val taskState: TaskState ) : UiScreen, KoinComponent { private val executor: SafeExecutor by inject() private val handler: ExceptionHandler by inject() @@ -22,7 +22,7 @@ class DeleteProjectStateUi( private val deleteStateUseCase: DeleteStateUseCase by inject() override suspend fun show() { - printer.printTitle("Confirm deletion of state '${state.name}': Y/N") + printer.printTitle("Confirm deletion of state '${taskState.name}': Y/N") when (reader.readInput()?.uppercase()) { "Y" -> deleteState() "N" -> return @@ -34,7 +34,7 @@ class DeleteProjectStateUi( private suspend fun deleteState() { executor.tryToExecute( action = { - deleteStateUseCase.deleteState(project, state) + deleteStateUseCase.deleteState(project, taskState) }, onError = { handler.printHandledError(it) diff --git a/src/main/kotlin/ui/view/user/admin/project/EditProjectStateUi.kt b/src/main/kotlin/ui/view/user/admin/project/EditProjectStateUi.kt index 8493b1c8..86d43c30 100644 --- a/src/main/kotlin/ui/view/user/admin/project/EditProjectStateUi.kt +++ b/src/main/kotlin/ui/view/user/admin/project/EditProjectStateUi.kt @@ -2,8 +2,8 @@ package ui.view.user.admin.project import ui.common.exception.handler.SafeExecutor import domain.model.Project -import domain.model.State -import domain.use_case.state.EditStateUseCase +import domain.model.TaskState +import domain.useCase.state.EditStateUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader @@ -13,7 +13,7 @@ import org.koin.core.component.inject class EditProjectStateUi( private val project: Project, - private val state: State + private val taskState: TaskState ) : UiScreen, KoinComponent { private val printer: Printer by inject() private val reader: Reader by inject() @@ -24,13 +24,13 @@ class EditProjectStateUi( override suspend fun show() { printer.printTitle("Edit State") - printer.printTitle("Current state name: ${state.name}") + printer.printTitle("Current state name: ${taskState.name}") printer.printTitle("Enter new state name:") val newName = reader.readInput().toString() executor.tryToExecute( action = { - editStateUseCase.editState(state, newName, project) + editStateUseCase.editState(taskState, newName, project) printer.printTitle("State updated successfully to: $newName") }, onError = { diff --git a/src/main/kotlin/ui/view/user/admin/project/EditProjectUi.kt b/src/main/kotlin/ui/view/user/admin/project/EditProjectUi.kt index f6a11cf5..a123c8cb 100644 --- a/src/main/kotlin/ui/view/user/admin/project/EditProjectUi.kt +++ b/src/main/kotlin/ui/view/user/admin/project/EditProjectUi.kt @@ -2,9 +2,9 @@ package ui.view.user.admin.project import ui.common.exception.handler.SafeExecutor import domain.model.Project -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.EditProjectDescriptionUseCase -import domain.use_case.project.EditProjectTitleUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.EditProjectDescriptionUseCase +import domain.useCase.project.EditProjectTitleUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader diff --git a/src/main/kotlin/ui/view/user/admin/project/ProjectStatesUi.kt b/src/main/kotlin/ui/view/user/admin/project/ProjectStatesUi.kt index e29d9993..861cae2b 100644 --- a/src/main/kotlin/ui/view/user/admin/project/ProjectStatesUi.kt +++ b/src/main/kotlin/ui/view/user/admin/project/ProjectStatesUi.kt @@ -1,8 +1,8 @@ package ui.view.user.admin.project import domain.model.Project -import domain.model.State -import domain.use_case.project.GetProjectByIdUseCase +import domain.model.TaskState +import domain.useCase.project.GetProjectByIdUseCase import ui.common.Printer import ui.common.Reader import ui.common.UiScreen @@ -16,19 +16,19 @@ class ProjectStatesUi( ) : UiScreen { private lateinit var projectId: UUID private lateinit var project: Project - private lateinit var states: List + private lateinit var taskStates: List suspend fun setProject(projectId: UUID) { this.projectId = projectId this.project = getProject() - this.states = project.states + this.taskStates = project.taskStates } override suspend fun show() { while (true) { printer.printTitle("Project states") - if (states.isEmpty()) { + if (taskStates.isEmpty()) { displayNoStatesAndGoToCreateState() break } else { @@ -38,16 +38,16 @@ class ProjectStatesUi( val selectedIndex = reader.readInput().toString().toIntOrNull()?.minus(1) ?: -1 when (selectedIndex) { - in states.indices -> { - goToSingleStateUi(states[selectedIndex]) + in taskStates.indices -> { + goToSingleStateUi(taskStates[selectedIndex]) } - states.size -> { + taskStates.size -> { break } else -> { - printer.printError("Invalid selection") + printer.printError("Invalid option") } } } @@ -66,13 +66,14 @@ class ProjectStatesUi( private fun displayAvailableStates() { printer.printCorrectOutput("Available States:") - printer.printOptions(states.map { it.name } + "Go Back") + printer.printOptions(taskStates.map { it.name }) + printer.printInfoLine("${taskStates.size + 1}. Go Back ") } - private suspend fun goToSingleStateUi(state: State) { + private suspend fun goToSingleStateUi(taskState: TaskState) { setProject(projectId) singleStateUi.setProject(project) - singleStateUi.setState(state) + singleStateUi.setState(taskState) singleStateUi.show() } } \ No newline at end of file diff --git a/src/main/kotlin/ui/view/user/admin/project/ProjectsUi.kt b/src/main/kotlin/ui/view/user/admin/project/ProjectsUi.kt index d04dab3f..07e4f95a 100644 --- a/src/main/kotlin/ui/view/user/admin/project/ProjectsUi.kt +++ b/src/main/kotlin/ui/view/user/admin/project/ProjectsUi.kt @@ -3,12 +3,13 @@ package ui.view.user.admin.project import ui.common.exception.handler.SafeExecutor import domain.model.Project import domain.model.User -import domain.use_case.authentication.GetUserByIdUseCase -import domain.use_case.project.GetAllProjectsUseCase +import domain.useCase.authentication.GetUserByIdUseCase +import domain.useCase.project.GetAllProjectsUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader import ui.common.UiScreen +import ui.extensions.formatDateTime import java.util.* class ProjectsUi( @@ -44,8 +45,8 @@ class ProjectsUi( - Made by: ${getUserById(project.creatorUserID).name} - Name: ${project.title} - Description: ${project.description} - - Creation Date: ${project.createdAt} - - Update Date: ${project.updatedAt} + - Creation Date: ${project.createdAt.formatDateTime()} + - Update Date: ${project.updatedAt.formatDateTime()} """.trimIndent() ) } @@ -84,7 +85,9 @@ class ProjectsUi( else -> { printer.printError("Invalid project number") - enterProject(projects) +// enterProject(projects) + showProjectDetails(projects) + } } } diff --git a/src/main/kotlin/ui/view/user/admin/project/SingleProjectUi.kt b/src/main/kotlin/ui/view/user/admin/project/SingleProjectUi.kt index c3b0ff22..20fd0e6f 100644 --- a/src/main/kotlin/ui/view/user/admin/project/SingleProjectUi.kt +++ b/src/main/kotlin/ui/view/user/admin/project/SingleProjectUi.kt @@ -3,9 +3,9 @@ package ui.view.user.admin.project import ui.common.exception.handler.SafeExecutor import domain.model.Project import domain.model.User -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.DeleteProjectUseCase -import domain.use_case.project.GetProjectByIdUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.DeleteProjectUseCase +import domain.useCase.project.GetProjectByIdUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader @@ -84,7 +84,7 @@ class SingleProjectUi( } 6 -> { - if (project.states.isEmpty()) { + if (project.taskStates.isEmpty()) { printer.printError("Cannot create a task because this project has no states.") } else { CreateTaskUi(projectId = project.id).show() @@ -92,19 +92,16 @@ class SingleProjectUi( } 7 -> { - printer.printGoodbyeMessage("Goodbye!") running = false } else -> { printer.printError("Invalid option") - takeUserInput() + show() + } } - - updateProject() - - + updateProject() } private suspend fun updateProject() { diff --git a/src/main/kotlin/ui/view/user/admin/project/SingleStateUi.kt b/src/main/kotlin/ui/view/user/admin/project/SingleStateUi.kt index 8f7c68e6..ba6e8c8c 100644 --- a/src/main/kotlin/ui/view/user/admin/project/SingleStateUi.kt +++ b/src/main/kotlin/ui/view/user/admin/project/SingleStateUi.kt @@ -2,8 +2,8 @@ package ui.view.user.admin.project import ui.common.exception.handler.SafeExecutor import domain.model.Project -import domain.model.State -import domain.use_case.project.GetProjectByIdUseCase +import domain.model.TaskState +import domain.useCase.project.GetProjectByIdUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.Reader @@ -17,14 +17,14 @@ class SingleStateUi( private val handler: ExceptionHandler, ) : UiScreen { private lateinit var project: Project - private lateinit var state: State + private lateinit var taskState: TaskState fun setProject(project: Project) { this.project = project } - fun setState(state: State) { - this.state = state + fun setState(taskState: TaskState) { + this.taskState = taskState } override suspend fun show() { @@ -36,11 +36,11 @@ class SingleStateUi( when (input) { 1 -> { - EditProjectStateUi(project, state).show() + EditProjectStateUi(project, taskState).show() } 2 -> { - DeleteProjectStateUi(project, state).show() + DeleteProjectStateUi(project, taskState).show() break } @@ -66,7 +66,7 @@ class SingleStateUi( } private fun displayHeader() { - printer.printTitle("State '${state.name}'") + printer.printTitle("State '${taskState.name}'") printer.printInfoLine("What would you like to do?") } @@ -74,7 +74,7 @@ class SingleStateUi( executor.tryToExecute( action = { project = getProjectByIdUseCase.getProjectById(project.id) - state = project.states.find { it.id == state.id }!! // Warning: Potential crash detected here! + taskState = project.taskStates.find { it.id == taskState.id }!! // Warning: Potential crash detected here! }, onError = { handler.printHandledError(it) diff --git a/src/main/kotlin/ui/view/user/mate/MateUi.kt b/src/main/kotlin/ui/view/user/mate/MateUi.kt index 53884fb1..9a3b28f9 100644 --- a/src/main/kotlin/ui/view/user/mate/MateUi.kt +++ b/src/main/kotlin/ui/view/user/mate/MateUi.kt @@ -27,10 +27,13 @@ class MateUi : UiScreen, KoinComponent { goToViewProjectsScreen() } - else -> { - printer.printGoodbyeMessage("Goodbye") + 2 -> { break } + + else -> { + printer.printError("Invalid option") + } } } } diff --git a/src/main/kotlin/ui/view/user/mate/UserProjectsUi.kt b/src/main/kotlin/ui/view/user/mate/UserProjectsUi.kt index 8412b4a1..dea99e1a 100644 --- a/src/main/kotlin/ui/view/user/mate/UserProjectsUi.kt +++ b/src/main/kotlin/ui/view/user/mate/UserProjectsUi.kt @@ -2,8 +2,8 @@ package ui.view.user.mate import ui.common.exception.handler.SafeExecutor import domain.model.Project -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.GetUserProjectsByIdUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.GetUserProjectsByIdUseCase import ui.common.exception.handler.ExceptionHandler import ui.common.Printer import ui.common.UiScreen @@ -49,26 +49,22 @@ class UserProjectsUi : UiScreen, KoinComponent { private suspend fun handleProjectSelection(projects: List) { var isRunning = true while (isRunning) { - printer.printOption("Enter project number (or any number to Go Back):") + printer.printOption("Enter project number:") val input = reader.readInt() handleUserInput(input, projects).also { isRunning = it } } } private suspend fun handleUserInput(input: Int?, projects: List): Boolean { - return when (input) { - null -> { - printer.printError("Please enter a valid number.") - true - } - - in 1..projects.size -> { + return when { + input != null && input in 1..projects.size -> { handleProjectSelectionById(projects[input - 1].id) false } else -> { - false + printer.printError("Invalid option") + true } } } diff --git a/src/test/kotlin/creator_helper/createProjectHelper.kt b/src/test/kotlin/creator_helper/createProjectHelper.kt index 408ec4a4..a6d7821f 100644 --- a/src/test/kotlin/creator_helper/createProjectHelper.kt +++ b/src/test/kotlin/creator_helper/createProjectHelper.kt @@ -1,7 +1,7 @@ package creator_helper import domain.model.Project -import domain.model.State +import domain.model.TaskState import domain.model.User import java.time.LocalDateTime import java.util.* @@ -13,7 +13,7 @@ fun createProjectHelper( creatorUserID: UUID = UUID.randomUUID(), createdAt: LocalDateTime = LocalDateTime.now(), updatedAt: LocalDateTime = LocalDateTime.now(), - state: List = listOf(createStateHelper()), + taskState: List = listOf(createStateHelper()), users: List = listOf(createUserHelper()) ): Project { return Project( @@ -24,6 +24,6 @@ fun createProjectHelper( createdAt = createdAt, updatedAt = updatedAt, users = users, - states = state + taskStates = taskState ) } \ No newline at end of file diff --git a/src/test/kotlin/creator_helper/createStateHelper.kt b/src/test/kotlin/creator_helper/createStateHelper.kt index e5664a37..2bfa0679 100644 --- a/src/test/kotlin/creator_helper/createStateHelper.kt +++ b/src/test/kotlin/creator_helper/createStateHelper.kt @@ -1,13 +1,13 @@ package creator_helper -import domain.model.State +import domain.model.TaskState import java.util.* fun createStateHelper( id: UUID = UUID.randomUUID(), name: String = "To Do" -): State { - return State( +): TaskState { + return TaskState( id = id, name = name ) diff --git a/src/test/kotlin/creator_helper/createTaskHelper.kt b/src/test/kotlin/creator_helper/createTaskHelper.kt index 7756c006..838b2e9e 100644 --- a/src/test/kotlin/creator_helper/createTaskHelper.kt +++ b/src/test/kotlin/creator_helper/createTaskHelper.kt @@ -1,6 +1,6 @@ package creator_helper -import domain.model.State +import domain.model.TaskState import domain.model.Task import java.time.LocalDateTime import java.util.* @@ -10,7 +10,7 @@ fun createTaskHelper( projectId: UUID = UUID.randomUUID(), title: String = "Test Task Title", description: String = "Test Task Description", - state: State = createStateHelper(), + taskState: TaskState = createStateHelper(), creatorUserID: UUID = UUID.randomUUID(), createdAt: LocalDateTime = LocalDateTime.now(), updatedAt: LocalDateTime = LocalDateTime.now() @@ -20,7 +20,7 @@ fun createTaskHelper( projectId = projectId, title = title, description = description, - state = state, + taskState = taskState, creatorUserID = creatorUserID, createdAt = createdAt, updatedAt = updatedAt diff --git a/src/test/kotlin/creator_helper/createUserHelper.kt b/src/test/kotlin/creator_helper/createUserHelper.kt index 00f3a3c9..53cac718 100644 --- a/src/test/kotlin/creator_helper/createUserHelper.kt +++ b/src/test/kotlin/creator_helper/createUserHelper.kt @@ -1,6 +1,6 @@ package creator_helper -import domain.model.Role +import domain.model.UserRole import domain.model.User import java.util.* @@ -9,7 +9,7 @@ fun createUserHelper( password: String = "password", email: String = "email", id: UUID = UUID.randomUUID(), - role: Role = Role.MATE, + userRole: UserRole = UserRole.MATE, isDeleted: Boolean = false, ): User { return User( @@ -17,7 +17,7 @@ fun createUserHelper( password = password, email =email, id = id, - role = role, + userRole = userRole, isDeleted = isDeleted, ) } @@ -26,12 +26,12 @@ val adminUser = createUserHelper( name = "admin", email = "admin@gmail.com", password = "admin123", - role = Role.ADMIN + userRole = UserRole.ADMIN ) val mateUser = createUserHelper( name = "mate", email = "mate@gmail.com", password = "mate123", - role = Role.MATE + userRole = UserRole.MATE ) \ No newline at end of file diff --git a/src/test/kotlin/creator_helper/createUserHelperForCsvWriter.kt b/src/test/kotlin/creator_helper/createUserHelperForCsvWriter.kt index 7f2d4382..6fcf5724 100644 --- a/src/test/kotlin/creator_helper/createUserHelperForCsvWriter.kt +++ b/src/test/kotlin/creator_helper/createUserHelperForCsvWriter.kt @@ -1,6 +1,6 @@ package creator_helper -import domain.model.Role +import domain.model.UserRole import domain.model.User import java.util.* @@ -17,7 +17,7 @@ fun createUserForCsvWriter( password = password, email =email, id = id, - role = Role.valueOf(role), + userRole = UserRole.valueOf(role), isDeleted = isDeleted, ) } @@ -36,7 +36,7 @@ fun createUserForCsvWriterInvalid( password = password, email =email, id = id, - role = Role.valueOf(role), + userRole = UserRole.valueOf(role), isDeleted = isDeleted, ) } diff --git a/src/test/kotlin/data/repository/AuthenticationRepositoryImplTest.kt b/src/test/kotlin/data/repository/AuthenticationRepositoryImplTest.kt index a57d13e5..370c8df7 100644 --- a/src/test/kotlin/data/repository/AuthenticationRepositoryImplTest.kt +++ b/src/test/kotlin/data/repository/AuthenticationRepositoryImplTest.kt @@ -1,7 +1,7 @@ package data.repository import creator_helper.createUserHelper -import data.datasource.interfaces.AuthenticationDataSource +import data.datasource.AuthenticationDataSource import io.mockk.coEvery import io.mockk.coVerify import io.mockk.mockk @@ -83,7 +83,7 @@ class AuthenticationRepositoryImplTest { @Test fun `getCurrentLoggedInUser should return current user`() = runTest { coEvery { authenticationDataSource.getCurrentUser() } returns testUser - val result = authenticationRepository.getCurrentLoggedInUser() + val result = authenticationRepository.getCurrentUser() assertEquals(testUser, result) coVerify { authenticationDataSource.getCurrentUser() } } diff --git a/src/test/kotlin/data/repository/LogRepositoryImplTest.kt b/src/test/kotlin/data/repository/LogRepositoryImplTest.kt index b40faa31..fe34cb84 100644 --- a/src/test/kotlin/data/repository/LogRepositoryImplTest.kt +++ b/src/test/kotlin/data/repository/LogRepositoryImplTest.kt @@ -2,7 +2,7 @@ package data.repository import creator_helper.createProjectLogHelper import creator_helper.createTaskLogHelper -import data.datasource.interfaces.LogDataSource +import data.datasource.LogDataSource import io.mockk.coEvery import io.mockk.coVerify import io.mockk.mockk diff --git a/src/test/kotlin/data/repository/ProjectRepositoryImplTest.kt b/src/test/kotlin/data/repository/ProjectRepositoryImplTest.kt index 5a478c1a..f5d47190 100644 --- a/src/test/kotlin/data/repository/ProjectRepositoryImplTest.kt +++ b/src/test/kotlin/data/repository/ProjectRepositoryImplTest.kt @@ -4,8 +4,8 @@ package data.repository import creator_helper.createProjectHelper import creator_helper.createStateHelper import creator_helper.createUserHelper -import data.datasource.interfaces.ProjectDataSource -import domain.model.Role +import data.datasource.ProjectDataSource +import domain.model.UserRole import io.mockk.coEvery import io.mockk.coVerify import io.mockk.mockk @@ -115,7 +115,7 @@ class ProjectRepositoryImplTest { val project = testProject coEvery { projectDataSource.deleteState(projectId, state) } returns project - val result = projectRepository.removeStateFromProject(projectId, state) + val result = projectRepository.deleteStateFromProject(projectId, state) assertEquals(project, result) coVerify { projectDataSource.deleteState(projectId, state) } @@ -124,7 +124,7 @@ class ProjectRepositoryImplTest { @Test fun `test add mate to project`() = runTest { val projectId = UUID.randomUUID() - val user = createUserHelper(role = Role.MATE) + val user = createUserHelper(userRole = UserRole.MATE) val project = testProject coEvery { projectDataSource.addMate(projectId, user) } returns project @@ -144,7 +144,7 @@ class ProjectRepositoryImplTest { ) coEvery { projectDataSource.getUserProjectsById(userId) } returns projects - val result = projectRepository.getProjectsForUserById(userId) + val result = projectRepository.getUserProjectsById(userId) assertEquals(projects, result) coVerify { projectDataSource.getUserProjectsById(userId) } diff --git a/src/test/kotlin/data/repository/TaskRepositoryImplTest.kt b/src/test/kotlin/data/repository/TaskRepositoryImplTest.kt index 74c4828d..af73f447 100644 --- a/src/test/kotlin/data/repository/TaskRepositoryImplTest.kt +++ b/src/test/kotlin/data/repository/TaskRepositoryImplTest.kt @@ -1,7 +1,7 @@ package data.repository import creator_helper.createTaskHelper -import data.datasource.interfaces.TaskDataSource +import data.datasource.TaskDataSource import ui.common.exception.TaskDeletionFailedException import ui.common.exception.TaskEditFailedException import ui.common.exception.TaskNotFoundException @@ -123,7 +123,7 @@ class TaskRepositoryImplTest { val tasksList = listOf(testTask) coEvery { taskDataSource.getAllTasksForProject(any()) } returns tasksList - val result = taskRepository.getAllTasksForProject(projectId) + val result = taskRepository.getAllProjectTasks(projectId) assertEquals(tasksList, result) coVerify { taskDataSource.getAllTasksForProject(projectId) } diff --git a/src/test/kotlin/domain/use_case/log/CreateProjectLogUseCaseTest.kt b/src/test/kotlin/domain/useCase/log/CreateProjectLogUseCaseTest.kt similarity index 99% rename from src/test/kotlin/domain/use_case/log/CreateProjectLogUseCaseTest.kt rename to src/test/kotlin/domain/useCase/log/CreateProjectLogUseCaseTest.kt index 7446e58a..75c2ad15 100644 --- a/src/test/kotlin/domain/use_case/log/CreateProjectLogUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/log/CreateProjectLogUseCaseTest.kt @@ -1,4 +1,4 @@ -package domain.use_case.log +package domain.useCase.log import com.google.common.truth.Truth.assertThat import creator_helper.projectLog diff --git a/src/test/kotlin/domain/use_case/log/CreateTaskLogUseCaseTest.kt b/src/test/kotlin/domain/useCase/log/CreateTaskLogUseCaseTest.kt similarity index 99% rename from src/test/kotlin/domain/use_case/log/CreateTaskLogUseCaseTest.kt rename to src/test/kotlin/domain/useCase/log/CreateTaskLogUseCaseTest.kt index 27f2f255..f0d8c944 100644 --- a/src/test/kotlin/domain/use_case/log/CreateTaskLogUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/log/CreateTaskLogUseCaseTest.kt @@ -1,4 +1,4 @@ -package domain.use_case.log +package domain.useCase.log import com.google.common.truth.Truth.assertThat import creator_helper.taskLog diff --git a/src/test/kotlin/domain/use_case/log/GetAllProjectLogsUseCaseTest.kt b/src/test/kotlin/domain/useCase/log/GetAllProjectLogsUseCaseTest.kt similarity index 98% rename from src/test/kotlin/domain/use_case/log/GetAllProjectLogsUseCaseTest.kt rename to src/test/kotlin/domain/useCase/log/GetAllProjectLogsUseCaseTest.kt index 7f6261f0..94f5a9c3 100644 --- a/src/test/kotlin/domain/use_case/log/GetAllProjectLogsUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/log/GetAllProjectLogsUseCaseTest.kt @@ -1,4 +1,4 @@ -package domain.use_case.log +package domain.useCase.log import com.google.common.truth.Truth.assertThat import creator_helper.projectLogsForAllUsers diff --git a/src/test/kotlin/domain/use_case/log/GetAllTaskLogsUseCaseTest.kt b/src/test/kotlin/domain/useCase/log/GetAllTaskLogsUseCaseTest.kt similarity index 98% rename from src/test/kotlin/domain/use_case/log/GetAllTaskLogsUseCaseTest.kt rename to src/test/kotlin/domain/useCase/log/GetAllTaskLogsUseCaseTest.kt index 0a8600e1..8b997920 100644 --- a/src/test/kotlin/domain/use_case/log/GetAllTaskLogsUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/log/GetAllTaskLogsUseCaseTest.kt @@ -1,4 +1,4 @@ -package domain.use_case.log +package domain.useCase.log import com.google.common.truth.Truth.assertThat import creator_helper.taskLogsForAllUsers diff --git a/src/test/kotlin/domain/use_case/project/AddProjectMateUseCaseTest.kt b/src/test/kotlin/domain/useCase/project/AddProjectMateUseCaseTest.kt similarity index 96% rename from src/test/kotlin/domain/use_case/project/AddProjectMateUseCaseTest.kt rename to src/test/kotlin/domain/useCase/project/AddProjectMateUseCaseTest.kt index ca61043c..f513904f 100644 --- a/src/test/kotlin/domain/use_case/project/AddProjectMateUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/project/AddProjectMateUseCaseTest.kt @@ -1,11 +1,11 @@ -package domain.use_case.project +package domain.useCase.project import creator_helper.createProjectHelper import creator_helper.createUserHelper import ui.common.exception.ProjectNotFoundException import domain.repository.ProjectRepository -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.log.CreateProjectLogUseCase import io.mockk.coEvery import io.mockk.coVerify import io.mockk.mockk diff --git a/src/test/kotlin/domain/use_case/project/AddProjectStateUseCaseTest.kt b/src/test/kotlin/domain/useCase/project/AddProjectTaskStateUseCaseTest.kt similarity index 91% rename from src/test/kotlin/domain/use_case/project/AddProjectStateUseCaseTest.kt rename to src/test/kotlin/domain/useCase/project/AddProjectTaskStateUseCaseTest.kt index e5008d8e..8f6bb5ae 100644 --- a/src/test/kotlin/domain/use_case/project/AddProjectStateUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/project/AddProjectTaskStateUseCaseTest.kt @@ -1,10 +1,10 @@ -package domain.use_case.project +package domain.useCase.project import creator_helper.createProjectHelper import creator_helper.createStateHelper import ui.common.exception.EmptyStateNameException import domain.repository.ProjectRepository -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.log.CreateProjectLogUseCase import io.mockk.coEvery import io.mockk.coVerify import io.mockk.mockk @@ -15,7 +15,7 @@ import org.junit.jupiter.api.Test import java.util.UUID import kotlin.test.assertFailsWith -class AddProjectStateUseCaseTest{ +class AddProjectTaskStateUseCaseTest{ private lateinit var repository: ProjectRepository private lateinit var logUseCase: CreateProjectLogUseCase @@ -34,7 +34,7 @@ class AddProjectStateUseCaseTest{ val userId = UUID.randomUUID() val project = createProjectHelper() val state = createStateHelper(name = "In Progress") - val updatedProject = project.copy(states = project.states + state) + val updatedProject = project.copy(taskStates = project.taskStates + state) coEvery { repository.addStateToProject(project.id, state) } returns updatedProject diff --git a/src/test/kotlin/domain/use_case/project/CreateProjectUseCaseTest.kt b/src/test/kotlin/domain/useCase/project/CreateProjectUseCaseTest.kt similarity index 92% rename from src/test/kotlin/domain/use_case/project/CreateProjectUseCaseTest.kt rename to src/test/kotlin/domain/useCase/project/CreateProjectUseCaseTest.kt index 7550dc0b..e75894ca 100644 --- a/src/test/kotlin/domain/use_case/project/CreateProjectUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/project/CreateProjectUseCaseTest.kt @@ -1,11 +1,11 @@ -package domain.use_case.project +package domain.useCase.project import creator_helper.createUserHelper import ui.common.exception.EmptyProjectDescriptionException import ui.common.exception.EmptyProjectTitleException import domain.repository.ProjectRepository -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.log.CreateProjectLogUseCase import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.BeforeEach @@ -50,7 +50,7 @@ class CreateProjectUseCaseTest { it.title == title && it.description == description && it.creatorUserID == currentUser.id - it.states.map { s -> s.name }.containsAll(listOf("To Do", "In Progress")) + it.taskStates.map { s -> s.name }.containsAll(listOf("To Do", "In Progress")) }) } coVerify(exactly = 1) { logUseCase.createProjectLog(currentUser.id, previousProject = null, any()) } diff --git a/src/test/kotlin/domain/use_case/project/DeleteProjectStateUseCaseTest.kt b/src/test/kotlin/domain/useCase/project/DeleteProjectTaskStateUseCaseTest.kt similarity index 77% rename from src/test/kotlin/domain/use_case/project/DeleteProjectStateUseCaseTest.kt rename to src/test/kotlin/domain/useCase/project/DeleteProjectTaskStateUseCaseTest.kt index da9acc0c..0d8ab7ac 100644 --- a/src/test/kotlin/domain/use_case/project/DeleteProjectStateUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/project/DeleteProjectTaskStateUseCaseTest.kt @@ -1,10 +1,10 @@ -package domain.use_case.project +package domain.useCase.project import creator_helper.createProjectHelper import creator_helper.createStateHelper import ui.common.exception.EmptyStateNameException import domain.repository.ProjectRepository -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.log.CreateProjectLogUseCase import io.mockk.coEvery import io.mockk.coVerify import io.mockk.mockk @@ -14,7 +14,7 @@ import kotlin.test.Test import kotlin.test.assertFailsWith import java.util.* -class DeleteProjectStateUseCaseTest { +class DeleteProjectTaskStateUseCaseTest { private lateinit var repository: ProjectRepository private lateinit var logUseCase: CreateProjectLogUseCase @@ -32,17 +32,17 @@ class DeleteProjectStateUseCaseTest { // Given val userId = UUID.randomUUID() val stateToRemove = createStateHelper(name = "To Do") - val originalProject = createProjectHelper(state = listOf(stateToRemove)) - val updatedProject = originalProject.copy(states = emptyList()) + val originalProject = createProjectHelper(taskState = listOf(stateToRemove)) + val updatedProject = originalProject.copy(taskStates = emptyList()) - coEvery { repository.removeStateFromProject(originalProject.id, stateToRemove) } returns updatedProject + coEvery { repository.deleteStateFromProject(originalProject.id, stateToRemove) } returns updatedProject // When val result = useCase.removeStateFromProject(userId, originalProject, stateToRemove) // Then - assert(result.states.isEmpty()) - coVerify(exactly = 1) { repository.removeStateFromProject(originalProject.id, stateToRemove) } + assert(result.taskStates.isEmpty()) + coVerify(exactly = 1) { repository.deleteStateFromProject(originalProject.id, stateToRemove) } coVerify(exactly = 1) { logUseCase.createProjectLog(userId, previousProject = originalProject, currentProject = updatedProject) } @@ -60,7 +60,7 @@ class DeleteProjectStateUseCaseTest { useCase.removeStateFromProject(userId, project, blankState) } - coVerify(exactly = 0) { repository.removeStateFromProject(any(), any()) } + coVerify(exactly = 0) { repository.deleteStateFromProject(any(), any()) } coVerify(exactly = 0) { logUseCase.createProjectLog(any(), any(), any()) } } } diff --git a/src/test/kotlin/domain/use_case/project/DeleteProjectUseCaseTest.kt b/src/test/kotlin/domain/useCase/project/DeleteProjectUseCaseTest.kt similarity index 92% rename from src/test/kotlin/domain/use_case/project/DeleteProjectUseCaseTest.kt rename to src/test/kotlin/domain/useCase/project/DeleteProjectUseCaseTest.kt index 0c46df0f..401eb8b9 100644 --- a/src/test/kotlin/domain/use_case/project/DeleteProjectUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/project/DeleteProjectUseCaseTest.kt @@ -1,8 +1,8 @@ -package domain.use_case.project +package domain.useCase.project import creator_helper.createProjectHelper import domain.repository.ProjectRepository -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.log.CreateProjectLogUseCase import io.mockk.mockk import io.mockk.coVerify import kotlinx.coroutines.test.runTest diff --git a/src/test/kotlin/domain/use_case/project/EditProjectDescriptionUseCaseTest.kt b/src/test/kotlin/domain/useCase/project/EditProjectDescriptionUseCaseTest.kt similarity index 97% rename from src/test/kotlin/domain/use_case/project/EditProjectDescriptionUseCaseTest.kt rename to src/test/kotlin/domain/useCase/project/EditProjectDescriptionUseCaseTest.kt index e13149b4..66b87d81 100644 --- a/src/test/kotlin/domain/use_case/project/EditProjectDescriptionUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/project/EditProjectDescriptionUseCaseTest.kt @@ -1,4 +1,4 @@ -package domain.use_case.project +package domain.useCase.project import com.google.common.truth.Truth.assertThat import creator_helper.createProjectHelper @@ -6,7 +6,7 @@ import ui.common.exception.DuplicateDescriptionException import ui.common.exception.EmptyProjectDescriptionException import domain.model.Project import domain.repository.ProjectRepository -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.log.CreateProjectLogUseCase import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.BeforeEach diff --git a/src/test/kotlin/domain/use_case/project/EditProjectStateUseCaseTest.kt b/src/test/kotlin/domain/useCase/project/EditProjectTaskStateUseCaseTest.kt similarity index 69% rename from src/test/kotlin/domain/use_case/project/EditProjectStateUseCaseTest.kt rename to src/test/kotlin/domain/useCase/project/EditProjectTaskStateUseCaseTest.kt index 536e73fa..d7d43192 100644 --- a/src/test/kotlin/domain/use_case/project/EditProjectStateUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/project/EditProjectTaskStateUseCaseTest.kt @@ -1,10 +1,10 @@ -package domain.use_case.project +package domain.useCase.project import creator_helper.createProjectHelper import ui.common.exception.EmptyStateNameException -import domain.model.State +import domain.model.TaskState import domain.repository.ProjectRepository -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.log.CreateProjectLogUseCase import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.BeforeEach @@ -13,7 +13,7 @@ import java.util.* import kotlin.test.assertFailsWith import kotlin.test.assertEquals -class EditProjectStateUseCaseTest { +class EditProjectTaskStateUseCaseTest { private lateinit var repository: ProjectRepository private lateinit var logUseCase: CreateProjectLogUseCase @@ -31,18 +31,18 @@ class EditProjectStateUseCaseTest { // Given val userId = UUID.randomUUID() val project = createProjectHelper() - val state = State(UUID.randomUUID(), "In Progress") - val updatedProject = project.copy(states = listOf(state)) + val taskState = TaskState(UUID.randomUUID(), "In Progress") + val updatedProject = project.copy(taskStates = listOf(taskState)) - coEvery { repository.editStateToProject(project.id, state) } returns updatedProject + coEvery { repository.editStateToProject(project.id, taskState) } returns updatedProject coEvery { logUseCase.createProjectLog(userId, project, updatedProject) } just Runs // when - val result = useCase.editStateToProject(userId, project, state) + val result = useCase.editStateToProject(userId, project, taskState) // then assertEquals(updatedProject, result) - coVerify { repository.editStateToProject(project.id, state) } + coVerify { repository.editStateToProject(project.id, taskState) } coVerify { logUseCase.createProjectLog(userId, project, updatedProject) } } @@ -51,11 +51,11 @@ class EditProjectStateUseCaseTest { // Given val userId = UUID.randomUUID() val project = createProjectHelper() - val blankState = State(UUID.randomUUID(), " ") + val blankTaskState = TaskState(UUID.randomUUID(), " ") //when & then assertFailsWith { - useCase.editStateToProject(userId, project, blankState) + useCase.editStateToProject(userId, project, blankTaskState) } coVerify(exactly = 0) { repository.editStateToProject(any(), any()) } coVerify(exactly = 0) { logUseCase.createProjectLog(any(), any(), any()) } diff --git a/src/test/kotlin/domain/use_case/project/EditProjectTitleUseCaseTest.kt b/src/test/kotlin/domain/useCase/project/EditProjectTitleUseCaseTest.kt similarity index 96% rename from src/test/kotlin/domain/use_case/project/EditProjectTitleUseCaseTest.kt rename to src/test/kotlin/domain/useCase/project/EditProjectTitleUseCaseTest.kt index e5b45182..89db7eee 100644 --- a/src/test/kotlin/domain/use_case/project/EditProjectTitleUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/project/EditProjectTitleUseCaseTest.kt @@ -1,10 +1,10 @@ -package domain.use_case.project +package domain.useCase.project import creator_helper.createProjectHelper import ui.common.exception.DuplicateTitleException import ui.common.exception.EmptyProjectTitleException import domain.repository.ProjectRepository -import domain.use_case.log.CreateProjectLogUseCase +import domain.useCase.log.CreateProjectLogUseCase import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.BeforeEach diff --git a/src/test/kotlin/domain/use_case/project/GetAllProjectsUseCaseTest.kt b/src/test/kotlin/domain/useCase/project/GetAllProjectsUseCaseTest.kt similarity index 96% rename from src/test/kotlin/domain/use_case/project/GetAllProjectsUseCaseTest.kt rename to src/test/kotlin/domain/useCase/project/GetAllProjectsUseCaseTest.kt index b02e7436..4d822598 100644 --- a/src/test/kotlin/domain/use_case/project/GetAllProjectsUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/project/GetAllProjectsUseCaseTest.kt @@ -1,4 +1,4 @@ -package domain.use_case.project +package domain.useCase.project import creator_helper.createProjectHelper import domain.repository.ProjectRepository diff --git a/src/test/kotlin/domain/use_case/project/GetProjectByIdUseCaseTest.kt b/src/test/kotlin/domain/useCase/project/GetProjectByIdUseCaseTest.kt similarity index 97% rename from src/test/kotlin/domain/use_case/project/GetProjectByIdUseCaseTest.kt rename to src/test/kotlin/domain/useCase/project/GetProjectByIdUseCaseTest.kt index cce59b54..1fa92d87 100644 --- a/src/test/kotlin/domain/use_case/project/GetProjectByIdUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/project/GetProjectByIdUseCaseTest.kt @@ -1,4 +1,4 @@ -package domain.use_case.project +package domain.useCase.project import creator_helper.createProjectHelper import domain.repository.ProjectRepository diff --git a/src/test/kotlin/domain/use_case/project/GetUserProjectsByIdUseCaseTest.kt b/src/test/kotlin/domain/useCase/project/GetUserProjectsByIdUseCaseTest.kt similarity index 81% rename from src/test/kotlin/domain/use_case/project/GetUserProjectsByIdUseCaseTest.kt rename to src/test/kotlin/domain/useCase/project/GetUserProjectsByIdUseCaseTest.kt index 4da3c042..27bcc40f 100644 --- a/src/test/kotlin/domain/use_case/project/GetUserProjectsByIdUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/project/GetUserProjectsByIdUseCaseTest.kt @@ -1,4 +1,4 @@ -package domain.use_case.project +package domain.useCase.project import creator_helper.createProjectHelper import creator_helper.createUserHelper @@ -7,7 +7,6 @@ import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.Assertions.* import org.junit.jupiter.api.* -import java.util.UUID class GetUserProjectsByIdUseCaseTest { private val projectRepository: ProjectRepository = mockk(relaxed = true) @@ -24,13 +23,13 @@ class GetUserProjectsByIdUseCaseTest { // Given val user = createUserHelper() val projectList = listOf(createProjectHelper(users = listOf(user)), createProjectHelper(users = listOf(user))) - coEvery { projectRepository.getProjectsForUserById(user.id) } returns projectList + coEvery { projectRepository.getUserProjectsById(user.id) } returns projectList // When val result = getUserProjectsByIdUseCase.getProjectForUserById(user.id) // Then - coVerify(exactly = 1) { projectRepository.getProjectsForUserById(user.id) } + coVerify(exactly = 1) { projectRepository.getUserProjectsById(user.id) } assertEquals(projectList, result) } diff --git a/src/test/kotlin/domain/use_case/state/CreateStateUseCaseTest.kt b/src/test/kotlin/domain/useCase/state/CreateTaskStateUseCaseTest.kt similarity index 88% rename from src/test/kotlin/domain/use_case/state/CreateStateUseCaseTest.kt rename to src/test/kotlin/domain/useCase/state/CreateTaskStateUseCaseTest.kt index e27c7372..6d9975bf 100644 --- a/src/test/kotlin/domain/use_case/state/CreateStateUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/state/CreateTaskStateUseCaseTest.kt @@ -1,10 +1,10 @@ -package domain.use_case.state +package domain.useCase.state import creator_helper.createProjectHelper import creator_helper.createUserHelper import ui.common.exception.EmptyStateNameException -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.AddProjectStateUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.AddProjectStateUseCase import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.Assertions.assertEquals @@ -13,7 +13,7 @@ import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertThrows -class CreateStateUseCaseTest { +class CreateTaskStateUseCaseTest { private val addProjectStateUseCase: AddProjectStateUseCase = mockk(relaxed = true) private val getCurrentUserUseCase: GetCurrentUserUseCase = mockk(relaxed = true) private lateinit var createStateUseCase: CreateStateUseCase @@ -39,7 +39,7 @@ class CreateStateUseCaseTest { assertEquals("Doing", result.name) assertNotNull(result.id) coVerify(exactly = 1) { - addProjectStateUseCase.addStateToProject(currentUserID = user.id, project = project, state = result) + addProjectStateUseCase.addStateToProject(currentUserID = user.id, project = project, taskState = result) } } diff --git a/src/test/kotlin/domain/use_case/state/DeleteStateUseCaseTest.kt b/src/test/kotlin/domain/useCase/state/DeleteTaskStateUseCaseTest.kt similarity index 83% rename from src/test/kotlin/domain/use_case/state/DeleteStateUseCaseTest.kt rename to src/test/kotlin/domain/useCase/state/DeleteTaskStateUseCaseTest.kt index d12e56da..75ebc453 100644 --- a/src/test/kotlin/domain/use_case/state/DeleteStateUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/state/DeleteTaskStateUseCaseTest.kt @@ -1,14 +1,14 @@ -package domain.use_case.state +package domain.useCase.state import creator_helper.* -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.DeleteProjectStateUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.DeleteProjectStateUseCase import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.Assertions.* import org.junit.jupiter.api.* -class DeleteStateUseCaseTest { +class DeleteTaskStateUseCaseTest { private val deleteProjectStateUseCase: DeleteProjectStateUseCase = mockk(relaxed = true) private val getCurrentUserUseCase: GetCurrentUserUseCase = mockk(relaxed = true) private lateinit var deleteStateUseCase: DeleteStateUseCase @@ -25,7 +25,7 @@ class DeleteStateUseCaseTest { val user = createUserHelper() val project = createProjectHelper() val state = createStateHelper() - val updatedProject = project.copy(states = project.states - state) + val updatedProject = project.copy(taskStates = project.taskStates - state) coEvery { getCurrentUserUseCase.getCurrentUser() } returns user coEvery { diff --git a/src/test/kotlin/domain/use_case/state/EditStateUseCaseTest.kt b/src/test/kotlin/domain/useCase/state/EditTaskStateUseCaseTest.kt similarity index 84% rename from src/test/kotlin/domain/use_case/state/EditStateUseCaseTest.kt rename to src/test/kotlin/domain/useCase/state/EditTaskStateUseCaseTest.kt index a6e98f3b..42ae2f02 100644 --- a/src/test/kotlin/domain/use_case/state/EditStateUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/state/EditTaskStateUseCaseTest.kt @@ -1,11 +1,11 @@ -package domain.use_case.state +package domain.useCase.state import creator_helper.createProjectHelper import creator_helper.createStateHelper import creator_helper.createUserHelper import ui.common.exception.EmptyStateNameException -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.EditProjectStateUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.EditProjectStateUseCase import io.mockk.clearAllMocks import io.mockk.coEvery import io.mockk.coVerify @@ -19,7 +19,7 @@ import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertThrows import java.util.* -class EditStateUseCaseTest { +class EditTaskStateUseCaseTest { private val editProjectStateUseCase: EditProjectStateUseCase = mockk(relaxed = true) private val getCurrentUserUseCase: GetCurrentUserUseCase = mockk(relaxed = true) @@ -44,7 +44,7 @@ class EditStateUseCaseTest { val project = createProjectHelper( creatorUserID = currentUser.id, - state = listOf(targetState, otherState) + taskState = listOf(targetState, otherState) ) val newStateName = "Updated State" @@ -55,10 +55,10 @@ class EditStateUseCaseTest { val result = editStateUseCase.editState(targetState, newStateName, project) // Then - assertEquals(2, result.states.size) + assertEquals(2, result.taskStates.size) - val updatedState = result.states.find { it.id == targetStateId } - val unchangedState = result.states.find { it.id == otherStateId } + val updatedState = result.taskStates.find { it.id == targetStateId } + val unchangedState = result.taskStates.find { it.id == otherStateId } assertNotNull(updatedState) assertEquals(newStateName, updatedState?.name) @@ -80,7 +80,7 @@ class EditStateUseCaseTest { // Given val user = createUserHelper() val state = createStateHelper() - val project = createProjectHelper(state = listOf(state)) + val project = createProjectHelper(taskState = listOf(state)) coEvery { getCurrentUserUseCase.getCurrentUser() } returns user diff --git a/src/test/kotlin/domain/use_case/task/CreateTaskUseCaseTest.kt b/src/test/kotlin/domain/useCase/task/CreateTaskUseCaseTest.kt similarity index 96% rename from src/test/kotlin/domain/use_case/task/CreateTaskUseCaseTest.kt rename to src/test/kotlin/domain/useCase/task/CreateTaskUseCaseTest.kt index 28e92bfe..ead242c9 100644 --- a/src/test/kotlin/domain/use_case/task/CreateTaskUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/task/CreateTaskUseCaseTest.kt @@ -1,4 +1,4 @@ -package domain.use_case.task +package domain.useCase.task import creator_helper.createStateHelper import creator_helper.createTaskHelper @@ -6,7 +6,7 @@ import ui.common.exception.EmptyTaskDescriptionException import ui.common.exception.EmptyTaskTitleException import domain.model.Task import domain.repository.TaskRepository -import domain.use_case.log.CreateTaskLogUseCase +import domain.useCase.log.CreateTaskLogUseCase import io.mockk.* import kotlinx.coroutines.runBlocking import kotlinx.coroutines.test.runTest @@ -30,7 +30,7 @@ class CreateTaskUseCaseTest { @Test fun `createTask should call taskRepository createTask`() = runTest { val task = createTaskHelper() - val state = task.state + val state = task.taskState coEvery { taskRepository.createTask(any()) } just Runs coEvery { createTaskLogUseCase.createTaskLog(any(), any(), any()) } just Runs @@ -60,7 +60,7 @@ class CreateTaskUseCaseTest { taskRepository.createTask(match { task -> task.title == title && task.description == description && - task.state == state && + task.taskState == state && task.projectId == projectId && task.creatorUserID == creatorUserId }) @@ -132,7 +132,7 @@ class CreateTaskUseCaseTest { // Then coVerify { taskRepository.createTask(match { task -> - task.state.name == stateName + task.taskState.name == stateName }) } } diff --git a/src/test/kotlin/domain/use_case/task/DeleteTaskUseCaseTest.kt b/src/test/kotlin/domain/useCase/task/DeleteTaskUseCaseTest.kt similarity index 92% rename from src/test/kotlin/domain/use_case/task/DeleteTaskUseCaseTest.kt rename to src/test/kotlin/domain/useCase/task/DeleteTaskUseCaseTest.kt index 52cd36c9..803a83fa 100644 --- a/src/test/kotlin/domain/use_case/task/DeleteTaskUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/task/DeleteTaskUseCaseTest.kt @@ -1,8 +1,8 @@ -package domain.use_case.task +package domain.useCase.task import creator_helper.createTaskHelper import domain.repository.TaskRepository -import domain.use_case.log.CreateTaskLogUseCase +import domain.useCase.log.CreateTaskLogUseCase import io.mockk.* import kotlinx.coroutines.test.* import org.junit.jupiter.api.* diff --git a/src/test/kotlin/domain/use_case/task/EditTaskUseCaseTest.kt b/src/test/kotlin/domain/useCase/task/EditTaskUseCaseTest.kt similarity index 91% rename from src/test/kotlin/domain/use_case/task/EditTaskUseCaseTest.kt rename to src/test/kotlin/domain/useCase/task/EditTaskUseCaseTest.kt index 44c171bc..c4e28e7e 100644 --- a/src/test/kotlin/domain/use_case/task/EditTaskUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/task/EditTaskUseCaseTest.kt @@ -1,10 +1,10 @@ -package domain.use_case.task +package domain.useCase.task import creator_helper.createStateHelper import creator_helper.createTaskHelper import ui.common.exception.EmptyFieldException import domain.repository.TaskRepository -import domain.use_case.log.CreateTaskLogUseCase +import domain.useCase.log.CreateTaskLogUseCase import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.BeforeEach @@ -36,7 +36,7 @@ class EditTaskUseCaseTest { coVerify { taskRepository.editTask(match { - it.title == newTitle && it.description == task.description && it.state == newState + it.title == newTitle && it.description == task.description && it.taskState == newState }) } } @@ -73,7 +73,7 @@ class EditTaskUseCaseTest { coVerify { taskRepository.editTask(match { - it.title == newTitle && it.description == newDescription && it.state == newState + it.title == newTitle && it.description == newDescription && it.taskState == newState }) createTaskLogUseCase.createTaskLog(editorId, task, any()) } @@ -90,14 +90,14 @@ class EditTaskUseCaseTest { coEvery { createTaskLogUseCase.createTaskLog(any(), any(), any()) } just Runs // When - editTaskUseCase.editTask(task, null, newDescription, task.state, editorId) + editTaskUseCase.editTask(task, null, newDescription, task.taskState, editorId) // Then coVerify { taskRepository.editTask(match { it.title == task.title && it.description == newDescription && - it.state == task.state + it.taskState == task.taskState }) createTaskLogUseCase.createTaskLog(editorId, task, any()) } @@ -114,14 +114,14 @@ class EditTaskUseCaseTest { coEvery { createTaskLogUseCase.createTaskLog(any(), any(), any()) } just Runs // When - editTaskUseCase.editTask(task, newTitle, null, task.state, editorId) + editTaskUseCase.editTask(task, newTitle, null, task.taskState, editorId) // Then coVerify { taskRepository.editTask(match { it.title == newTitle && it.description == task.description && - it.state == task.state + it.taskState == task.taskState }) createTaskLogUseCase.createTaskLog(editorId, task, any()) } @@ -158,14 +158,14 @@ class EditTaskUseCaseTest { coEvery { createTaskLogUseCase.createTaskLog(any(), any(), any()) } just Runs // When - editTaskUseCase.editTask(task, " ", "Updated Description", task.state, editorId) + editTaskUseCase.editTask(task, " ", "Updated Description", task.taskState, editorId) // Then coVerify { taskRepository.editTask(match { it.description == "Updated Description" && it.title == task.title && - it.state == task.state + it.taskState == task.taskState }) } } @@ -180,14 +180,14 @@ class EditTaskUseCaseTest { coEvery { createTaskLogUseCase.createTaskLog(any(), any(), any()) } just Runs // When - editTaskUseCase.editTask(task, "Updated Title", " ", task.state, editorId) + editTaskUseCase.editTask(task, "Updated Title", " ", task.taskState, editorId) // Then coVerify { taskRepository.editTask(match { it.title == "Updated Title" && it.description == task.description && - it.state == task.state + it.taskState == task.taskState }) } } @@ -204,7 +204,7 @@ class EditTaskUseCaseTest { task = task, newTitle = null, newDescription = null, - newState = task.state, + newTaskState = task.taskState, editorUserId = editorId ) } @@ -222,7 +222,7 @@ class EditTaskUseCaseTest { task = task, newTitle = " ", newDescription = " ", - newState = task.state, + newTaskState = task.taskState, editorUserId = editorId ) } diff --git a/src/test/kotlin/domain/use_case/task/GetProjectTasksUseCaseTest.kt b/src/test/kotlin/domain/useCase/task/GetProjectTasksUseCaseTest.kt similarity index 84% rename from src/test/kotlin/domain/use_case/task/GetProjectTasksUseCaseTest.kt rename to src/test/kotlin/domain/useCase/task/GetProjectTasksUseCaseTest.kt index 00203c0b..3fd7d9ba 100644 --- a/src/test/kotlin/domain/use_case/task/GetProjectTasksUseCaseTest.kt +++ b/src/test/kotlin/domain/useCase/task/GetProjectTasksUseCaseTest.kt @@ -1,4 +1,4 @@ -package domain.use_case.task +package domain.useCase.task import creator_helper.createTaskHelper import domain.repository.TaskRepository @@ -23,13 +23,13 @@ class GetProjectTasksUseCaseTest { // Given val projectId = UUID.randomUUID() val taskList = listOf(createTaskHelper(projectId = projectId)) - coEvery { taskRepository.getAllTasksForProject(any()) } returns taskList + coEvery { taskRepository.getAllProjectTasks(any()) } returns taskList // When getProjectTasksUseCase.getProjectTasks(projectId) // Then - coVerify(exactly = 1) { taskRepository.getAllTasksForProject(projectId) } + coVerify(exactly = 1) { taskRepository.getAllProjectTasks(projectId) } } @Test @@ -41,7 +41,7 @@ class GetProjectTasksUseCaseTest { val task3 = createTaskHelper(projectId = projectId) val expectedTasks = listOf(task1, task2, task3) - coEvery { taskRepository.getAllTasksForProject(projectId) } returns expectedTasks + coEvery { taskRepository.getAllProjectTasks(projectId) } returns expectedTasks // When val result = getProjectTasksUseCase.getProjectTasks(projectId) @@ -66,8 +66,8 @@ class GetProjectTasksUseCaseTest { createTaskHelper(projectId = projectId2) ) - coEvery { taskRepository.getAllTasksForProject(projectId1) } returns tasksForProject1 - coEvery { taskRepository.getAllTasksForProject(projectId2) } returns tasksForProject2 + coEvery { taskRepository.getAllProjectTasks(projectId1) } returns tasksForProject1 + coEvery { taskRepository.getAllProjectTasks(projectId2) } returns tasksForProject2 // When val result1 = getProjectTasksUseCase.getProjectTasks(projectId1) @@ -92,7 +92,7 @@ class GetProjectTasksUseCaseTest { createTaskHelper(projectId = projectId) ) - coEvery { taskRepository.getAllTasksForProject(projectId) } returns tasks + coEvery { taskRepository.getAllProjectTasks(projectId) } returns tasks // When val result = getProjectTasksUseCase.getProjectTasks(projectId) diff --git a/src/test/kotlin/domain/use_case/task/GetTaskByStateIdAndProjectIdTest.kt b/src/test/kotlin/domain/useCase/task/GetTaskByTaskStateIdAndProjectIdTest.kt similarity index 81% rename from src/test/kotlin/domain/use_case/task/GetTaskByStateIdAndProjectIdTest.kt rename to src/test/kotlin/domain/useCase/task/GetTaskByTaskStateIdAndProjectIdTest.kt index d4149438..9c3d3e0c 100644 --- a/src/test/kotlin/domain/use_case/task/GetTaskByStateIdAndProjectIdTest.kt +++ b/src/test/kotlin/domain/useCase/task/GetTaskByTaskStateIdAndProjectIdTest.kt @@ -1,4 +1,4 @@ -package domain.use_case.task +package domain.useCase.task import creator_helper.* import domain.repository.TaskRepository @@ -8,7 +8,7 @@ import org.junit.jupiter.api.Assertions.* import org.junit.jupiter.api.* import java.util.UUID -class GetTaskByStateIdAndProjectIdTest { +class GetTaskByTaskStateIdAndProjectIdTest { private val taskRepository: TaskRepository = mockk(relaxed = true) private lateinit var getTaskByStateIdAndProjectId: GetTaskByStateIdAndProjectId @@ -22,8 +22,8 @@ class GetTaskByStateIdAndProjectIdTest { // Given val projectId = UUID.randomUUID() val stateId = UUID.randomUUID() - val task1 = createTaskHelper(projectId = projectId, state = createStateHelper(id = stateId)) - val task2 = createTaskHelper(projectId = projectId, state = createStateHelper(id = stateId)) + val task1 = createTaskHelper(projectId = projectId, taskState = createStateHelper(id = stateId)) + val task2 = createTaskHelper(projectId = projectId, taskState = createStateHelper(id = stateId)) coEvery { taskRepository.getTaskByStateIdAndProjectId(projectId, stateId) } returns listOf(task1, task2) diff --git a/src/test/kotlin/ui/admin/log/project/DisplayProjectLogTest.kt b/src/test/kotlin/ui/admin/log/project/DisplayProjectLogTest.kt index 944f1cca..a8a5f2e3 100644 --- a/src/test/kotlin/ui/admin/log/project/DisplayProjectLogTest.kt +++ b/src/test/kotlin/ui/admin/log/project/DisplayProjectLogTest.kt @@ -4,7 +4,7 @@ import creator_helper.createProjectHelper import creator_helper.createProjectLogHelper import creator_helper.createStateHelper import creator_helper.createUserHelper -import domain.use_case.authentication.GetUserByIdUseCase +import domain.useCase.authentication.GetUserByIdUseCase import io.mockk.coEvery import io.mockk.mockk import io.mockk.verify @@ -169,8 +169,8 @@ class ProjectLogUiTest { val currentStates = listOf(state1, state2) val previousState = listOf(state1) - val currentProject = createProjectHelper(state = currentStates) - val previousProject = createProjectHelper(state = previousState) + val currentProject = createProjectHelper(taskState = currentStates) + val previousProject = createProjectHelper(taskState = previousState) val projectLog = createProjectLogHelper(previousEntity = previousProject , currentEntity = currentProject) val index = 0 @@ -180,7 +180,7 @@ class ProjectLogUiTest { // Then verify { printer.printCorrectOutput( - "${index + 1}. User $userName added new state ${currentProject?.states?.last()?.name} to project ${currentProject.title} at ${currentProject?.updatedAt?.formatDateTime()}" + "${index + 1}. User $userName added new state ${currentProject?.taskStates?.last()?.name} to project ${currentProject.title} at ${currentProject?.updatedAt?.formatDateTime()}" ) } } @@ -201,8 +201,8 @@ class ProjectLogUiTest { val currentStates = listOf(state1) val previousStates = listOf(state1,state2) - val currentProject = createProjectHelper(state = currentStates) - val previousProject = createProjectHelper(state = previousStates) + val currentProject = createProjectHelper(taskState = currentStates) + val previousProject = createProjectHelper(taskState = previousStates) val projectLog = createProjectLogHelper(previousEntity = previousProject , currentEntity = currentProject) val index = 0 @@ -233,8 +233,8 @@ class ProjectLogUiTest { val currentStates = listOf(state1) val previousStates = listOf(state1,state2) - val currentProject = createProjectHelper(state = currentStates) - val previousProject = createProjectHelper(state = previousStates) + val currentProject = createProjectHelper(taskState = currentStates) + val previousProject = createProjectHelper(taskState = previousStates) val projectLog = createProjectLogHelper(previousEntity = previousProject , currentEntity = currentProject) val index = 0 @@ -266,8 +266,8 @@ class ProjectLogUiTest { val currentStates = listOf(state2,state3) val previousStates = listOf(state1,state3) - val currentProject = createProjectHelper(state = currentStates) - val previousProject = createProjectHelper(state = previousStates) + val currentProject = createProjectHelper(taskState = currentStates) + val previousProject = createProjectHelper(taskState = previousStates) val projectLog = createProjectLogHelper(previousEntity = previousProject , currentEntity = currentProject) val index = 0 @@ -325,8 +325,8 @@ class ProjectLogUiTest { val currentStates = listOf(state1, state2) val previousStates = listOf(state1, state2) - val currentProject = createProjectHelper(state = currentStates) - val previousProject = createProjectHelper(state = previousStates) + val currentProject = createProjectHelper(taskState = currentStates) + val previousProject = createProjectHelper(taskState = previousStates) val projectLog = createProjectLogHelper(previousEntity = previousProject, currentEntity = currentProject) val index = 0 diff --git a/src/test/kotlin/ui/view/authentication/LoginUiTest.kt b/src/test/kotlin/ui/view/authentication/LoginUiTest.kt index 5888b342..4a73da14 100644 --- a/src/test/kotlin/ui/view/authentication/LoginUiTest.kt +++ b/src/test/kotlin/ui/view/authentication/LoginUiTest.kt @@ -6,7 +6,7 @@ import ui.common.exception.EmptyFieldException import ui.common.exception.InvalidCredentialsException import ui.common.exception.handler.ExceptionHandler import ui.common.exception.handler.SafeExecutor -import domain.use_case.authentication.LoginUseCase +import domain.useCase.authentication.LoginUseCase import io.mockk.coEvery import io.mockk.coVerify import io.mockk.every @@ -16,8 +16,6 @@ import io.mockk.verify import kotlinx.coroutines.test.runTest import ui.common.Printer import org.junit.jupiter.api.BeforeEach -import org.junit.jupiter.api.Disabled -import org.junit.jupiter.api.assertThrows import ui.common.Reader import ui.common.Validator import ui.view.user.admin.home.AdminUi @@ -59,14 +57,14 @@ class LoginUiTest { verify { printer.printInfoLine("Please enter your information to login:") } } - @Disabled @Test - fun `should throw EmptyFieldException when user input is null`() = runTest { + fun `should print error message empty field when user input is null`() = runTest { + val exception = EmptyFieldException() every { reader.readInput() } returns null - assertThrows { - loginUi.show() - } + loginUi.show() + + handler.printHandledError(exception) } @Test @@ -76,9 +74,9 @@ class LoginUiTest { loginUi.show() - coVerify { adminUi.show() } verify { printer.printCorrectOutput("Welcome ${adminUser.name}") } verify { printer.printCorrectOutput("Login successful!") } + coVerify { adminUi.show() } } @@ -90,9 +88,9 @@ class LoginUiTest { loginUi.show() - coVerify { mateUi.show() } verify { printer.printCorrectOutput("Welcome ${mateUser.name}") } verify { printer.printCorrectOutput("Login successful!") } + coVerify { mateUi.show() } } @Test diff --git a/src/test/kotlin/ui/view/authentication/RegisterUiTest.kt b/src/test/kotlin/ui/view/authentication/RegisterUiTest.kt index ba61e847..7d3cdf91 100644 --- a/src/test/kotlin/ui/view/authentication/RegisterUiTest.kt +++ b/src/test/kotlin/ui/view/authentication/RegisterUiTest.kt @@ -4,7 +4,7 @@ import ui.common.exception.EmailAlreadyExistsException import ui.common.exception.EmptyFieldException import ui.common.exception.handler.ExceptionHandler import ui.common.exception.handler.SafeExecutor -import domain.use_case.authentication.RegisterUserUseCase +import domain.useCase.authentication.RegisterUserUseCase import io.mockk.coEvery import io.mockk.coVerify import io.mockk.every @@ -12,8 +12,6 @@ import io.mockk.mockk import io.mockk.spyk import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.BeforeEach -import org.junit.jupiter.api.Disabled -import org.junit.jupiter.api.assertThrows import ui.common.Printer import ui.common.Reader import ui.common.Validator @@ -52,14 +50,15 @@ class RegisterUiTest { coVerify { printer.printInfoLine("Please enter your registration credentials :") } } - @Disabled + @Test fun `should throw EmptyFieldException when user input is null`() = runTest { + val exception = EmptyFieldException() every { reader.readInput() } returns null - assertThrows { - registerUi.show() - } + registerUi.show() + + handler.printHandledError(exception) } @Test diff --git a/src/test/kotlin/ui/view/task/CreateTaskUiTest.kt b/src/test/kotlin/ui/view/task/CreateTaskUiTest.kt index 0267022c..39189dc1 100644 --- a/src/test/kotlin/ui/view/task/CreateTaskUiTest.kt +++ b/src/test/kotlin/ui/view/task/CreateTaskUiTest.kt @@ -4,9 +4,9 @@ import creator_helper.createProjectHelper import creator_helper.createStateHelper import creator_helper.createUserHelper -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.GetProjectByIdUseCase -import domain.use_case.task.CreateTaskUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.GetProjectByIdUseCase +import domain.useCase.task.CreateTaskUseCase import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.AfterEach @@ -63,7 +63,7 @@ class CreateTaskUiTest { // Given val user = createUserHelper() val state = createStateHelper() - val project = createProjectHelper(state = listOf(state)) + val project = createProjectHelper(taskState = listOf(state)) coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project coEvery { getCurrentUserUseCase.getCurrentUser() } returns user @@ -83,7 +83,7 @@ class CreateTaskUiTest { // Given val user = createUserHelper() val state = createStateHelper() - val project = createProjectHelper(state = listOf(state)) + val project = createProjectHelper(taskState = listOf(state)) coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project coEvery { getCurrentUserUseCase.getCurrentUser() } returns user @@ -104,7 +104,7 @@ class CreateTaskUiTest { // Given val user = createUserHelper() val state = createStateHelper() - val project = createProjectHelper(state = listOf(state)) + val project = createProjectHelper(taskState = listOf(state)) coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project coEvery { getCurrentUserUseCase.getCurrentUser() } returns user @@ -125,7 +125,7 @@ class CreateTaskUiTest { // Given val user = createUserHelper() val state = createStateHelper() - val project = createProjectHelper(state = listOf(state)) + val project = createProjectHelper(taskState = listOf(state)) coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project coEvery { getCurrentUserUseCase.getCurrentUser() } returns user @@ -186,7 +186,7 @@ class CreateTaskUiTest { // Given val user = createUserHelper() val state = createStateHelper() - val project = createProjectHelper(state = listOf(state)) + val project = createProjectHelper(taskState = listOf(state)) coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project coEvery { getCurrentUserUseCase.getCurrentUser() } returns user @@ -210,7 +210,7 @@ class CreateTaskUiTest { // Given val user = createUserHelper() val state = createStateHelper() - val project = createProjectHelper(state = listOf(state)) + val project = createProjectHelper(taskState = listOf(state)) coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project coEvery { getCurrentUserUseCase.getCurrentUser() } returns user @@ -233,7 +233,7 @@ class CreateTaskUiTest { // Given val user = createUserHelper() val state = createStateHelper() - val project = createProjectHelper(state = listOf(state)) + val project = createProjectHelper(taskState = listOf(state)) coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project coEvery { getCurrentUserUseCase.getCurrentUser() } returns user diff --git a/src/test/kotlin/ui/view/task/DeleteTaskUITest.kt b/src/test/kotlin/ui/view/task/DeleteTaskUITest.kt index a45a5a3e..0087294c 100644 --- a/src/test/kotlin/ui/view/task/DeleteTaskUITest.kt +++ b/src/test/kotlin/ui/view/task/DeleteTaskUITest.kt @@ -3,9 +3,9 @@ package ui.view.task import creator_helper.createTaskHelper import creator_helper.createUserHelper import domain.model.Task -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.task.DeleteTaskUseCase -import domain.use_case.task.GetProjectTasksUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.task.DeleteTaskUseCase +import domain.useCase.task.GetProjectTasksUseCase import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.AfterEach diff --git a/src/test/kotlin/ui/view/task/EditTaskUiTest.kt b/src/test/kotlin/ui/view/task/EditTaskUiTest.kt index ef1c77ee..9bae8e66 100644 --- a/src/test/kotlin/ui/view/task/EditTaskUiTest.kt +++ b/src/test/kotlin/ui/view/task/EditTaskUiTest.kt @@ -4,12 +4,11 @@ import creator_helper.createProjectHelper import creator_helper.createStateHelper import creator_helper.createTaskHelper import creator_helper.createUserHelper - import domain.model.Task -import domain.use_case.authentication.GetCurrentUserUseCase -import domain.use_case.project.GetProjectByIdUseCase -import domain.use_case.task.EditTaskUseCase -import domain.use_case.task.GetProjectTasksUseCase +import domain.useCase.authentication.GetCurrentUserUseCase +import domain.useCase.project.GetProjectByIdUseCase +import domain.useCase.task.EditTaskUseCase +import domain.useCase.task.GetProjectTasksUseCase import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.AfterEach @@ -20,22 +19,23 @@ import org.koin.core.context.GlobalContext.stopKoin import org.koin.dsl.module import ui.common.Printer import ui.common.Reader +import ui.common.exception.TaskEditFailedException import ui.common.exception.handler.ExceptionHandler import ui.common.exception.handler.SafeExecutor - import ui.view.user.mate.UserProjectsUi import java.util.* class EditTaskUiTest { private val printer: Printer = mockk(relaxed = true) - private val reader: Reader = mockk() - private val getCurrentUserUseCase: GetCurrentUserUseCase = mockk() - private val getProjectTasksUseCase: GetProjectTasksUseCase = mockk() - private val getProjectByIdUseCase: GetProjectByIdUseCase = mockk() + private val reader: Reader = mockk(relaxed = true) + private val getCurrentUserUseCase: GetCurrentUserUseCase = mockk(relaxed = true) + private val getProjectTasksUseCase: GetProjectTasksUseCase = mockk(relaxed = true) + private val getProjectByIdUseCase: GetProjectByIdUseCase = mockk(relaxed = true) private val editTaskUseCase: EditTaskUseCase = mockk(relaxed = true) private val exceptionHandler: ExceptionHandler = mockk(relaxed = true) private val executor: SafeExecutor = spyk() private val projectId = UUID.randomUUID() + private val user = createUserHelper(id = UUID.randomUUID()) private lateinit var editTaskUi: EditTaskUi @@ -70,29 +70,37 @@ class EditTaskUiTest { @Test fun `should edit task when valid inputs are provided`() = runTest { - // Given - val user = createUserHelper() + // Arrange val state1 = createStateHelper(name = "To Do") val state2 = createStateHelper(name = "In Progress") - val task = createTaskHelper(projectId = projectId, state = state1) + val task = createTaskHelper(projectId = projectId, taskState = state1) val tasks = listOf(task) - val project = createProjectHelper(id = projectId, state = listOf(state1, state2)) + val project = createProjectHelper(id = projectId, taskState = listOf(state1, state2)) + // Mocks for dependencies coEvery { getProjectTasksUseCase.getProjectTasks(projectId) } returns tasks coEvery { getCurrentUserUseCase.getCurrentUser() } returns user coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project - every { reader.readInput() } returnsMany listOf("1", "New Title", "New Description", "2") - // When + every { reader.readInt() } returnsMany listOf(1, 99) + every { reader.readInput() } returnsMany listOf("New Title", "New Description", "2") + + // Act editTaskUi.show() - // Then - coVerify { - editTaskUseCase.editTask(task, "New Title", "New Description", state2, user.id) - printer.printInfoLine("Task updated successfully!") - anyConstructed().show() + // Assert + coVerify(exactly = 1) { + editTaskUseCase.editTask( + match { it.id == task.id }, + "New Title", + "New Description", + match { it.name == "In Progress" }, + user.id + ) } + verify { printer.printInfoLine("Task updated successfully!") } + } @@ -116,22 +124,21 @@ class EditTaskUiTest { @Test fun `should return to projects screen for invalid task number`() = runTest { // Given - val user = createUserHelper() val state = createStateHelper() - val task = createTaskHelper(projectId = projectId, state = state) + val task = createTaskHelper(projectId = projectId, taskState = state) val tasks = listOf(task) coEvery { getProjectTasksUseCase.getProjectTasks(projectId) } returns tasks coEvery { getCurrentUserUseCase.getCurrentUser() } returns user - every { reader.readInput() } returns "99" + every { reader.readInt() } returns 99 // When editTaskUi.show() // Then verify { - printer.printError("Invalid input. Returning to the projects screen.") + printer.printError("Invalid option") } coVerify(exactly = 0) { @@ -142,26 +149,55 @@ class EditTaskUiTest { @Test fun `should return to projects screen for non-numeric task input`() = runTest { // Given - val user = createUserHelper() val state = createStateHelper() - val task = createTaskHelper(projectId = projectId, state = state) + val task = createTaskHelper(projectId = projectId, taskState = state) val tasks = listOf(task) coEvery { getProjectTasksUseCase.getProjectTasks(projectId) } returns tasks coEvery { getCurrentUserUseCase.getCurrentUser() } returns user // Non-numeric input - every { reader.readInput() } returns "abc" + every { reader.readInt() } returns null // When editTaskUi.show() // Then verify { - printer.printError("Invalid input. Returning to the projects screen.") + printer.printError("Invalid option") } } + @Test + fun `should handle exception during task edit`() = runTest { + // Given + val state = createStateHelper() + val task = createTaskHelper(projectId = projectId, taskState = state) + val tasks = listOf(task) + val project = createProjectHelper(id = projectId, taskState = listOf(state)) + val exception = TaskEditFailedException() + + coEvery { getProjectTasksUseCase.getProjectTasks(projectId) } returns tasks + coEvery { getCurrentUserUseCase.getCurrentUser() } returns user + coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project + coEvery { editTaskUseCase.editTask(any(), any(), any(), any(), any()) } throws exception + + every { reader.readInt() } returnsMany listOf(1, 99) + every { reader.readInput() } returnsMany listOf( + "New Title", + "New Description", + "1" + ) + + // When + editTaskUi.show() + + // Then + coVerify { exceptionHandler.printHandledError(exception) } + verify(exactly = 0) { printer.printInfoLine("Task updated successfully!") } + coVerify(exactly = 0) { UserProjectsUi().show() } + } + @Test fun `should handle exception during task fetch`() = runTest { // Given @@ -178,17 +214,8 @@ class EditTaskUiTest { @Test fun `should handle exception during project fetch`() = runTest { // Given - val user = createUserHelper() - val state = createStateHelper() - val task = createTaskHelper(projectId = projectId, state = state) - val tasks = listOf(task) - val exception = RuntimeException("Failed to fetch project") - - coEvery { getProjectTasksUseCase.getProjectTasks(projectId) } returns tasks - coEvery { getCurrentUserUseCase.getCurrentUser() } returns user - coEvery { getProjectByIdUseCase.getProjectById(projectId) } throws exception - - every { reader.readInput() } returns "1" + val exception = Exception() + coEvery { getProjectTasksUseCase.getProjectTasks(projectId) } throws exception // When editTaskUi.show() @@ -198,21 +225,25 @@ class EditTaskUiTest { } @Test - fun `should handle exception during task edit`() = runTest { + fun `should handle exception when calling getProjectById in editSelectedTask`() = runTest { // Given - val user = createUserHelper() val state = createStateHelper() - val task = createTaskHelper(projectId = projectId, state = state) + val task = createTaskHelper(projectId = projectId, taskState = state) val tasks = listOf(task) - val project = createProjectHelper(id = projectId, state = listOf(state)) - val exception = RuntimeException("Failed to edit task") + val exception = TaskEditFailedException() coEvery { getProjectTasksUseCase.getProjectTasks(projectId) } returns tasks coEvery { getCurrentUserUseCase.getCurrentUser() } returns user - coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project - coEvery { editTaskUseCase.editTask(any(), any(), any(), any(), any()) } throws exception + coEvery { + getProjectByIdUseCase.getProjectById(task.projectId) + } throws exception - every { reader.readInput() } returnsMany listOf("1", "New Title", "New Description", "1") + every { reader.readInt() } returnsMany listOf(1, 99) + every { reader.readInput() } returnsMany listOf( + "New Title", + "New Description", + "1" + ) // When editTaskUi.show() @@ -220,47 +251,53 @@ class EditTaskUiTest { // Then coVerify { exceptionHandler.printHandledError(exception) } } + @Test fun `should accept empty input for title and description`() = runTest { // Given - val user = createUserHelper() - val state = createStateHelper() - val task = createTaskHelper(projectId = projectId, state = state, title = "Original Title") + val state1 = createStateHelper(name = "To Do") + val state2 = createStateHelper(name = "In Progress") + val task = createTaskHelper(projectId = projectId, taskState = state1, title = "Original Title") val tasks = listOf(task) - val project = createProjectHelper(id = projectId, state = listOf(state)) + val project = createProjectHelper(id = projectId, taskState = listOf(state1, state2)) coEvery { getProjectTasksUseCase.getProjectTasks(projectId) } returns tasks coEvery { getCurrentUserUseCase.getCurrentUser() } returns user coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project - // Empty inputs for title and description - every { reader.readInput() } returnsMany listOf("1", "", "", "1") + every { reader.readInt() } returnsMany listOf(1, 99) + every { reader.readInput() } returnsMany listOf("", "", "2") // When editTaskUi.show() // Then coVerify { - editTaskUseCase.editTask(task, "", "", state, user.id) + editTaskUseCase.editTask( + task, + "", + "", + state2, + user.id + ) } } @Test fun `should change state when valid state number is provided`() = runTest { // Given - val user = createUserHelper() val state1 = createStateHelper(name = "To Do") val state2 = createStateHelper(name = "In Progress") - val task = createTaskHelper(projectId = projectId, state = state1) + val task = createTaskHelper(projectId = projectId, taskState = state1) val tasks = listOf(task) - val project = createProjectHelper(id = projectId, state = listOf(state1, state2)) + val project = createProjectHelper(id = projectId, taskState = listOf(state1, state2)) coEvery { getProjectTasksUseCase.getProjectTasks(projectId) } returns tasks coEvery { getCurrentUserUseCase.getCurrentUser() } returns user coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project - // Keep original title and description, change state - every { reader.readInput() } returnsMany listOf("1", task.title, task.description, "2") + every { reader.readInt() } returnsMany listOf(1, 99) + every { reader.readInput() } returnsMany listOf(task.title, task.description, "2") // When editTaskUi.show() @@ -270,21 +307,22 @@ class EditTaskUiTest { editTaskUseCase.editTask(task, task.title, task.description, state2, user.id) } } + @Test fun `should keep current state when state input is invalid`() = runTest { // Given - val user = createUserHelper() val state1 = createStateHelper(name = "To Do") val state2 = createStateHelper(name = "In Progress") - val task = createTaskHelper(projectId = projectId, state = state1) + val task = createTaskHelper(projectId = projectId, taskState = state1) val tasks = listOf(task) - val project = createProjectHelper(id = projectId, state = listOf(state1, state2)) + val project = createProjectHelper(id = projectId, taskState = listOf(state1, state2)) coEvery { getProjectTasksUseCase.getProjectTasks(projectId) } returns tasks coEvery { getCurrentUserUseCase.getCurrentUser() } returns user coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project - every { reader.readInput() } returnsMany listOf("1", "", "", "99") + every { reader.readInt() } returnsMany listOf(1, 99) + every { reader.readInput() } returnsMany listOf("", "", "99") // When editTaskUi.show() @@ -295,21 +333,22 @@ class EditTaskUiTest { editTaskUseCase.editTask(task, "", "", state1, user.id) } } + @Test fun `should keep current state when state input is non-numeric`() = runTest { // Given - val user = createUserHelper() val state1 = createStateHelper(name = "To Do") val state2 = createStateHelper(name = "In Progress") - val task = createTaskHelper(projectId = projectId, state = state1) + val task = createTaskHelper(projectId = projectId, taskState = state1) val tasks = listOf(task) - val project = createProjectHelper(id = projectId, state = listOf(state1, state2)) + val project = createProjectHelper(id = projectId, taskState = listOf(state1, state2)) coEvery { getProjectTasksUseCase.getProjectTasks(projectId) } returns tasks coEvery { getCurrentUserUseCase.getCurrentUser() } returns user coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project - every { reader.readInput() } returnsMany listOf("1", "", "", "abc") + every { reader.readInt() } returnsMany listOf(1, 99) + every { reader.readInput() } returnsMany listOf("", "", "abc") // When editTaskUi.show() @@ -320,21 +359,22 @@ class EditTaskUiTest { editTaskUseCase.editTask(task, "", "", state1, user.id) } } + @Test fun `should keep current state when state input is null`() = runTest { // Given - val user = createUserHelper() val state1 = createStateHelper(name = "To Do") val state2 = createStateHelper(name = "In Progress") - val task = createTaskHelper(projectId = projectId, state = state1) + val task = createTaskHelper(projectId = projectId, taskState = state1) val tasks = listOf(task) - val project = createProjectHelper(id = projectId, state = listOf(state1, state2)) + val project = createProjectHelper(id = projectId, taskState = listOf(state1, state2)) coEvery { getProjectTasksUseCase.getProjectTasks(projectId) } returns tasks coEvery { getCurrentUserUseCase.getCurrentUser() } returns user coEvery { getProjectByIdUseCase.getProjectById(projectId) } returns project - every { reader.readInput() } returnsMany listOf("1", "", "", null) + every { reader.readInt() } returnsMany listOf(1, 99) + every { reader.readInput() } returnsMany listOf("", "", null) // When editTaskUi.show() @@ -345,5 +385,4 @@ class EditTaskUiTest { editTaskUseCase.editTask(task, "", "", state1, user.id) } } - } \ No newline at end of file diff --git a/src/test/kotlin/ui/view/user/admin/log/project/ProjectLogsUiTest.kt b/src/test/kotlin/ui/view/user/admin/log/project/ProjectLogsUiTest.kt index 973655b1..98b396a7 100644 --- a/src/test/kotlin/ui/view/user/admin/log/project/ProjectLogsUiTest.kt +++ b/src/test/kotlin/ui/view/user/admin/log/project/ProjectLogsUiTest.kt @@ -3,8 +3,8 @@ package ui.view.user.admin.log.project import creator_helper.createProjectLogHelper import ui.common.exception.handler.ExceptionHandler import ui.common.exception.handler.SafeExecutor -import domain.use_case.authentication.GetUserByIdUseCase -import domain.use_case.log.GetAllProjectLogsUseCase +import domain.useCase.authentication.GetUserByIdUseCase +import domain.useCase.log.GetAllProjectLogsUseCase import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.BeforeEach diff --git a/src/test/kotlin/ui/view/user/admin/log/task/TaskLogUiTest.kt b/src/test/kotlin/ui/view/user/admin/log/task/TaskLogUiTest.kt index 8ae18aa6..e774af8e 100644 --- a/src/test/kotlin/ui/view/user/admin/log/task/TaskLogUiTest.kt +++ b/src/test/kotlin/ui/view/user/admin/log/task/TaskLogUiTest.kt @@ -1,7 +1,7 @@ package ui.view.user.admin.log.task import creator_helper.* -import domain.use_case.authentication.GetUserByIdUseCase +import domain.useCase.authentication.GetUserByIdUseCase import io.mockk.coEvery import io.mockk.mockk import io.mockk.verify @@ -135,8 +135,8 @@ class TaskLogUiTest{ val state2 = createStateHelper(name = "s2") - val currentTask = createTaskHelper(state = state1) - val previousTask = createTaskHelper(state = state2) + val currentTask = createTaskHelper(taskState = state1) + val previousTask = createTaskHelper(taskState = state2) val taskLog = createTaskLogHelper(previousEntity = previousTask , currentEntity = currentTask) val index = 0 diff --git a/src/test/kotlin/ui/view/user/admin/log/task/TaskLogsUiTest.kt b/src/test/kotlin/ui/view/user/admin/log/task/TaskLogsUiTest.kt index 37dc59e9..ec12a202 100644 --- a/src/test/kotlin/ui/view/user/admin/log/task/TaskLogsUiTest.kt +++ b/src/test/kotlin/ui/view/user/admin/log/task/TaskLogsUiTest.kt @@ -3,8 +3,8 @@ package ui.view.user.admin.log.task import creator_helper.createTaskLogHelper import ui.common.exception.handler.ExceptionHandler import ui.common.exception.handler.SafeExecutor -import domain.use_case.authentication.GetUserByIdUseCase -import domain.use_case.log.GetAllTaskLogsUseCase +import domain.useCase.authentication.GetUserByIdUseCase +import domain.useCase.log.GetAllTaskLogsUseCase import io.mockk.coEvery import io.mockk.coVerify import io.mockk.mockk diff --git a/src/test/kotlin/ui/view/user/mate/MateUiTest.kt b/src/test/kotlin/ui/view/user/mate/MateUiTest.kt index 63d27168..88b27a2d 100644 --- a/src/test/kotlin/ui/view/user/mate/MateUiTest.kt +++ b/src/test/kotlin/ui/view/user/mate/MateUiTest.kt @@ -9,13 +9,12 @@ import org.koin.core.context.stopKoin import org.koin.dsl.module import ui.common.Printer import ui.common.Reader - import kotlin.test.Test class MateUiTest { private val printer: Printer = mockk(relaxed = true) - private val reader: Reader = mockk() + private val reader: Reader = mockk(relaxed = true) private val userProjectsUI: UserProjectsUi = mockk(relaxed = true) private val mateUi = MateUi() @@ -55,29 +54,42 @@ class MateUiTest { } @Test - fun `test show - choose log out option`() = runTest { - // Arrange: mock the reader input for "Log out" option (option 2) + fun `should logout and return to the startup menu when chooses logout option`() = runTest { + // Given every { reader.readInt() } returns 2 - // Act: call the show method + // When mateUi.show() - // Assert: verify interactions with the printer and the goodbye message + // Then + coVerify(exactly = 0) { userProjectsUI.show() } verify { printer.printTitle("Welcome to Plan Mate") } - verify { printer.printInfoLine("Choose an option:") } verify { printer.printOptions("View Projects", "Log out") } - verify { printer.printGoodbyeMessage("Goodbye") } } @Test - fun `should not call user project ui screen when in reader input is wrong`() = runTest { + fun `should not call user project ui screen and print error message when choose invalid option`() = runTest { + // Given + every { reader.readInt() } returnsMany listOf(20, 2) + + // When + mateUi.show() + + // Then + verify { printer.printError("Invalid option") } + coVerify(exactly = 0) { userProjectsUI.show() } + } + + @Test + fun `should not call user project ui screen and print invalid option message when input is null`() = runTest { // Given - every { reader.readInt() } returns null + every { reader.readInt() } returnsMany listOf(null, 2) // When mateUi.show() // Then + verify { printer.printError("Invalid option") } coVerify(exactly = 0) { userProjectsUI.show() } } }