upload file

casper-application-domain/src/main/kotlin/hs/kr/entrydsm/domain/file/object/PathList.kt

@@ -0,0 +1,5 @@
+package hs.kr.entrydsm.domain.file.`object`
+
+object PathList {
+    const val PHOTO = "entry_photo/"
+}

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

@@ -0,0 +1,5 @@
+package hs.kr.entrydsm.domain.file.spi
+
+interface GenerateFileUrlPort {
+    fun generateFileUrl(fileName: String, path: String): String
+}

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

@@ -0,0 +1,7 @@
+package hs.kr.entrydsm.domain.file.spi
+
+import java.io.File
+
+interface UploadFilePort {
+    fun upload(file: File, path: String): String
+}

casper-application-domain/src/main/kotlin/hs/kr/entrydsm/global/exception/WebException.kt

@@ -0,0 +1,6 @@
+package hs.kr.entrydsm.global.exception
+
+abstract class WebException(
+    open val status: Int,
+    override val message: String,
+) : RuntimeException()

casper-application-infrastructure/build.gradle.kts

@@ -134,6 +134,9 @@ dependencies {
 
     // swagger
     implementation(Dependencies.SWAGGER)
+
+    // aws s3
+    implementation("com.amazonaws:aws-java-sdk-s3:1.12.767")
 }
 
 allOpen {

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/domain/application/domain/entity/ApplicationJpaEntity.kt

@@ -52,7 +52,7 @@ class ApplicationJpaEntity(
     @get:JvmName("getIsOutOfHeadcount")
     var isOutOfHeadcount: Boolean?,
     @Column(columnDefinition = "TEXT")
-    val photoPath: String?,
+    var photoPath: String?,
     val parentRelation: String?,
     val postalCode: String?,
     val detailAddress: String?,

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/domain/application/domain/entity/PhotoJpaEntity.kt

@@ -0,0 +1,17 @@
+package hs.kr.entrydsm.application.domain.application.domain.entity
+
+import jakarta.persistence.Column
+import jakarta.persistence.Entity
+import jakarta.persistence.Id
+import jakarta.persistence.Table
+import java.util.UUID
+
+@Entity
+@Table(name = "tbl_photo")
+class PhotoJpaEntity(
+    @Id
+    val userId: UUID,
+
+    @Column(name = "photo_path", nullable = false)
+    var photo: String,
+)

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/domain/application/domain/repository/PhotoJpaRepository.kt

@@ -0,0 +1,10 @@
+package hs.kr.entrydsm.application.domain.application.domain.repository
+
+import hs.kr.entrydsm.application.domain.application.domain.entity.PhotoJpaEntity
+import org.springframework.data.jpa.repository.JpaRepository
+import java.util.UUID
+
+interface PhotoJpaRepository : JpaRepository<PhotoJpaEntity, Long> {
+
+    fun findByUserId(userId: UUID): PhotoJpaEntity?
+}

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/domain/application/presentation/FileController.kt

@@ -0,0 +1,24 @@
+package hs.kr.entrydsm.application.domain.application.presentation
+
+import hs.kr.entrydsm.application.domain.application.usecase.FileUploadUseCase
+import hs.kr.entrydsm.application.domain.file.presentation.converter.ImageFileConverter
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestPart
+import org.springframework.web.bind.annotation.RestController
+import org.springframework.web.multipart.MultipartFile
+
+@RequestMapping("/photo")
+@RestController
+class FileController(
+    private val fileUploadUseCase: FileUploadUseCase
+) {
+    @PostMapping
+    fun uploadPhoto(@RequestPart(name = "image") file: MultipartFile): ResponseEntity<Map<String, String>> {
+        val photoUrl = fileUploadUseCase.execute(
+            file.let(ImageFileConverter::transferTo)
+        )
+        return ResponseEntity.ok(mapOf("photo_url" to photoUrl))
+    }
+}

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/domain/application/presentation/dto/response/ApplicationDetailResponse.kt

@@ -22,5 +22,6 @@ data class ApplicationDetailResponse(
         val reviewedAt: LocalDateTime?,
         val createdAt: LocalDateTime,
         val updatedAt: LocalDateTime,
+        val photoPath: String?,
     )
 }

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/domain/application/usecase/ApplicationQueryUseCase.kt

@@ -5,11 +5,15 @@ import hs.kr.entrydsm.application.domain.application.domain.repository.Applicati
 import hs.kr.entrydsm.application.domain.application.domain.repository.ApplicationScoreJpaRepository
 import hs.kr.entrydsm.application.domain.application.domain.repository.CalculationResultJpaRepository
 import hs.kr.entrydsm.application.domain.application.domain.repository.CalculationStepJpaRepository
+import hs.kr.entrydsm.application.domain.application.domain.repository.PhotoJpaRepository
 import hs.kr.entrydsm.application.domain.application.presentation.dto.response.ApplicationDetailResponse
 import hs.kr.entrydsm.application.domain.application.presentation.dto.response.ApplicationListResponse
 import hs.kr.entrydsm.application.domain.application.presentation.dto.response.ApplicationScoresResponse
 import hs.kr.entrydsm.application.domain.application.presentation.dto.response.CalculationHistoryResponse
 import hs.kr.entrydsm.application.domain.application.presentation.dto.response.CalculationResponse
+import hs.kr.entrydsm.application.global.security.SecurityAdapter
+import hs.kr.entrydsm.domain.file.`object`.PathList
+import hs.kr.entrydsm.domain.file.spi.GenerateFileUrlPort
 import org.springframework.data.domain.PageRequest
 import org.springframework.data.domain.Pageable
 import org.springframework.data.domain.Sort
@@ -25,13 +29,19 @@ class ApplicationQueryUseCase(
     private val calculationResultRepository: CalculationResultJpaRepository,
     private val calculationStepRepository: CalculationStepJpaRepository,
     private val objectMapper: ObjectMapper,
+    private val photoJpaRepository: PhotoJpaRepository,
+    private val securityAdapter: SecurityAdapter,
+    private val generateFileUrlPort: GenerateFileUrlPort
 ) {
     fun getApplicationById(applicationId: String): ApplicationDetailResponse {
         val uuid = UUID.fromString(applicationId)
         val application =
             applicationRepository.findById(uuid)
                 .orElseThrow { IllegalArgumentException("원서를 찾을 수 없습니다: $applicationId") }
 
+        val user = securityAdapter.getCurrentUserId()
+        val photoPath = photoJpaRepository.findByUserId(user)?.photo
+
         return ApplicationDetailResponse(
             success = true,
             data =
@@ -51,6 +61,7 @@ class ApplicationQueryUseCase(
                     reviewedAt = application.reviewedAt,
                     createdAt = application.createdAt,
                     updatedAt = application.updatedAt,
+                    photoPath = generateFileUrlPort.generateFileUrl(photoPath!!, PathList.PHOTO)
                 ),
         )
     }

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/domain/application/usecase/FileUploadUseCase.kt

@@ -0,0 +1,35 @@
+package hs.kr.entrydsm.application.domain.application.usecase
+
+import hs.kr.entrydsm.application.domain.application.domain.entity.PhotoJpaEntity
+import hs.kr.entrydsm.application.domain.application.domain.repository.PhotoJpaRepository
+import hs.kr.entrydsm.application.global.security.SecurityAdapter
+import hs.kr.entrydsm.domain.file.spi.UploadFilePort
+import hs.kr.entrydsm.domain.file.`object`.PathList
+import org.springframework.stereotype.Component
+import org.springframework.transaction.annotation.Transactional
+import java.io.File
+
+@Component
+class FileUploadUseCase(
+    private val uploadFilePort: UploadFilePort,
+    private val photoJpaRepository: PhotoJpaRepository,
+    private val securityAdapter: SecurityAdapter,
+) {
+    @Transactional
+    fun execute(file: File): String {
+        val userId = securityAdapter.getCurrentUserId()
+        val photoUrl = uploadFilePort.upload(file, PathList.PHOTO)
+
+        photoJpaRepository.findByUserId(userId)?.apply {
+            photo = photoUrl
+            photoJpaRepository.save(this)
+        } ?: photoJpaRepository.save(
+            PhotoJpaEntity(
+                userId = userId,
+                photo = photoUrl
+            )
+        )
+
+        return photoUrl
+    }
+}

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/domain/file/presentation/converter/FileConverter.kt

@@ -0,0 +1,31 @@
+package hs.kr.entrydsm.application.domain.file.presentation.converter
+
+import hs.kr.entrydsm.application.domain.file.presentation.exception.WebFileExceptions
+import org.springframework.web.multipart.MultipartFile
+import java.io.File
+import java.io.FileOutputStream
+import java.util.UUID
+
+interface FileConverter {
+    val MultipartFile.extension: String
+        get() = originalFilename?.substringAfterLast(".", "")?.uppercase() ?: ""
+
+    fun isCorrectExtension(multipartFile: MultipartFile): Boolean
+
+    fun transferTo(multipartFile: MultipartFile): File {
+        if (!isCorrectExtension(multipartFile)) {
+            throw WebFileExceptions.InvalidExtension()
+        }
+
+        return transferFile(multipartFile)
+    }
+
+    private fun transferFile(multipartFile: MultipartFile): File {
+        return File("${UUID.randomUUID()}_${multipartFile.originalFilename}")
+            .apply {
+                FileOutputStream(this).use {
+                    it.write(multipartFile.bytes)
+                }
+            }
+    }
+}

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/domain/file/presentation/converter/FileExtensions.kt

@@ -0,0 +1,8 @@
+package hs.kr.entrydsm.application.domain.file.presentation.converter
+
+object FileExtensions {
+    const val JPG = "JPG"
+    const val JPEG = "JPEG"
+    const val PNG = "PNG"
+    const val HEIC = "HEIC"
+}

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/domain/file/presentation/converter/ImageFileConverter.kt

@@ -0,0 +1,16 @@
+package hs.kr.entrydsm.application.domain.file.presentation.converter
+
+import hs.kr.entrydsm.application.domain.file.presentation.converter.FileExtensions.HEIC
+import hs.kr.entrydsm.application.domain.file.presentation.converter.FileExtensions.JPEG
+import hs.kr.entrydsm.application.domain.file.presentation.converter.FileExtensions.JPG
+import hs.kr.entrydsm.application.domain.file.presentation.converter.FileExtensions.PNG
+import org.springframework.web.multipart.MultipartFile
+
+object ImageFileConverter : FileConverter {
+    override fun isCorrectExtension(multipartFile: MultipartFile): Boolean {
+        return when (multipartFile.extension) {
+            JPG, JPEG, PNG, HEIC -> true
+            else -> false
+        }
+    }
+}

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/domain/file/presentation/exception/WebFileExceptions.kt

@@ -0,0 +1,14 @@
+package hs.kr.entrydsm.application.domain.file.presentation.exception
+
+import hs.kr.entrydsm.global.exception.WebException
+
+sealed class WebFileExceptions(
+    override val status: Int,
+    override val message: String,
+) : WebException(status, message) {
+    class InvalidExtension(message: String = INVALID_EXTENSION) : WebFileExceptions(400, message)
+
+    companion object {
+        private const val INVALID_EXTENSION = "확장자가 유효하지 않습니다."
+    }
+}

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/global/config/AwsS3Config.kt

@@ -0,0 +1,29 @@
+package hs.kr.entrydsm.application.global.config
+
+import com.amazonaws.auth.AWSStaticCredentialsProvider
+import com.amazonaws.auth.BasicAWSCredentials
+import com.amazonaws.services.s3.AmazonS3Client
+import com.amazonaws.services.s3.AmazonS3ClientBuilder
+import hs.kr.entrydsm.application.global.storage.AwsCredentialsProperties
+import hs.kr.entrydsm.application.global.storage.AwsProperties
+import org.springframework.boot.context.properties.EnableConfigurationProperties
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@Configuration
+@EnableConfigurationProperties(AwsProperties::class, AwsCredentialsProperties::class)
+class AwsS3Config(
+    private val awsProperties: AwsProperties,
+    private val awsCredentialsProperties: AwsCredentialsProperties
+) {
+
+    @Bean
+    fun amazonS3Client(): AmazonS3Client {
+        val credentials = BasicAWSCredentials(awsCredentialsProperties.accessKey, awsCredentialsProperties.secretKey)
+
+        return AmazonS3ClientBuilder.standard()
+            .withRegion(awsProperties.region)
+            .withCredentials(AWSStaticCredentialsProvider(credentials))
+            .build() as AmazonS3Client
+    }
+}

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/global/storage/AwsCredentialsProperties.kt

@@ -0,0 +1,9 @@
+package hs.kr.entrydsm.application.global.storage
+
+import org.springframework.boot.context.properties.ConfigurationProperties
+
+@ConfigurationProperties("cloud.aws.credentials")
+class AwsCredentialsProperties(
+    val accessKey: String,
+    val secretKey: String,
+)

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/global/storage/AwsProperties.kt

@@ -0,0 +1,9 @@
+package hs.kr.entrydsm.application.global.storage
+
+import org.springframework.boot.context.properties.ConfigurationProperties
+
+@ConfigurationProperties("cloud.aws.s3")
+class AwsProperties(
+    val bucket: String,
+    val region: String,
+)

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/global/storage/AwsS3Adapter.kt

@@ -0,0 +1,70 @@
+package hs.kr.entrydsm.application.global.storage
+
+import com.amazonaws.HttpMethod
+import com.amazonaws.services.s3.AmazonS3Client
+import com.amazonaws.services.s3.internal.Mimetypes
+import com.amazonaws.services.s3.model.CannedAccessControlList
+import com.amazonaws.services.s3.model.GeneratePresignedUrlRequest
+import com.amazonaws.services.s3.model.ObjectMetadata
+import com.amazonaws.services.s3.model.PutObjectRequest
+import hs.kr.entrydsm.domain.file.spi.GenerateFileUrlPort
+import hs.kr.entrydsm.domain.file.spi.UploadFilePort
+import org.springframework.stereotype.Component
+import java.io.File
+import java.io.IOException
+import java.util.Date
+
+@Component
+class AwsS3Adapter(
+    private val amazonS3Client: AmazonS3Client,
+    private val awsProperties: AwsProperties
+) : UploadFilePort, GenerateFileUrlPort {
+
+    companion object {
+        const val EXP_TIME = 1000 * 60 * 2
+    }
+
+    override fun upload(file: File, path: String): String {
+        runCatching { inputS3(file, path) }
+            .also { file.delete() }
+
+        return getS3Url(path)
+    }
+
+    private fun inputS3(file: File, path: String) {
+        try {
+            val inputStream = file.inputStream()
+            val objectMetadata = ObjectMetadata().apply {
+                contentLength = file.length()
+                contentType = Mimetypes.getInstance().getMimetype(file)
+            }
+
+            amazonS3Client.putObject(
+                PutObjectRequest(
+                    awsProperties.bucket,
+                    path,
+                    inputStream,
+                    objectMetadata
+                ).withCannedAcl(CannedAccessControlList.PublicRead)
+            )
+        } catch (e: IOException) {
+            throw IllegalArgumentException("File Exception")
+        }
+    }
+
+    private fun getS3Url(path: String): String {
+        return amazonS3Client.getUrl(awsProperties.bucket, path).toString()
+    }
+
+    override fun generateFileUrl(fileName: String, path: String): String {
+        val expiration = Date().apply {
+            time += EXP_TIME
+        }
+        return amazonS3Client.generatePresignedUrl(
+            GeneratePresignedUrlRequest(
+                awsProperties.bucket,
+                "${path}$fileName"
+            ).withMethod(HttpMethod.GET).withExpiration(expiration)
+        ).toString()
+    }
+}