Pivotal #ID 176479720: Mongo Metadata Query

submission/persistence-mongo/src/main/kotlin/ac/uk/ebi/biostd/persistence/doc/db/repositories/SubmissionMongoRepository.kt

@@ -7,6 +7,8 @@ import org.springframework.data.mongodb.repository.Query
 
 interface SubmissionMongoRepository : MongoRepository<DocSubmission, String> {
 
+    fun findByAccNo(accNo: String): DocSubmission?
+
     fun existsByAccNo(accNo: String): Boolean
 
     fun getByAccNo(accNo: String): DocSubmission
@@ -15,6 +17,10 @@ interface SubmissionMongoRepository : MongoRepository<DocSubmission, String> {
 
     fun getByAccNoAndVersionGreaterThan(accNo: String, version: Int): List<DocSubmission>
 
+    fun findFirstByAccNoOrderByVersionDesc(accNo: String): DocSubmission?
+
+    fun getFirstByAccNo(accNo: String): DocSubmission
+
     @Query(value = "{ 'groupId' :  ?0 }", fields = "{ '_id': 0, 'user.\$id':1 }")
     fun findAllUserIdByGroupId(accNo: String): List<String?>?
 }

submission/persistence-mongo/src/main/kotlin/ac/uk/ebi/biostd/persistence/doc/integration/MongoDbReposConfig.kt

@@ -29,5 +29,7 @@ class MongoDbReposConfig {
     ): SubmissionRequestDocDataRepository = SubmissionRequestDocDataRepository(submissionRequestRepository)
 
     @Bean
-    internal fun submissionMetaQueryService(): SubmissionMongoMetaQueryService = SubmissionMongoMetaQueryService()
+    internal fun submissionMongoMetaQueryService(
+        submissionDocDataRepository: SubmissionDocDataRepository
+    ): SubmissionMongoMetaQueryService = SubmissionMongoMetaQueryService(submissionDocDataRepository)
 }

submission/persistence-mongo/src/main/kotlin/ac/uk/ebi/biostd/persistence/doc/service/SubmissionMongoMetaQueryService.kt

@@ -3,21 +3,74 @@ package ac.uk.ebi.biostd.persistence.doc.service
 import ac.uk.ebi.biostd.persistence.common.model.BasicProject
 import ac.uk.ebi.biostd.persistence.common.model.BasicSubmission
 import ac.uk.ebi.biostd.persistence.common.service.SubmissionMetaQueryService
+import ac.uk.ebi.biostd.persistence.doc.db.data.SubmissionDocDataRepository
+import ac.uk.ebi.biostd.persistence.doc.model.DocProcessingStatus
+import ac.uk.ebi.biostd.persistence.doc.model.DocSubmission
+import ac.uk.ebi.biostd.persistence.doc.model.DocSubmissionMethod
+import ac.uk.ebi.biostd.persistence.exception.ProjectNotFoundException
+import ac.uk.ebi.biostd.persistence.exception.ProjectWithoutPatternException
+import ebi.ac.uk.model.SubmissionMethod
+import ebi.ac.uk.model.constants.ProcessingStatus
+import ebi.ac.uk.model.constants.SubFields.ACC_NO_TEMPLATE
+import java.time.ZoneOffset
+
+class SubmissionMongoMetaQueryService(
+    private val submissionDocDataRepository: SubmissionDocDataRepository
+) : SubmissionMetaQueryService {
 
-class SubmissionMongoMetaQueryService : SubmissionMetaQueryService {
     override fun getBasicProject(accNo: String): BasicProject {
-        TODO("Not yet implemented")
+        val projectDb: DocSubmission? = submissionDocDataRepository.findByAccNo(accNo)
+        require(projectDb != null) { throw ProjectNotFoundException(accNo) }
+
+        val projectPattern = projectDb.attributes.firstOrNull { it.name == ACC_NO_TEMPLATE.value }?.value
+            ?: throw ProjectWithoutPatternException(accNo)
+
+        return BasicProject(projectDb.accNo, projectPattern, projectDb.releaseTime?.atOffset(ZoneOffset.UTC))
     }
 
     override fun findLatestBasicByAccNo(accNo: String): BasicSubmission? {
-        return null
+        return submissionDocDataRepository.findFirstByAccNoOrderByVersionDesc(accNo)?.asBasicSubmission()
     }
 
     override fun getAccessTags(accNo: String): List<String> {
         return emptyList()
     }
 
-    override fun existByAccNo(accNo: String): Boolean {
-        return false
+    override fun existByAccNo(accNo: String): Boolean =
+        submissionDocDataRepository.existsByAccNo(accNo)
+
+    companion object {
+
+        private fun DocProcessingStatus.toProcessingStatus(): ProcessingStatus {
+            return when (this) {
+                DocProcessingStatus.PROCESSED -> ProcessingStatus.PROCESSED
+                DocProcessingStatus.PROCESSING -> ProcessingStatus.PROCESSING
+                DocProcessingStatus.REQUESTED -> ProcessingStatus.REQUESTED
+            }
+        }
+
+        private fun DocSubmissionMethod.toSubmissionMethod(): SubmissionMethod {
+            return when (this) {
+                DocSubmissionMethod.FILE -> SubmissionMethod.FILE
+                DocSubmissionMethod.PAGE_TAB -> SubmissionMethod.PAGE_TAB
+                DocSubmissionMethod.UNKNOWN -> SubmissionMethod.UNKNOWN
+            }
+        }
+
+        fun DocSubmission.asBasicSubmission(): BasicSubmission {
+            return BasicSubmission(
+                accNo = accNo,
+                version = version,
+                secretKey = secretKey,
+                title = title,
+                relPath = relPath,
+                released = released,
+                creationTime = creationTime.atOffset(ZoneOffset.UTC),
+                modificationTime = modificationTime.atOffset(ZoneOffset.UTC),
+                releaseTime = releaseTime?.atOffset(ZoneOffset.UTC),
+                status = status.toProcessingStatus(),
+                method = method.toSubmissionMethod(),
+                owner = owner)
+        }
     }
 }

submission/persistence-mongo/src/test/kotlin/ac/uk/ebi/biostd/persistence/doc/db/data/SubmissionDocDataRepositoryTest.kt

@@ -38,23 +38,41 @@ internal class SubmissionDocDataRepositoryTest {
     inner class UpdateStatus {
         @Test
         fun `successful status update`() {
-            submissionMongoRepository.save(testDocSubmission("accNo1", 1, PROCESSING))
+            submissionMongoRepository.save(testDocSubmission("accNo10", 1, PROCESSING))
 
-            testInstance.updateStatus(PROCESSED, "accNo1", 1)
+            testInstance.updateStatus(PROCESSED, "accNo10", 1)
 
-            assertThat(submissionMongoRepository.getByAccNo("accNo1").status).isEqualTo(PROCESSED)
+            assertThat(submissionMongoRepository.getByAccNo("accNo10").status).isEqualTo(PROCESSED)
         }
 
         @Test
         fun `status should not be updated when version does not match`() {
-            submissionMongoRepository.save(testDocSubmission("accNo2", 1, PROCESSING))
+            submissionMongoRepository.save(testDocSubmission("accNo20", 1, PROCESSING))
 
-            testInstance.updateStatus(PROCESSED, "accNo2", 3)
+            testInstance.updateStatus(PROCESSED, "accNo20", 3)
 
-            assertThat(submissionMongoRepository.getByAccNo("accNo2").status).isEqualTo(PROCESSING)
+            assertThat(submissionMongoRepository.getByAccNo("accNo20").status).isEqualTo(PROCESSING)
         }
     }
 
+    @Test
+    fun `successful status update`() {
+        submissionMongoRepository.save(testDocSubmission("accNo1", 1, PROCESSING))
+
+        testInstance.updateStatus(PROCESSED, "accNo1", 1)
+
+        assertThat(submissionMongoRepository.getByAccNo("accNo1").status).isEqualTo(PROCESSED)
+    }
+
+    @Test
+    fun `status update when version does not match so do not update`() {
+        submissionMongoRepository.save(testDocSubmission("accNo2", 1, PROCESSING))
+
+        testInstance.updateStatus(PROCESSED, "accNo2", 3)
+
+        assertThat(submissionMongoRepository.getByAccNo("accNo2").status).isEqualTo(PROCESSING)
+    }
+
     @Test
     fun getCurrentVersion() {
         submissionMongoRepository.save(testDocSubmission("accNo3", -1, PROCESSED))

submission/persistence-mongo/src/test/kotlin/ac/uk/ebi/biostd/persistence/doc/service/SubmissionMongoMetaQueryServiceTest.kt

@@ -0,0 +1,123 @@
+package ac.uk.ebi.biostd.persistence.doc.service
+
+import ac.uk.ebi.biostd.persistence.doc.db.repositories.SubmissionMongoRepository
+import ac.uk.ebi.biostd.persistence.doc.integration.MongoDbReposConfig
+import ac.uk.ebi.biostd.persistence.doc.model.DocAttribute
+import ac.uk.ebi.biostd.persistence.doc.model.DocProcessingStatus
+import ac.uk.ebi.biostd.persistence.doc.model.DocSection
+import ac.uk.ebi.biostd.persistence.doc.model.DocSubmission
+import ac.uk.ebi.biostd.persistence.doc.model.DocSubmissionMethod
+import ebi.ac.uk.model.constants.SubFields
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.test.context.DynamicPropertyRegistry
+import org.springframework.test.context.DynamicPropertySource
+import org.springframework.test.context.junit.jupiter.SpringExtension
+import org.testcontainers.containers.MongoDBContainer
+import org.testcontainers.junit.jupiter.Container
+import org.testcontainers.junit.jupiter.Testcontainers
+import org.testcontainers.utility.DockerImageName
+import java.time.Instant
+
+@ExtendWith(SpringExtension::class)
+@Testcontainers
+@SpringBootTest(classes = [MongoDbReposConfig::class])
+internal class SubmissionMongoMetaQueryServiceTest {
+
+    @Autowired
+    lateinit var testInstance: SubmissionMongoMetaQueryService
+
+    @Autowired
+    lateinit var submissionMongoRepository: SubmissionMongoRepository
+
+    @Test
+    fun getBasicProject() {
+        submissionMongoRepository.save(testDocSubmission(
+            accNo = "accNo1",
+            version = 1,
+            status = DocProcessingStatus.PROCESSED,
+            attributes = listOf(DocAttribute(SubFields.ACC_NO_TEMPLATE.value, "template"))
+        ))
+
+        val result = testInstance.getBasicProject("accNo1")
+
+        assertThat(result.accNo).isEqualTo("accNo1")
+    }
+
+    @Test
+    fun findLatestBasicByAccNo() {
+        submissionMongoRepository.save(testDocSubmission("accNo2", 1, DocProcessingStatus.PROCESSED))
+        submissionMongoRepository.save(testDocSubmission("accNo2", -2, DocProcessingStatus.PROCESSED))
+        submissionMongoRepository.save(testDocSubmission("accNo2", 4, DocProcessingStatus.PROCESSED))
+
+        val lastVersion = testInstance.findLatestBasicByAccNo("accNo2")
+
+        assertThat(lastVersion).isNotNull()
+        assertThat(lastVersion!!.version).isEqualTo(4)
+    }
+
+    @Test
+    fun getAccessTags() {
+    }
+
+    @Test
+    fun `exists by AccNo when exists`() {
+        submissionMongoRepository.save(testDocSubmission("accNo3", 1, DocProcessingStatus.PROCESSED))
+
+        assertThat(submissionMongoRepository.existsByAccNo("accNo3")).isTrue()
+    }
+
+    @Test
+    fun `exist by AccNo when don't exists`() {
+        submissionMongoRepository.save(testDocSubmission("accNo4", 1, DocProcessingStatus.PROCESSED))
+
+        assertThat(submissionMongoRepository.existsByAccNo("accNo5")).isFalse()
+    }
+
+    private fun testDocSubmission(
+        accNo: String,
+        version: Int,
+        status: DocProcessingStatus,
+        attributes: List<DocAttribute> = listOf()
+    ): DocSubmission {
+        return DocSubmission(
+            id = "",
+            accNo = accNo,
+            version = version,
+            owner = "",
+            submitter = "",
+            title = "",
+            method = DocSubmissionMethod.PAGE_TAB,
+            relPath = "",
+            rootPath = "",
+            released = true,
+            secretKey = "",
+            status = status,
+            releaseTime = Instant.ofEpochSecond(1),
+            modificationTime = Instant.ofEpochSecond(2),
+            creationTime = Instant.ofEpochSecond(3),
+            section = DocSection(type = ""),
+            attributes = attributes,
+            tags = listOf(),
+            projects = listOf(),
+            stats = listOf()
+        )
+    }
+
+    companion object {
+
+        @Container
+        val mongoContainer: MongoDBContainer = MongoDBContainer(DockerImageName.parse("mongo:4.0.10"))
+
+        @JvmStatic
+        @DynamicPropertySource
+        fun propertySource(register: DynamicPropertyRegistry) {
+            register.add("spring.data.mongodb.uri") { mongoContainer.getReplicaSetUrl("testDb") }
+            register.add("spring.data.mongodb.database") { "testDb" }
+            register.add("app.persistence.enableMongo") { "true" }
+        }
+    }
+}