feat: split submit

compose.yml

@@ -1,35 +1,9 @@
 services:
-  mysql:
-    image: mysql
-    container_name: solve-mysql
-    environment:
-      MYSQL_ROOT_PASSWORD: root
-      MYSQL_DATABASE: solve
-    ports:
-      - 3306:3306
-    volumes:
-      - ./.compose/mysql:/var/lib/mysql
-    restart: unless-stopped
   redis:
     image: redis
     container_name: solve-redis
     ports:
       - 6379:6379
     restart: unless-stopped
     volumes:
-      - ./.compose/redis/data:/data
-      - ./.compose/redis/redis.conf:/usr/local/etc/redis/redis.conf
-#  cassendra:
-#    image: cassendra
-#    container_name: solve-cassendra
-#    ports:
-#      - 9042:9042
-#    volumes:
-#      - ./.compose/cassendra:/var/lib/cassendra
-#    environment:
-#      - CASSANDRA_CLUSTER_NAME=solve
-#    healthcheck:
-#      test: ["CMD", "cqlsh", "-e", "DESCRIBE KEYSPACES"]
-#      interval: 15s
-#      timeout: 10s
-#      retries: 10
+      - ./.compose/redis/data:/data

src/main/kotlin/com/solve/domain/admin/problem/service/impl/AdminProblemServiceImpl.kt

@@ -10,9 +10,13 @@ import com.solve.domain.admin.problem.service.AdminProblemService
 import com.solve.domain.problem.domain.entity.Problem
 import com.solve.domain.problem.domain.entity.ProblemExample
 import com.solve.domain.problem.domain.entity.ProblemTestCase
-import com.solve.domain.problem.domain.enums.ProblemSubmitState
 import com.solve.domain.problem.error.ProblemError
-import com.solve.domain.problem.repository.*
+import com.solve.domain.problem.repository.ProblemContributorRepository
+import com.solve.domain.problem.repository.ProblemExampleRepository
+import com.solve.domain.problem.repository.ProblemRepository
+import com.solve.domain.problem.repository.ProblemTestCaseRepository
+import com.solve.domain.submit.domain.enums.SubmitState
+import com.solve.domain.submit.repository.SubmitRepository
 import com.solve.global.common.enums.Tier
 import com.solve.global.error.CustomException
 import com.solve.global.security.holder.SecurityHolder
@@ -29,7 +33,7 @@ class AdminProblemServiceImpl(
     private val problemTestCaseRepository: ProblemTestCaseRepository,
     private val problemExampleRepository: ProblemExampleRepository,
     private val problemContributorRepository: ProblemContributorRepository,
-    private val problemSubmitRepository: ProblemSubmitRepository
+    private val submitRepository: SubmitRepository
 ) : AdminProblemService {
     @Transactional(readOnly = true)
     override fun getProblems(pageable: Pageable): Page<AdminProblemResponse> {
@@ -117,9 +121,9 @@ class AdminProblemServiceImpl(
         author = AdminProblemAuthorResponse.of(author),
         contributors = problemContributorRepository.findAllByProblem(this)
             .map { AdminProblemContributorResponse.of(it.user) },
-        correctRate = problemSubmitRepository.findAllByProblem(this).let { submits ->
+        correctRate = submitRepository.findAllByProblem(this).let { submits ->
             (submits.map { it.state }
-                .filter { it == ProblemSubmitState.ACCEPTED }.size.toDouble() / submits.size * 1000).toInt() / 10.0
+                .filter { it == SubmitState.ACCEPTED }.size.toDouble() / submits.size * 1000).toInt() / 10.0
         },
     )
 

src/main/kotlin/com/solve/domain/admin/statistic/service/impl/AdminStatisticServiceImpl.kt

@@ -3,7 +3,7 @@ package com.solve.domain.admin.statistic.service.impl
 import com.solve.domain.admin.statistic.service.AdminStatisticService
 import com.solve.domain.contest.repository.ContestRepository
 import com.solve.domain.problem.repository.ProblemRepository
-import com.solve.domain.problem.repository.ProblemSubmitRepository
+import com.solve.domain.submit.repository.SubmitRepository
 import com.solve.domain.user.repository.UserRepository
 import org.springframework.stereotype.Service
 import java.time.LocalDateTime
@@ -13,15 +13,15 @@ class AdminStatisticServiceImpl(
     private val problemRepository: ProblemRepository,
     private val userRepository: UserRepository,
     private val contestRepository: ContestRepository,
-    private val problemSubmitRepository: ProblemSubmitRepository
+    private val submitRepository: SubmitRepository
 ) : AdminStatisticService {
     override fun getTotalUsers() = userRepository.count()
 
     override fun getTotalContests() = contestRepository.count()
 
     override fun getTotalProblems() = problemRepository.count()
 
-    override fun getTotalSubmissions() = problemSubmitRepository.count()
+    override fun getTotalSubmissions() = submitRepository.count()
 
     override fun getTotalOngoingContests() = LocalDateTime.now().let {
         contestRepository.countByEndAtGreaterThanEqualAndStartAtLessThanEqual(it, it)

src/main/kotlin/com/solve/domain/problem/dto/response/ProblemResponse.kt

@@ -2,8 +2,8 @@ package com.solve.domain.problem.dto.response
 
 import com.fasterxml.jackson.annotation.JsonInclude
 import com.solve.domain.problem.domain.entity.ProblemExample
-import com.solve.domain.problem.domain.enums.ProblemSubmitState
 import com.solve.domain.problem.domain.enums.ProblemTag
+import com.solve.domain.submit.domain.enums.SubmitState
 import com.solve.domain.user.domain.entity.User
 import com.solve.global.common.enums.Tier
 
@@ -22,7 +22,7 @@ data class ProblemResponse(
     val solvedCount: Int,
     val examples: List<ProblemExampleResponse>,
     val author: ProblemAuthorResponse,
-    var state: ProblemSubmitState? = null
+    var state: SubmitState? = null
 )
 
 data class ProblemAuthorResponse(

src/main/kotlin/com/solve/domain/problem/mapper/ProblemMapper.kt

@@ -1,26 +1,26 @@
 package com.solve.domain.problem.mapper
 
 import com.solve.domain.problem.domain.entity.Problem
-import com.solve.domain.problem.domain.enums.ProblemSubmitState
 import com.solve.domain.problem.dto.response.ProblemAuthorResponse
 import com.solve.domain.problem.dto.response.ProblemExampleResponse
 import com.solve.domain.problem.dto.response.ProblemResponse
 import com.solve.domain.problem.repository.ProblemExampleRepository
-import com.solve.domain.problem.repository.ProblemSubmitRepository
+import com.solve.domain.submit.domain.enums.SubmitState
+import com.solve.domain.submit.repository.SubmitRepository
 import com.solve.global.security.holder.SecurityHolder
 import org.springframework.stereotype.Component
 import org.springframework.transaction.annotation.Transactional
 
 @Component
 class ProblemMapper(
-    private val problemSubmitRepository: ProblemSubmitRepository,
+    private val submitRepository: SubmitRepository,
     private val problemExampleRepository: ProblemExampleRepository,
     private val securityHolder: SecurityHolder
 ) {
     @Transactional(readOnly = true)
     fun toResponse(problem: Problem): ProblemResponse {
-        val submits = problemSubmitRepository.findAllByProblem(problem)
-        val acceptedSubmits = submits.filter { it.state == ProblemSubmitState.ACCEPTED }
+        val submits = submitRepository.findAllByProblem(problem)
+        val acceptedSubmits = submits.filter { it.state == SubmitState.ACCEPTED }
         val distinctSolvedCount = acceptedSubmits.distinctBy { it.author }.size
         val correctRate = if (submits.isNotEmpty()) {
             (acceptedSubmits.size.toDouble() / submits.size * 1000).toInt() / 10.0
@@ -44,20 +44,20 @@ class ProblemMapper(
         ).apply {
             if (!securityHolder.isAuthenticated) return@apply
 
-            val mySubmits = problemSubmitRepository.findAllByProblemAndAuthor(problem, securityHolder.user)
+            val mySubmits = submitRepository.findAllByProblemAndAuthor(problem, securityHolder.user)
 
-            if (mySubmits.any { it.state == ProblemSubmitState.ACCEPTED }) {
-                state = ProblemSubmitState.ACCEPTED
+            if (mySubmits.any { it.state == SubmitState.ACCEPTED }) {
+                state = SubmitState.ACCEPTED
             } else if (mySubmits.any {
                     it.state in listOf(
-                        ProblemSubmitState.WRONG_ANSWER,
-                        ProblemSubmitState.RUNTIME_ERROR,
-                        ProblemSubmitState.TIME_LIMIT_EXCEEDED,
-                        ProblemSubmitState.MEMORY_LIMIT_EXCEEDED,
-                        ProblemSubmitState.COMPILE_ERROR
+                        SubmitState.WRONG_ANSWER,
+                        SubmitState.RUNTIME_ERROR,
+                        SubmitState.TIME_LIMIT_EXCEEDED,
+                        SubmitState.MEMORY_LIMIT_EXCEEDED,
+                        SubmitState.COMPILE_ERROR
                     )
                 }) {
-                state = ProblemSubmitState.WRONG_ANSWER
+                state = SubmitState.WRONG_ANSWER
             }
         }
     }

src/main/kotlin/com/solve/domain/problem/repository/impl/ProblemQueryRepositoryImpl.kt

@@ -5,11 +5,11 @@ import com.querydsl.jpa.impl.JPAQuery
 import com.querydsl.jpa.impl.JPAQueryFactory
 import com.solve.domain.problem.domain.entity.Problem
 import com.solve.domain.problem.domain.entity.QProblem
-import com.solve.domain.problem.domain.entity.QProblemSubmit
 import com.solve.domain.problem.domain.enums.ProblemSearchOrder
 import com.solve.domain.problem.domain.enums.ProblemSearchState
-import com.solve.domain.problem.domain.enums.ProblemSubmitState
 import com.solve.domain.problem.repository.ProblemQueryRepository
+import com.solve.domain.submit.domain.entity.QSubmit
+import com.solve.domain.submit.domain.enums.SubmitState
 import com.solve.global.common.enums.Tier
 import com.solve.global.security.holder.SecurityHolder
 import org.springframework.data.domain.Page
@@ -24,7 +24,7 @@ class ProblemQueryRepositoryImpl(
     private val queryFactory: JPAQueryFactory
 ) : ProblemQueryRepository {
     private val problem = QProblem.problem
-    private val submit = QProblemSubmit.problemSubmit
+    private val submit = QSubmit.submit
 
     @Transactional(readOnly = true)
     override fun searchProblem(
@@ -79,7 +79,7 @@ class ProblemQueryRepositoryImpl(
         if (state.contains(ProblemSearchState.SOLVED)) {
             return problem.id.`in`(
                 submittedProblems
-                    .filter { it.state == ProblemSubmitState.ACCEPTED }
+                    .filter { it.state == SubmitState.ACCEPTED }
                     .map { it.problem.id }
             )
         }
@@ -93,7 +93,7 @@ class ProblemQueryRepositoryImpl(
         if (state.contains(ProblemSearchState.SOLVING)) {
             return problem.id.`in`(
                 submittedProblems
-                    .filter { it.state != ProblemSubmitState.ACCEPTED }
+                    .filter { it.state != SubmitState.ACCEPTED }
                     .map { it.problem.id }
             )
         }
@@ -111,7 +111,7 @@ class ProblemQueryRepositoryImpl(
                 query.leftJoin(submit).on(submit.problem.eq(problem))
                     .groupBy(problem)
                     .orderBy(
-                        submit.state.`when`(ProblemSubmitState.ACCEPTED)
+                        submit.state.`when`(SubmitState.ACCEPTED)
                             .then(1L)
                             .otherwise(0L)
                             .sum()
@@ -125,7 +125,7 @@ class ProblemQueryRepositoryImpl(
                 query.leftJoin(submit).on(submit.problem.eq(problem))
                     .groupBy(problem)
                     .orderBy(
-                        submit.state.`when`(ProblemSubmitState.ACCEPTED)
+                        submit.state.`when`(SubmitState.ACCEPTED)
                             .then(1L)
                             .otherwise(0L)
                             .sum()