Merge pull request #46 from EntryDSM/feature/원서-접수-기능

Feature/원서 접수 기능

Author: coehgns

API_TEST.md

@@ -2,51 +2,41 @@ object Dependencies {
     //kotlin
     const val KOTLIN_REFLECT = "org.jetbrains.kotlin:kotlin-reflect"
     const val KOTLIN_TEST = "org.jetbrains.kotlin:kotlin-test"
-
     //springframework
     const val SPRING_BOOT_STARTER = "org.springframework.boot:spring-boot-starter"
     const val SPRING_BOOT_STARTER_WEB = "org.springframework.boot:spring-boot-starter-web"
     const val SPRING_BOOT_STARTER_TEST = "org.springframework.boot:spring-boot-starter-test"
     const val SPRING_BOOT_STARTER_ACTUATOR  = "org.springframework.boot:spring-boot-starter-actuator"
     const val SPRING_BOOT_STARTER_SECURITY = "org.springframework.boot:spring-boot-starter-security"
     const val SPRING_CONTEXT = "org.springframework:spring-context"
-
+    const val SPRING_BOOT_STARTER_VALIDATION = "org.springframework.boot:spring-boot-starter-validation"
+    const val SPRING_BOOT_STARTER_DATA_JPA = "org.springframework.boot:spring-boot-starter-data-jpa"
+    //database
+    const val H2_DATABASE = "com.h2database:h2"
     //jexl
     const val APACHE_COMMONS_JEXL = "org.apache.commons:commons-jexl3:${DependencyVersions.APACHE_COMMONS_JEXL_VERSION}"
-
     //kotlinx serialization
     const val KOTLINX_SERIALIZATION_JSON = "org.jetbrains.kotlinx:kotlinx-serialization-json:${DependencyVersions.KOTLINX_SERIALIZATION_VERSION}"
-
     //kotlinx coroutines
     const val KOTLINX_COROUTINES_CORE = "org.jetbrains.kotlinx:kotlinx-coroutines-core:${DependencyVersions.KOTLINX_COROUTINES_VERSION}"
-    const val KOTLINX_COROUTINES_REACTOR = "org.jetbrains.kotlinx:kotlinx-coroutines-reactor:${DependencyVersions.KOTLINX_COROUTINES_VERSION}"
-
     //junit
     const val JUNIT = "org.jetbrains.kotlin:kotlin-test-junit5"
     const val JUNIT_PLATFORM_LAUNCHER = "org.junit.platform:junit-platform-launcher"
-
     //poi
     const val POI = "org.apache.poi:poi:${DependencyVersions.POI_VERSION}"
     const val POI_OOXML = "org.apache.poi:poi-ooxml:${DependencyVersions.POI_VERSION}"
-
     //Pdf
     const val PDF_ITEXT = "com.itextpdf:itext7-fonts:${DependencyVersions.PDF_ITEXT}"
     const val PDF_HTML = "com.itextpdf:html2pdf:${DependencyVersions.PDF_HTML}"
-
     const val THYMELEAF = "org.springframework.boot:spring-boot-starter-thymeleaf"
-
     //commons io
     const val COMMONS_IO = "commons-io:commons-io:${DependencyVersions.COMMONS_IO}"
-
     // Feign Client
     const val OPEN_FEIGN = "org.springframework.cloud:spring-cloud-starter-openfeign:${DependencyVersions.OPEN_FEIGN_VERSION}"
-
     // Spring Cloud BOM
     const val SPRING_CLOUD = "org.springframework.cloud:spring-cloud-dependencies:${DependencyVersions.SPRING_CLOUD_VERSION}"
-
     // WebFlux
     const val WEB_FLUX = "org.springframework.boot:spring-boot-starter-webflux"
-
     // gRPC
     const val GRPC_NETTY_SHADED = "io.grpc:grpc-netty-shaded:${DependencyVersions.GRPC}"
     const val GRPC_PROTOBUF = "io.grpc:grpc-protobuf:${DependencyVersions.GRPC}"
@@ -56,65 +46,46 @@ object Dependencies {
     const val GRPC_TESTING = "io.grpc:grpc-testing:${DependencyVersions.GRPC}"
     const val GRPC_CLIENT = "net.devh:grpc-client-spring-boot-starter:${DependencyVersions.GRPC_CLIENT}"
     const val GOOGLE_PROTOBUF = "com.google.protobuf:protobuf-java:${DependencyVersions.GOOGLE_PROTOBUF}"
-
     // Coroutines
     const val COROUTINES = "org.jetbrains.kotlinx:kotlinx-coroutines-core:${DependencyVersions.COROUTINES}"
-
     // MapStruct
     const val MAPSTRUCT = "org.mapstruct:mapstruct:${DependencyVersions.MAPSTRUCT}"
     const val MAPSTRUCT_PROCESSOR = "org.mapstruct:mapstruct-processor:${DependencyVersions.MAPSTRUCT}"
-
     // MySQL
     const val MYSQL_CONNECTOR = "com.mysql:mysql-connector-j"
-
     // QueryDSL
     const val QUERYDSL_JPA = "com.querydsl:querydsl-jpa:${DependencyVersions.QUERYDSL}:jakarta"
     const val QUERYDSL_APT = "com.querydsl:querydsl-apt:${DependencyVersions.QUERYDSL}:jakarta"
-
     // Jakarta APIs for kapt
     const val JAKARTA_PERSISTENCE_API = "jakarta.persistence:jakarta.persistence-api:${DependencyVersions.JAKARTA_PERSISTENCE}"
     const val JAKARTA_ANNOTATION_API = "jakarta.annotation:jakarta.annotation-api:${DependencyVersions.JAKARTA_ANNOTATION}"
-
     // Caffeine
     const val CAFFEINE = "com.github.ben-manes.caffeine:caffeine:${DependencyVersions.CAFFEINE}"
-
     // Jackson Kotlin module
     const val JACKSON_MODULE_KOTLIN = "com.fasterxml.jackson.module:jackson-module-kotlin"
-
+    const val JACKSON_DATATYPE_JSR310 = "com.fasterxml.jackson.datatype:jackson-datatype-jsr310"
     // Coroutines Reactor bridge
     const val COROUTINES_REACTOR = "org.jetbrains.kotlinx:kotlinx-coroutines-reactor"
-
     // Reactor Netty
     const val REACTOR_NETTY = "io.projectreactor.netty:reactor-netty"
-
-    // JPA
-    const val SPRING_BOOT_STARTER_DATA_JPA = "org.springframework.boot:spring-boot-starter-data-jpa"
-
     // transaction
     const val SPRING_TRANSACTION = "org.springframework:spring-tx"
-
     //spring cache
     // Redis (캐시)
     const val REDIS = "org.springframework.boot:spring-boot-starter-data-redis"
-
     // Cache (스프링 캐시)
     const val SPRING_CACHE = "org.springframework.boot:spring-boot-starter-cache"
-
     //Resilience4j
     const val RESILIENCE4J_CIRCUITBREAKER = "io.github.resilience4j:resilience4j-circuitbreaker:${DependencyVersions.RESILIENCE4J}"
     const val RESILIENCE4J_RETRY = "io.github.resilience4j:resilience4j-retry:${DependencyVersions.RESILIENCE4J}"
     const val RESILIENCE4J_SPRING_BOOT = "io.github.resilience4j:resilience4j-spring-boot3:${DependencyVersions.RESILIENCE4J}"
     const val RESILIENCE4J_KOTLIN = "io.github.resilience4j:resilience4j-kotlin:${DependencyVersions.RESILIENCE4J}"
-
     // Netty
     const val NETTY = "io.netty:netty-resolver-dns-native-macos:${DependencyVersions.NETTY}"
-
     //kafka
     const val KAFKA = "org.springframework.kafka:spring-kafka"
-    
     // Spring Cloud Config
     const val SPRING_CLOUD_STARTER_CONFIG = "org.springframework.cloud:spring-cloud-starter-config"
-
     //swagger
     const val SWAGGER = "org.springdoc:springdoc-openapi-starter-webmvc-ui:${DependencyVersions.SWAGGER}"
 }

CLAUDE.md

@@ -1,4 +1,13 @@
 object DependencyVersions {
+    // Database
+    const val MYSQL_CONNECTOR_VERSION = "9.2.0"
+    
+    // QueryDSL
+    const val QUERYDSL_VERSION = "5.1.0"
+    
+    // MapStruct
+    const val MAPSTRUCT_VERSION = "1.6.3"
+    
     // JEXL
     const val APACHE_COMMONS_JEXL_VERSION = "3.5.0"
 

buildSrc/src/main/kotlin/Dependencies.kt

@@ -2,6 +2,10 @@ object Plugins {
     const val KOTLIN_JVM = "jvm"
     const val JETBRAINS_KOTLIN_JVM = "org.jetbrains.kotlin.jvm"
     const val KOTLIN_SPRING = "plugin.spring"
+    const val KOTLIN_JPA = "plugin.jpa"
+    const val KOTLIN_ALLOPEN = "plugin.allopen"
+    const val KOTLIN_NOARG = "plugin.noarg"
+    const val KOTLIN_KAPT = "kapt"
     const val KOTLIN_SERIALIZATION = "plugin.serialization"
     const val JETBRAINS_KOTLIN_SERIALIZATION = "org.jetbrains.kotlin.plugin.serialization"
     const val SPRING_BOOT = "org.springframework.boot"

buildSrc/src/main/kotlin/DependencyVersions.kt

@@ -0,0 +1,108 @@
+package hs.kr.entrydsm.domain.application.entities
+
+import hs.kr.entrydsm.domain.application.values.*
+import hs.kr.entrydsm.global.annotation.entities.Entity
+import hs.kr.entrydsm.global.constants.ErrorCodes
+import hs.kr.entrydsm.global.exception.DomainException
+import hs.kr.entrydsm.global.interfaces.AggregateRoot
+import java.util.UUID
+
+@Entity(aggregateRoot = ApplicationPrototype::class, context = "application")
+data class ApplicationPrototype(
+    private val prototypeId: PrototypeId,
+    val applicationType: String,
+    val educationalStatus: String,
+    val region: String?,
+    val application: Map<String, Map<String, FieldDefinition>>,
+    val score: Map<String, Map<String, FieldDefinition>>,
+    val formula: List<FormulaStep>,
+    val constant: Map<String, Double>
+) : AggregateRoot<PrototypeId>() {
+    
+    val id: PrototypeId
+        @JvmName("getPrototypeId")
+        get() = prototypeId
+    
+    init {
+        if (applicationType.isBlank()) throw DomainException(ErrorCodes.Common.VALIDATION_FAILED)
+        if (educationalStatus.isBlank()) throw DomainException(ErrorCodes.Common.VALIDATION_FAILED)
+        if (application.isEmpty()) throw DomainException(ErrorCodes.Common.VALIDATION_FAILED)
+        if (score.isEmpty()) throw DomainException(ErrorCodes.Common.VALIDATION_FAILED)
+        if (formula.isEmpty()) throw DomainException(ErrorCodes.Common.VALIDATION_FAILED)
+    }
+    
+    override fun getId(): PrototypeId = prototypeId
+    override fun getType(): String = "ApplicationPrototype"
+    override fun checkInvariants(): Boolean {
+        return applicationType.isNotBlank() &&
+               educationalStatus.isNotBlank() &&
+               application.isNotEmpty() &&
+               score.isNotEmpty() &&
+               formula.isNotEmpty()
+    }
+    
+    fun getRequiredApplicationFields(): Set<String> {
+        return application.flatMap { (groupName, fieldGroup) ->
+            fieldGroup.filter { it.value.required }.keys.map { fieldName ->
+                "$groupName.$fieldName"
+            }
+        }.toSet()
+    }
+    
+    fun getRequiredScoreFields(): Set<String> {
+        return score.flatMap { (groupName, fieldGroup) ->
+            fieldGroup.filter { it.value.required }.keys.map { fieldName ->
+                "$groupName.$fieldName"
+            }
+        }.toSet()
+    }
+    
+    fun validateApplicationData(applicationData: Map<String, Any>): Boolean {
+        val requiredFields = getRequiredApplicationFields()
+        val providedFields = extractAllFieldKeys(applicationData)
+        return requiredFields.all { providedFields.contains(it) }
+    }
+    
+    fun validateScoreData(scoreData: Map<String, Any>): Boolean {
+        val requiredFields = getRequiredScoreFields()
+        val providedFields = extractAllFieldKeys(scoreData)
+        return requiredFields.all { providedFields.contains(it) }
+    }
+    
+    private fun extractAllFieldKeys(data: Map<String, Any>, prefix: String = ""): Set<String> {
+        val result = mutableSetOf<String>()
+        data.forEach { (key, value) ->
+            val fullKey = if (prefix.isEmpty()) key else "${prefix}.${key}"
+            result.add(fullKey)
+            if (value is Map<*, *>) {
+                @Suppress("UNCHECKED_CAST")
+                result.addAll(extractAllFieldKeys(value as Map<String, Any>, fullKey))
+            }
+        }
+        return result
+    }
+    
+    companion object {
+        fun create(
+            prototypeId: PrototypeId,
+            applicationType: String,
+            educationalStatus: String,
+            region: String?,
+            applicationFields: Map<String, Map<String, FieldDefinition>>,
+            scoreFields: Map<String, Map<String, FieldDefinition>>,
+            formulas: List<FormulaStep>,
+            constants: Map<String, Double>
+        ): ApplicationPrototype {
+            return ApplicationPrototype(
+                prototypeId = prototypeId,
+                applicationType = applicationType,
+                educationalStatus = educationalStatus,
+                region = region,
+                application = applicationFields,
+                score = scoreFields,
+                formula = formulas,
+                constant = constants
+            )
+        }
+    }
+}

buildSrc/src/main/kotlin/Plugins.kt

@@ -0,0 +1,44 @@
+package hs.kr.entrydsm.domain.application.entities
+
+import hs.kr.entrydsm.domain.application.values.ApplicationTypeInfo
+import hs.kr.entrydsm.domain.application.values.EducationalStatusInfo
+import hs.kr.entrydsm.global.annotation.entities.Entity
+import hs.kr.entrydsm.global.constants.ErrorCodes
+import hs.kr.entrydsm.global.exception.DomainException
+import hs.kr.entrydsm.global.interfaces.EntityMarker
+
+@Entity(aggregateRoot = SupportedApplicationTypes::class, context = "application")
+data class SupportedApplicationTypes(
+    val applicationTypes: List<ApplicationTypeInfo>,
+    val educationalStatuses: List<EducationalStatusInfo>
+) : EntityMarker {
+    
+    init {
+        if (applicationTypes.isEmpty()) throw DomainException(ErrorCodes.Common.VALIDATION_FAILED)
+        if (educationalStatuses.isEmpty()) throw DomainException(ErrorCodes.Common.VALIDATION_FAILED)
+    }
+    
+    override fun getDomainContext(): String = "application"
+    
+    override fun getIdentifier(): String = "supported-types"
+    
+    fun isValidApplicationType(code: String): Boolean {
+        return applicationTypes.any { it.code == code }
+    }
+    
+    fun isValidEducationalStatus(code: String): Boolean {
+        return educationalStatuses.any { it.code == code }
+    }
+    
+    companion object {
+        fun create(
+            applicationTypes: List<ApplicationTypeInfo>,
+            educationalStatuses: List<EducationalStatusInfo>
+        ): SupportedApplicationTypes {
+            return SupportedApplicationTypes(
+                applicationTypes = applicationTypes,
+                educationalStatuses = educationalStatuses
+            )
+        }
+    }
+}

casper-application-domain/src/main/kotlin/hs/kr/entrydsm/domain/application/entities/ApplicationPrototype.kt

@@ -0,0 +1,12 @@
+package hs.kr.entrydsm.domain.application.spi
+
+import hs.kr.entrydsm.domain.application.entities.ApplicationPrototype
+import hs.kr.entrydsm.domain.application.entities.SupportedApplicationTypes
+import hs.kr.entrydsm.domain.application.values.ApplicationTypeFilter
+import hs.kr.entrydsm.domain.application.values.ValidationResult
+
+interface PrototypePort {
+    fun findPrototypeByApplicationType(filter: ApplicationTypeFilter): ApplicationPrototype?
+    fun findSupportedTypes(): SupportedApplicationTypes
+    fun validateScoreData(prototype: ApplicationPrototype, scoreData: Map<String, Any>): ValidationResult
+}

casper-application-domain/src/main/kotlin/hs/kr/entrydsm/domain/application/entities/SupportedApplicationTypes.kt

@@ -0,0 +1,15 @@
+package hs.kr.entrydsm.domain.application.values
+
+import hs.kr.entrydsm.global.constants.ErrorCodes
+import hs.kr.entrydsm.global.exception.DomainException
+
+data class ApplicationTypeFilter(
+    val applicationType: String,
+    val educationalStatus: String,
+    val region: String?
+) {
+    init {
+        if (applicationType.isBlank()) throw DomainException(ErrorCodes.Common.VALIDATION_FAILED)
+        if (educationalStatus.isBlank()) throw DomainException(ErrorCodes.Common.VALIDATION_FAILED)
+    }
+}

casper-application-domain/src/main/kotlin/hs/kr/entrydsm/domain/application/spi/PrototypePort.kt

@@ -0,0 +1,14 @@
+package hs.kr.entrydsm.domain.application.values
+
+import hs.kr.entrydsm.global.constants.ErrorCodes
+import hs.kr.entrydsm.global.exception.DomainException
+
+data class ApplicationTypeInfo(
+    val code: String,
+    val name: String
+) {
+    init {
+        if (code.isBlank()) throw DomainException(ErrorCodes.Common.VALIDATION_FAILED)
+        if (name.isBlank()) throw DomainException(ErrorCodes.Common.VALIDATION_FAILED)
+    }
+}