feat: Create QuestionSheet

api/src/main/kotlin/com/mashup/dojo/scheduler/Scheduler.kt

@@ -25,7 +25,9 @@ class Scheduler(
     @Async("questionSheetSchedulerExecutor")
     fun createQuestionSheet() {
         log.info { "=== Start Create questionSheet at ${LocalDateTime.now()}. ===" }
-        questionUseCase.createQuestionSheet()
+
+        // ToDo 친구 관계 생성 후 주석 해제할 것
+        // questionUseCase.createQuestionSheet()
         log.info { "=== Done Create questionSheet at ${LocalDateTime.now()}. ===" }
     }
 }

entity/src/main/kotlin/com/mashup/dojo/MemberRelationRepository.kt

@@ -1,6 +1,7 @@
 package com.mashup.dojo
 
 import com.mashup.dojo.base.BaseTimeEntity
+import com.querydsl.core.types.dsl.Expressions
 import com.querydsl.jpa.impl.JPAQueryFactory
 import jakarta.persistence.Column
 import jakarta.persistence.Entity
@@ -48,6 +49,16 @@ interface MemberRelationQueryRepository {
         fromId: String,
         toId: String,
     ): Boolean
+
+    fun findRandomOfFriend(
+        memberId: String,
+        limit: Long,
+    ): List<String>
+
+    fun findRandomOfAccompany(
+        memberId: String,
+        limit: Long,
+    ): List<String>
 }
 
 class MemberRelationQueryRepositoryImpl(
@@ -92,6 +103,42 @@ class MemberRelationQueryRepositoryImpl(
         return findMemberRelation != null
     }
 
+    override fun findRandomOfFriend(
+        memberId: String,
+        limit: Long,
+    ): List<String> {
+        val memberRelation = QMemberRelationEntity.memberRelationEntity
+
+        return jpaQueryFactory
+            .select(memberRelation.toId)
+            .from(memberRelation)
+            .where(
+                memberRelation.fromId.eq(memberId),
+                memberRelation.relationType.eq(RelationType.FRIEND)
+            )
+            .orderBy(Expressions.numberTemplate(Double::class.java, "function('RAND')").asc())
+            .limit(limit)
+            .fetch()
+    }
+
+    override fun findRandomOfAccompany(
+        memberId: String,
+        limit: Long,
+    ): List<String> {
+        val memberRelation = QMemberRelationEntity.memberRelationEntity
+
+        return jpaQueryFactory
+            .select(memberRelation.toId)
+            .from(memberRelation)
+            .where(
+                memberRelation.fromId.eq(memberId),
+                memberRelation.relationType.eq(RelationType.ACCOMPANY)
+            )
+            .orderBy(Expressions.numberTemplate(Double::class.java, "function('RAND')").asc())
+            .limit(8)
+            .fetch()
+    }
+
     private fun findByFromIdAndRelationType(
         fromId: String,
         relationType: RelationType,

entity/src/main/kotlin/com/mashup/dojo/QuestionRepository.kt

@@ -1,6 +1,7 @@
 package com.mashup.dojo
 
 import com.mashup.dojo.base.BaseEntity
+import com.querydsl.jpa.impl.JPAQueryFactory
 import jakarta.persistence.Column
 import jakarta.persistence.Entity
 import jakarta.persistence.EnumType
@@ -12,7 +13,7 @@ import org.springframework.data.jpa.repository.JpaRepository
 import org.springframework.data.jpa.repository.Query
 import org.springframework.data.repository.query.Param
 
-interface QuestionRepository : JpaRepository<QuestionEntity, String> {
+interface QuestionRepository : JpaRepository<QuestionEntity, String>, QuestionRepositoryCustom {
     @Query("SELECT q FROM QuestionEntity q WHERE q.type = :type AND q.id NOT IN :excludeIds ORDER BY function('RAND')")
     fun findRandomQuestions(
         @Param("type") type: QuestionType,
@@ -54,3 +55,37 @@ enum class QuestionCategory {
     HUMOR,
     OTHER,
 }
+
+interface QuestionRepositoryCustom {
+    fun findFriendQuestionsByIds(questionIds: List<String>): List<String>
+
+    fun findAccompanyQuestionsByIds(questionIds: List<String>): List<String>
+}
+
+class QuestionRepositoryImpl(
+    private val queryFactory: JPAQueryFactory,
+) : QuestionRepositoryCustom {
+    override fun findFriendQuestionsByIds(questionIds: List<String>): List<String> {
+        val question = QQuestionEntity.questionEntity
+
+        return queryFactory.select(question.id)
+            .from(question)
+            .where(
+                question.type.eq(QuestionType.FRIEND),
+                question.id.`in`(questionIds)
+            )
+            .fetch()
+    }
+
+    override fun findAccompanyQuestionsByIds(questionIds: List<String>): List<String> {
+        val question = QQuestionEntity.questionEntity
+
+        return queryFactory.select(question.id)
+            .from(question)
+            .where(
+                question.type.eq(QuestionType.ACCOMPANY),
+                question.id.`in`(questionIds)
+            )
+            .fetch()
+    }
+}

service/src/main/kotlin/com/mashup/dojo/domain/Question.kt

@@ -66,4 +66,21 @@ data class QuestionSheet(
     val questionId: QuestionId,
     val resolverId: MemberId,
     val candidates: List<MemberId>,
-)
+) {
+    companion object {
+        fun create(
+            questionSetId: QuestionSetId,
+            questionId: QuestionId,
+            resolverId: MemberId,
+            candidates: List<MemberId>,
+        ): QuestionSheet {
+            return QuestionSheet(
+                questionSheetId = QuestionSheetId(UUIDGenerator.generate()),
+                questionSetId = questionSetId,
+                questionId = questionId,
+                resolverId = resolverId,
+                candidates = candidates
+            )
+        }
+    }
+}

service/src/main/kotlin/com/mashup/dojo/service/MemberRelationService.kt

@@ -32,6 +32,10 @@ interface MemberRelationService {
         fromId: MemberId,
         toId: MemberId,
     ): Boolean
+
+    fun findCandidateOfFriend(memberId: MemberId): List<MemberId>
+
+    fun findCandidateOfAccompany(memberId: MemberId): List<MemberId>
 }
 
 @Service
@@ -79,6 +83,28 @@ class DefaultMemberRelationService(
     ): Boolean {
         return memberRelationRepository.isFriend(fromId = fromId.value, toId = toId.value)
     }
+
+    override fun findCandidateOfFriend(memberId: MemberId): List<MemberId> {
+        return memberRelationRepository.findRandomOfFriend(
+            memberId = memberId.value,
+            limit = DEFAULT_CANDIDATE_SIZE
+        ).map {
+            MemberId(it)
+        }
+    }
+
+    override fun findCandidateOfAccompany(memberId: MemberId): List<MemberId> {
+        return memberRelationRepository.findRandomOfAccompany(
+            memberId = memberId.value,
+            limit = DEFAULT_CANDIDATE_SIZE
+        ).map {
+            MemberId(it)
+        }
+    }
+
+    companion object {
+        private const val DEFAULT_CANDIDATE_SIZE: Long = 8
+    }
 }
 
 private fun MemberRelation.toEntity(): MemberRelationEntity {

service/src/main/kotlin/com/mashup/dojo/service/QuestionService.kt

@@ -10,7 +10,6 @@ import com.mashup.dojo.QuestionSheetEntity
 import com.mashup.dojo.QuestionSheetRepository
 import com.mashup.dojo.Status
 import com.mashup.dojo.domain.ImageId
-import com.mashup.dojo.domain.Member
 import com.mashup.dojo.domain.MemberId
 import com.mashup.dojo.domain.PublishStatus
 import com.mashup.dojo.domain.PublishedTime
@@ -71,9 +70,11 @@ interface QuestionService {
         endAt: LocalDateTime,
     ): QuestionSet
 
-    fun createQuestionSheets(
+    fun createQuestionSheetsForMember(
         questionSet: QuestionSet,
-        members: List<Member>,
+        candidatesOfFriend: List<MemberId>,
+        candidatesOfAccompany: List<MemberId>,
+        resolver: MemberId,
     ): List<QuestionSheet>
 }
 
@@ -224,21 +225,51 @@ class DefaultQuestionService(
     }
 
     @Transactional
-    override fun createQuestionSheets(
+    override fun createQuestionSheetsForMember(
         questionSet: QuestionSet,
-        members: List<Member>,
+        candidatesOfFriend: List<MemberId>,
+        candidatesOfAccompany: List<MemberId>,
+        resolver: MemberId,
     ): List<QuestionSheet> {
         /**
-         * TODO:
+         * TODO: 여기 있는 애들은 해결된 것일까요?
          * target : members
          * question : QuestionSet
          * candidate : member.candidate()
          *
          * - make friend logic, get Candidate logic
+         *
+         * ToDo 아래는 추후 캐시에 넣는 작업을 해야합니다.
          * - cache put -> QuestionSet and return
          * - Temporarily set to create for all members, discuss details later
          */
-        return LIST_SAMPLE_QUESTION_SHEET
+
+        val questionIds = questionSet.questionIds.map { questionOrder -> questionOrder.questionId.value }
+        val friendQuestionIds = questionRepository.findFriendQuestionsByIds(questionIds)
+        val accompanyQuestionIds = questionRepository.findAccompanyQuestionsByIds(questionIds)
+
+        val friendQuestionSheetEntities =
+            friendQuestionIds.map { friendQuestionId ->
+                QuestionSheet.create(
+                    questionSetId = questionSet.id,
+                    questionId = QuestionId(friendQuestionId),
+                    resolverId = resolver,
+                    candidates = candidatesOfFriend
+                ).toEntity()
+            }
+
+        val accompanyQuestionSheetEntities =
+            accompanyQuestionIds.map { friendQuestionId ->
+                QuestionSheet.create(
+                    questionSetId = questionSet.id,
+                    questionId = QuestionId(friendQuestionId),
+                    resolverId = resolver,
+                    candidates = candidatesOfAccompany
+                ).toEntity()
+            }
+
+        val questionSheetEntities = friendQuestionSheetEntities + accompanyQuestionSheetEntities
+        return questionSheetRepository.saveAll(questionSheetEntities).map { it.toQuestionSheetWithCandidatesId() }
     }
 
     override fun getQuestionById(id: QuestionId): Question? {
@@ -379,6 +410,16 @@ private fun QuestionSetEntity.toQuestionSet(): QuestionSet {
     )
 }
 
+private fun QuestionSheet.toEntity(): QuestionSheetEntity {
+    return QuestionSheetEntity(
+        id = questionSheetId.value,
+        questionSetId = questionSetId.value,
+        questionId = questionId.value,
+        resolverId = resolverId.value,
+        candidates = candidates.map { it.value }.toList()
+    )
+}
+
 private fun QuestionSheetEntity.toQuestionSheetWithCandidatesId(): QuestionSheet {
     return QuestionSheet(
         questionSheetId = QuestionSheetId(id),

service/src/main/kotlin/com/mashup/dojo/usecase/QuestionUseCase.kt

@@ -13,6 +13,7 @@ import com.mashup.dojo.domain.QuestionSheet
 import com.mashup.dojo.domain.QuestionSheetId
 import com.mashup.dojo.domain.QuestionType
 import com.mashup.dojo.service.ImageService
+import com.mashup.dojo.service.MemberRelationService
 import com.mashup.dojo.service.MemberService
 import com.mashup.dojo.service.PickService
 import com.mashup.dojo.service.QuestionService
@@ -85,6 +86,7 @@ class DefaultQuestionUseCase(
     private val memberService: MemberService,
     private val pickService: PickService,
     private val imageService: ImageService,
+    private val memberRelationService: MemberRelationService,
 ) : QuestionUseCase {
     @Transactional
     override fun create(command: QuestionUseCase.CreateCommand): QuestionId {
@@ -120,7 +122,18 @@ class DefaultQuestionUseCase(
     override fun createQuestionSheet(): List<QuestionSheet> {
         val currentQuestionSet = questionService.getNextOperatingQuestionSet() ?: throw DojoException.of(DojoExceptionType.QUESTION_SET_NOT_READY)
         val allMemberRecords = memberService.findAllMember()
-        return questionService.createQuestionSheets(currentQuestionSet, allMemberRecords)
+        // ToDo Default 친구 수가 8명 이하일 경우 오류 발생하므로, 친구가 8명이 아니면 회원가입 불가능
+
+        return allMemberRecords.flatMap { member ->
+            val candidateOfFriend = memberRelationService.findCandidateOfFriend(member.id)
+            val candidateOfAccompany = memberRelationService.findCandidateOfAccompany(member.id)
+            questionService.createQuestionSheetsForMember(
+                questionSet = currentQuestionSet,
+                candidatesOfFriend = candidateOfFriend,
+                candidatesOfAccompany = candidateOfAccompany,
+                resolver = member.id
+            )
+        }
     }
 
     override fun getQuestionSheetList(memberId: MemberId): QuestionUseCase.GetQuestionSheetsResult {