Create report mutation

.github/workflows/graphql-service-ci.yml

@@ -18,4 +18,4 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Run Gradle Test
-        run: ./gradlew test
+        run: ./gradlew test --info

pstatus-graphql-ktor/build.gradle

@@ -73,10 +73,6 @@ dependencies {
     testImplementation "io.ktor:ktor-server-tests-jvm:$ktor_version"
     testImplementation "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
 
-//    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
-//    testImplementation 'org.mockito:mockito-core:4.6.1'
-//    testImplementation 'org.mockito:mockito-junit-jupiter:4.6.1'
-
     testImplementation "org.junit.jupiter:junit-jupiter-api:5.8.1"
     testImplementation "org.junit.jupiter:junit-jupiter-engine:5.8.1"
     testImplementation "org.mockito:mockito-core:4.5.1"
@@ -108,4 +104,27 @@ jib {
     }
 }
 
+test {
+
+    // Discover and execute JUnit Platform-based (JUnit 5, JUnit Jupiter) tests
+    // JUnit 5 has the ability to execute JUnit 4 tests as well
+    useJUnitPlatform()
+
+    //Change this to "true" if we want to execute unit tests
+    systemProperty("isTestEnvironment", "false")
+
+    // Set the test classpath, if required
+}
+
+sourceSets {
+    main {
+        java {
+            srcDir 'src/kotlin'
+        }
+        resources {
+            srcDir 'src/resources'
+        }
+    }
+}
+
 

pstatus-graphql-ktor/src/main/kotlin/gov/cdc/ocio/processingstatusapi/Application.kt

@@ -26,6 +26,7 @@ fun KoinApplication.loadKoinModules(environment: ApplicationEnvironment): KoinAp
         // Create a CosmosDB config that can be dependency injected (for health checks)
         single(createdAtStart = true) { CosmosConfiguration(uri, authKey) }
     }
+
     return modules(listOf(cosmosModule))
 }
 
@@ -34,15 +35,20 @@ fun main(args: Array<String>) {
 }
 
 fun Application.module() {
-    graphQLModule()
-    configureRouting()
+
     install(Koin) {
         loadKoinModules(environment)
     }
+    graphQLModule()
+    configureRouting()
+
     install(ContentNegotiation) {
         jackson()
     }
 
+
+
+
     // See https://opensource.expediagroup.com/graphql-kotlin/docs/schema-generator/writing-schemas/scalars
     RuntimeWiring.newRuntimeWiring().scalar(ExtendedScalars.Date)
 }

pstatus-graphql-ktor/src/main/kotlin/gov/cdc/ocio/processingstatusapi/models/reports/ReportInputSchema.kt

@@ -0,0 +1,114 @@
+package gov.cdc.ocio.processingstatusapi.models.reports
+
+import com.expediagroup.graphql.generator.annotations.GraphQLDescription
+import gov.cdc.ocio.processingstatusapi.models.submission.Aggregation
+import gov.cdc.ocio.processingstatusapi.models.submission.Status
+import java.time.OffsetDateTime
+
+@GraphQLDescription("Input type for a key-value pair")
+data class KeyValueInput(
+    @GraphQLDescription("Key of the key-value pair")
+    val key: String,
+
+    @GraphQLDescription("Value of the key-value pair")
+    val value: String
+)
+
+@GraphQLDescription("Input type for creating or updating a report")
+data class ReportInput(
+    @GraphQLDescription("Identifier of the report recorded by the database")
+    val id: String? = null,
+
+    @GraphQLDescription("Upload identifier this report belongs to")
+    val uploadId: String? = null,
+
+    @GraphQLDescription("Unique report identifier")
+    val reportId: String? = null,
+
+    @GraphQLDescription("Data stream ID")
+    val dataStreamId: String? = null,
+
+    @GraphQLDescription("Data stream route")
+    val dataStreamRoute: String? = null,
+
+    @GraphQLDescription("Date/time of when the upload was first ingested into the data-exchange")
+    val dexIngestDateTime: OffsetDateTime? = null,
+
+    @GraphQLDescription("Message metadata")
+    val messageMetadata: MessageMetadataInput? = null,
+
+    @GraphQLDescription("Stage info")
+    val stageInfo: StageInfoInput? = null,
+
+    @GraphQLDescription("Tags associated with the report")
+    val tags: List<KeyValueInput>? = null,
+
+    @GraphQLDescription("Data associated with the report")
+    val data: List<KeyValueInput>? = null,
+
+    @GraphQLDescription("Indicates the content type of the content; e.g. JSON, XML")
+    val contentType: String? = null,
+
+    @GraphQLDescription("Jurisdiction report belongs to; set to null if not applicable")
+    val jurisdiction: String? = null,
+
+    @GraphQLDescription("Sender ID this report belongs to; set to null if not applicable")
+    val senderId: String? = null,
+
+    @GraphQLDescription("Data Producer ID stated in the report; set to null if not applicable")
+    val dataProducerId: String? = null,
+
+    @GraphQLDescription("Content of the report. If the report is JSON then the content will be shown as JSON. Otherwise, the content is a base64 encoded string.")
+    val content: List<KeyValueInput>? = null,
+
+    @GraphQLDescription("Timestamp when the report was recorded in the database")
+    val timestamp: OffsetDateTime? = null
+)
+
+@GraphQLDescription("Input type for message metadata")
+data class MessageMetadataInput(
+    @GraphQLDescription("Unique Identifier for that message")
+    val messageUUID: String? = null,
+
+    @GraphQLDescription("MessageHash value")
+    val messageHash: String? = null,
+
+    @GraphQLDescription("Single or Batch message")
+    val aggregation: Aggregation? = null,
+
+    @GraphQLDescription("Message Index")
+    val messageIndex: Int? = null
+)
+
+@GraphQLDescription("Input type for stage info")
+data class StageInfoInput(
+    @GraphQLDescription("Service")
+    val service: String? = null,
+
+    @GraphQLDescription("Stage name a.k.a action")
+    val action: String? = null,
+
+    @GraphQLDescription("Version")
+    val version: String? = null,
+
+    @GraphQLDescription("Status- SUCCESS OR FAILURE")
+     val status: Status? = null,
+
+    @GraphQLDescription("Issues array")
+    val issues: List<IssueInput>? = null,
+
+    @GraphQLDescription("Start processing time")
+    val startProcessingTime: OffsetDateTime? = null,
+
+    @GraphQLDescription("End processing time")
+    val endProcessingTime: OffsetDateTime? = null
+)
+
+@GraphQLDescription("Input type for issues")
+data class IssueInput(
+    @GraphQLDescription("Issue code")
+    val code: String? = null,
+
+    @GraphQLDescription("Issue description")
+    val description: String? = null
+)

pstatus-graphql-ktor/src/main/kotlin/gov/cdc/ocio/processingstatusapi/mutations/ReportMutation.kt

@@ -0,0 +1,139 @@
+package gov.cdc.ocio.processingstatusapi.mutations
+
+import com.azure.cosmos.models.CosmosItemRequestOptions
+import com.azure.cosmos.models.CosmosItemResponse
+import com.azure.cosmos.models.PartitionKey
+import gov.cdc.ocio.processingstatusapi.exceptions.BadRequestException
+import gov.cdc.ocio.processingstatusapi.exceptions.BadStateException
+import gov.cdc.ocio.processingstatusapi.exceptions.ContentException
+import gov.cdc.ocio.processingstatusapi.loaders.CosmosLoader
+import gov.cdc.ocio.processingstatusapi.models.Report
+import gov.cdc.ocio.processingstatusapi.models.reports.IssueInput
+import gov.cdc.ocio.processingstatusapi.models.reports.MessageMetadataInput
+import gov.cdc.ocio.processingstatusapi.models.reports.ReportInput
+import gov.cdc.ocio.processingstatusapi.models.reports.StageInfoInput
+import gov.cdc.ocio.processingstatusapi.models.submission.Issue
+import gov.cdc.ocio.processingstatusapi.models.submission.Level
+import gov.cdc.ocio.processingstatusapi.models.submission.MessageMetadata
+import gov.cdc.ocio.processingstatusapi.models.submission.StageInfo
+
+class ReportMutation() : CosmosLoader() {
+
+    /**
+     * Mutation for creating or replacing a report based on the provided action.
+     *
+     * @param input ReportInput
+     * @param action Specifies whether to create or replace the report. Can be "create" or "replace".
+     * @return Report
+     * @throws BadRequestException
+     * @throws ContentException
+     * @throws BadStateException
+     */
+    fun upsertReport(input: ReportInput, action: String): Report? {
+        logger.info("ReportId, id = ${input.id}, action = $action")
+
+        return try {
+            performUpsert(input, action)
+        } catch (e: Exception) {
+            logger.error("Error upserting report: ${e.message}", e)
+            null
+        }
+    }
+
+    private fun performUpsert(input: ReportInput, action: String): Report? {
+        // Validate action parameter
+        if (action !in listOf("create", "replace")) {
+            throw BadRequestException("Invalid action specified: $action. Must be 'create' or 'replace'.")
+        }
+
+        val report = mapInputToReport(input)
+
+        when (action) {
+            "create" -> {
+                if (!report.id.isNullOrBlank()) {
+                    throw BadRequestException("ID should not be provided for create action.")
+                }
+
+                // Generate a new ID if not provided
+                report.id = generateNewId()
+                val options = CosmosItemRequestOptions()
+                val createResponse: CosmosItemResponse<Report>? = reportsContainer?.createItem(report, PartitionKey(report.uploadId!!), options)
+                return createResponse?.item
+            }
+            "replace" -> {
+                if (report.id.isNullOrBlank()) {
+                    throw BadRequestException("ID must be provided for replace action.")
+                }
+
+                // Attempt to read the existing item
+                val readResponse: CosmosItemResponse<Report>? = reportsContainer?.readItem(report.id!!, PartitionKey(report.uploadId!!), Report::class.java)
+
+                if (readResponse != null) {
+                    // Replace the existing item
+                    val options = CosmosItemRequestOptions()
+                    val replaceResponse: CosmosItemResponse<Report>? = reportsContainer?.replaceItem(report, report.id!!, PartitionKey(report.uploadId!!), options)
+                    return replaceResponse?.item
+                } else {
+                    throw BadRequestException("Report with ID ${report.id} not found for replacement.")
+                }
+            }
+            else -> {
+                throw BadRequestException("Unexpected action: $action")
+            }
+        }
+    }
+
+    private fun mapInputToReport(input: ReportInput): Report {
+        return Report(
+            id = input.id,
+            uploadId = input.uploadId,
+            reportId = input.reportId,
+            dataStreamId = input.dataStreamId,
+            dataStreamRoute = input.dataStreamRoute,
+            dexIngestDateTime = input.dexIngestDateTime,
+            messageMetadata = input.messageMetadata?.let { mapInputToMessageMetadata(it) },
+            stageInfo = input.stageInfo?.let { mapInputToStageInfo(it) },
+            tags = input.tags?.associate { it.key to it.value },
+            data = input.data?.associate { it.key to it.value },
+            contentType = input.contentType,
+            jurisdiction = input.jurisdiction,
+            senderId = input.senderId,
+            dataProducerId = input.dataProducerId,
+            content = input.content?.associate { it.key to it.value },
+            timestamp = input.timestamp
+        )
+    }
+
+    private fun mapInputToMessageMetadata(input: MessageMetadataInput): MessageMetadata {
+        return MessageMetadata(
+            messageUUID = input.messageUUID,
+            messageHash = input.messageHash,
+            aggregation = input.aggregation,
+            messageIndex = input.messageIndex
+        )
+    }
+
+    private fun mapInputToStageInfo(input: StageInfoInput): StageInfo {
+        return StageInfo(
+            service = input.service,
+            action = input.action,
+            version = input.version,
+            status = input.status,
+            issues = input.issues?.map { mapInputToIssue(it) },
+            startProcessingTime = input.startProcessingTime,
+            endProcessingTime = input.endProcessingTime
+        )
+    }
+
+    private fun mapInputToIssue(input: IssueInput): Issue {
+        return Issue(
+            level = input.code?.let { Level.valueOf(it) },
+            message = input.description
+        )
+    }
+
+    private fun generateNewId(): String {
+        // Implement your logic to generate a new unique ID
+        return java.util.UUID.randomUUID().toString()
+    }
+}

pstatus-graphql-ktor/src/main/kotlin/gov/cdc/ocio/processingstatusapi/mutations/ReportMutationService.kt

@@ -0,0 +1,26 @@
+package gov.cdc.ocio.processingstatusapi.mutations
+
+import com.expediagroup.graphql.generator.annotations.GraphQLDescription
+import com.expediagroup.graphql.server.operations.Mutation
+import gov.cdc.ocio.processingstatusapi.models.reports.ReportInput
+
+@GraphQLDescription("A Mutation Service to either create a new report or replace an existing report")
+class ReportMutationService() : Mutation {
+
+    @GraphQLDescription("Create upload")
+    @Suppress("unused")
+    fun upsertReport(
+        @GraphQLDescription(
+            "*Report Input* to be created or updated:\n"
+        )
+        input: ReportInput,
+        @GraphQLDescription(
+            "*Action*: Can be one of the following values\n"
+                    + "`create`: Create new report\n"
+                    + "`replace`: Replace existing report\n"
+        )
+        action: String,
+        ) = ReportMutation().upsertReport(input, action)
+
+
+}

pstatus-graphql-ktor/src/main/kotlin/gov/cdc/ocio/processingstatusapi/plugins/GraphQL.kt

@@ -7,6 +7,8 @@ import com.expediagroup.graphql.server.ktor.*
 import gov.cdc.ocio.processingstatusapi.dataloaders.ReportDataLoader
 import gov.cdc.ocio.processingstatusapi.dataloaders.ReportDeadLetterDataLoader
 import gov.cdc.ocio.processingstatusapi.mutations.NotificationsMutationService
+import gov.cdc.ocio.processingstatusapi.mutations.ReportMutation
+import gov.cdc.ocio.processingstatusapi.mutations.ReportMutationService
 import gov.cdc.ocio.processingstatusapi.queries.*
 import io.ktor.http.*
 import io.ktor.serialization.jackson.*
@@ -21,6 +23,7 @@ import io.ktor.server.websocket.*
 import mu.KotlinLogging
 import java.time.Duration
 import java.util.*
+import org.koin.ktor.ext.inject
 
 
 /**
@@ -80,6 +83,9 @@ fun Application.graphQLModule() {
 //    install(CORS) {
 //        anyHost()
 //    }
+
+//    val reportMutation by inject<ReportMutation>() // Inject ReportMutation from Koin
+
     install(GraphQL) {
         schema {
             packages = listOf("gov.cdc.ocio.processingstatusapi")
@@ -92,7 +98,8 @@ fun Application.graphQLModule() {
 
             )
             mutations= listOf(
-                NotificationsMutationService()
+                NotificationsMutationService(),
+                ReportMutationService()
             )
 //            subscriptions = listOf(
 //                ErrorSubscriptionService()