Updated tool dto code to be more consistent

src/main/kotlin/de/fraunhofer/iem/dataprovider/tool/controller/ToolController.kt

 package de.fraunhofer.iem.dataprovider.tool.controller
 
 import de.fraunhofer.iem.dataprovider.configuration.ApiPaths
-import de.fraunhofer.iem.dataprovider.tool.dto.ToolEntityResponseDto
+import de.fraunhofer.iem.dataprovider.tool.dto.ToolDto
 import de.fraunhofer.iem.dataprovider.tool.repository.ToolRepository
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.RestController
@@ -10,7 +10,7 @@ import org.springframework.web.bind.annotation.RestController
 class ToolController(val toolRepository: ToolRepository) {
 
     @GetMapping(ApiPaths.GET_ALL_TOOLS)
-    fun getAllTools(): List<ToolEntityResponseDto> {
+    fun getAllTools(): List<ToolDto> {
         return toolRepository.findAll().map { it.toDto() }
     }
 }

src/main/kotlin/de/fraunhofer/iem/dataprovider/tool/dto/ToolResponseDto.kt → src/main/kotlin/de/fraunhofer/iem/dataprovider/tool/dto/ToolDto.kt

 package de.fraunhofer.iem.dataprovider.tool.dto
 
-data class ToolResponseDto(
+import de.fraunhofer.iem.dataprovider.tool.enumeration.ToolType
+
+data class ToolDto(
     val name: String,
     val description: String,
     val relevantKpis: List<String>,
-    val findings: List<FindingDto> = emptyList()
+    val findings: MutableList<FindingDto> = mutableListOf(),
+    val toolType: ToolType
 )

src/main/kotlin/de/fraunhofer/iem/dataprovider/tool/dto/ToolEntityResponseDto.kt

-package de.fraunhofer.iem.dataprovider.tool.dto
-
-import java.util.*
-
-data class ToolEntityResponseDto(val id: UUID, val name: String, val toolType: String)

src/main/kotlin/de/fraunhofer/iem/dataprovider/tool/entity/ToolEntity.kt

 package de.fraunhofer.iem.dataprovider.tool.entity
 
-import de.fraunhofer.iem.dataprovider.tool.dto.ToolEntityResponseDto
+import de.fraunhofer.iem.dataprovider.tool.dto.ToolDto
 import de.fraunhofer.iem.dataprovider.tool.enumeration.ToolType
 import jakarta.persistence.*
 import org.hibernate.Hibernate
@@ -21,8 +21,8 @@ class ToolEntity(
     var toolType: ToolType,
 ) {
 
-    fun toDto(): ToolEntityResponseDto {
-        return ToolEntityResponseDto(this.id!!, this.name, this.toolType.getName())
+    fun toDto(): ToolDto {
+        return toolType.toViewModel()
     }
 
     override fun equals(other: Any?): Boolean {

src/main/kotlin/de/fraunhofer/iem/dataprovider/tool/enumeration/ToolType.kt

 package de.fraunhofer.iem.dataprovider.tool.enumeration
 
 import de.fraunhofer.iem.dataprovider.kpi.enumeration.KpiKind
-import de.fraunhofer.iem.dataprovider.tool.dto.FindingDto
-import de.fraunhofer.iem.dataprovider.tool.dto.ToolResponseDto
+import de.fraunhofer.iem.dataprovider.tool.dto.ToolDto
 
 enum class ToolType {
     ORT {
-        override fun toViewModel(findings: List<FindingDto>): ToolResponseDto {
-            return ToolResponseDto(
+        override fun toViewModel(): ToolDto {
+            return ToolDto(
                 name = this.getName(),
-                findings = findings,
                 relevantKpis = listOf(
                     KpiKind.MAXIMAL_VULNERABILITY.getName(),
                     KpiKind.VULNERABILITY_SCORE.getName(),
                     KpiKind.SECURITY.getName()
                 ),
                 description = "The OSS Review Toolkit (ORT) provides information about dependencies." +
-                    "For more information see https://github.com/oss-review-toolkit/ort."
+                    "For more information see https://github.com/oss-review-toolkit/ort.",
+                toolType = ORT
             )
         }
 
@@ -25,10 +24,9 @@ enum class ToolType {
         }
     },
     OCCMD {
-        override fun toViewModel(findings: List<FindingDto>): ToolResponseDto {
-            return ToolResponseDto(
+        override fun toViewModel(): ToolDto {
+            return ToolDto(
                 name = this.getName(),
-                findings = findings,
                 relevantKpis = listOf(
                     KpiKind.SECURITY.getName(),
                     KpiKind.PROCESS_TRANSPARENCY.getName(),
@@ -40,7 +38,9 @@ enum class ToolType {
                     KpiKind.CHECKED_IN_BINARIES.getName()
                 ),
                 description = "The OCCMD provides various information about the analyzed project." +
-                    "For more information see https://gitlab.opencode.de/opencode-analyzer/occmd-public."
+                    "For more information see https://gitlab.opencode.de/opencode-analyzer/occmd-public.",
+                toolType = OCCMD
+
             )
         }
 
@@ -49,10 +49,9 @@ enum class ToolType {
         }
     },
     Gitlab {
-        override fun toViewModel(findings: List<FindingDto>): ToolResponseDto {
-            return ToolResponseDto(
+        override fun toViewModel(): ToolDto {
+            return ToolDto(
                 name = this.getName(),
-                findings = findings,
                 relevantKpis = listOf(
                     KpiKind.PROCESS_TRANSPARENCY.getName(),
                     KpiKind.PROCESS_COMPLIANCE.getName(),
@@ -61,7 +60,8 @@ enum class ToolType {
                     KpiKind.DOCUMENTATION.getName(),
                 ),
                 description = "The Gitlab API is used to derive information about, e.g., the project's compliance" +
-                    "to OpenCoDE's platform rules."
+                    "to OpenCoDE's platform rules.",
+                toolType = Gitlab
             )
         }
 
@@ -70,6 +70,6 @@ enum class ToolType {
         }
     };
 
-    abstract fun toViewModel(findings: List<FindingDto> = emptyList()): ToolResponseDto
+    abstract fun toViewModel(): ToolDto
     abstract fun getName(): String
 }

src/main/kotlin/de/fraunhofer/iem/dataprovider/toolRun/dto/ToolRunDto.kt

 package de.fraunhofer.iem.dataprovider.toolRun.dto
 
-import de.fraunhofer.iem.dataprovider.tool.dto.ToolResponseDto
+import de.fraunhofer.iem.dataprovider.tool.dto.ToolDto
 import de.fraunhofer.iem.dataprovider.toolRun.entity.ToolRunEntity
 import java.util.*
 
@@ -8,17 +8,17 @@ data class ToolRunDto(
     val id: UUID,
     val createdAt: String,
     val projectId: Long,
-    val tools: List<ToolResponseDto>,
+    val tools: List<ToolDto>,
     val languages: Set<LanguageDto> = emptySet()
 ) {
     companion object {
-        fun getDtoFromEntityWithToolFindings(toolRunEntity: ToolRunEntity, tools: List<ToolResponseDto>): ToolRunDto {
+        fun getDtoFromEntity(toolRunEntity: ToolRunEntity): ToolRunDto {
             if (toolRunEntity.id != null) {
                 return ToolRunDto(
                     id = toolRunEntity.id!!,
                     createdAt = toolRunEntity.createdAt.toString(),
                     projectId = toolRunEntity.repository.projectId,
-                    tools = tools,
+                    tools = toolRunEntity.toolEntities.map { it.toDto() },
                     languages = toolRunEntity.languageEntities.map {
                         LanguageDto(name = it.name, percentage = it.percentage)
                     }.toSet()

src/main/kotlin/de/fraunhofer/iem/dataprovider/toolRun/service/ToolRunDbService.kt

@@ -5,6 +5,7 @@ import de.fraunhofer.iem.dataprovider.repository.dto.RepositoryCreateDto
 import de.fraunhofer.iem.dataprovider.repository.service.RepositoryService
 import de.fraunhofer.iem.dataprovider.tool.dto.CreateToolDto
 import de.fraunhofer.iem.dataprovider.tool.service.ToolService
+import de.fraunhofer.iem.dataprovider.toolRun.dto.ToolRunDto
 import de.fraunhofer.iem.dataprovider.toolRun.entity.LanguageEntity
 import de.fraunhofer.iem.dataprovider.toolRun.entity.ToolRunEntity
 import de.fraunhofer.iem.dataprovider.toolRun.repository.ToolRunRepository
@@ -18,7 +19,6 @@ class ToolRunDbService(
     private val toolService: ToolService
 ) {
 
-
     @Transactional
     fun createToolRun(
         repoDto: RepositoryCreateDto,
@@ -56,7 +56,9 @@ class ToolRunDbService(
 
     //TODO: this should return a create tool run dto
     @Transactional(readOnly = true)
-    fun getToolRunByProjectId(projectId: Long): ToolRunEntity {
-        return toolRunRepository.findFirstByRepository_ProjectIdOrderByCreatedAtDesc(projectId)
+    fun getToolRunByProjectId(projectId: Long): ToolRunDto {
+        return ToolRunDto.getDtoFromEntity(
+            toolRunRepository.findFirstByRepository_ProjectIdOrderByCreatedAtDesc(projectId)
+        )
     }
 }

src/main/kotlin/de/fraunhofer/iem/dataprovider/toolRun/service/ToolRunService.kt

@@ -3,7 +3,6 @@ package de.fraunhofer.iem.dataprovider.toolRun.service
 import de.fraunhofer.iem.dataprovider.kpi.service.KPIService
 import de.fraunhofer.iem.dataprovider.logger.getLogger
 import de.fraunhofer.iem.dataprovider.repository.service.RepositoryService
-import de.fraunhofer.iem.dataprovider.tool.dto.ToolResponseDto
 import de.fraunhofer.iem.dataprovider.tool.enumeration.ToolType
 import de.fraunhofer.iem.dataprovider.toolRun.dto.ToolRunDto
 import de.fraunhofer.iem.dataprovider.tools.gitlab.service.RepositoryDetailsService
@@ -124,51 +123,40 @@ class ToolRunService(
         dispatcher: CoroutineDispatcher = Dispatchers.IO,
         includeFindings: Boolean = false
     ): ToolRunDto {
-        val toolRunEntity = toolRunDbService.getToolRunByProjectId(projectId = projectId)
+        val toolRun = withContext(dispatcher) {
+            toolRunDbService.getToolRunByProjectId(projectId = projectId)
+        }
 
-        val apiJobs: MutableList<Deferred<ToolResponseDto>> = mutableListOf()
+        val apiJobs: MutableList<Job> = mutableListOf()
 
         if (includeFindings) {
-            toolRunEntity.toolEntities.forEach { tool ->
+            toolRun.tools.forEach { tool ->
                 when (tool.toolType) {
                     ToolType.ORT -> {
                         apiJobs.add(
-                            defaultScope.async {
+                            defaultScope.launch {
                                 val rawOrtResult = ortService.getOrtResults(projectId = projectId)
                                 val findings = ortService.getFindings(rawOrtResult)
-                                tool.toolType.toViewModel(findings = findings)
+                                tool.findings.addAll(findings)
                             }
                         )
                     }
 
                     else -> {
-                        apiJobs.add(
-                            defaultScope.async {
-                                tool.toolType.toViewModel()
-                            }
-                        )
+                        logger.info("No findings to retrieve for tool ${tool.toolType}")
                     }
                 }
             }
-        } else {
-            toolRunEntity.toolEntities.forEach { tool ->
-                apiJobs.add(
-                    defaultScope.async {
-                        tool.toolType.toViewModel()
-                    }
-                )
-            }
         }
 
-        val tools = apiJobs.mapNotNull {
+        apiJobs.forEach {
             try {
-                it.await()
+                it.join()
             } catch (exception: Exception) {
                 logger.error("API job failed with error $exception")
-                null
             }
         }
 
-        return ToolRunDto.getDtoFromEntityWithToolFindings(toolRunEntity, tools)
+        return toolRun
     }
 }