채팅방 생성(유저 초대) 구현

 

채팅방 엔티티 생성

package hjp.hjchat.domain.chat.entity

import jakarta.persistence.*
import java.time.LocalDateTime

@Entity
@Table(name = "chat_room")
class ChatRoom(

    @Id @GeneratedValue
    val id: Long? = null,

    @OneToMany(mappedBy = "chatRoom", cascade = [CascadeType.ALL], orphanRemoval = true)
    val messages: List<Message> = mutableListOf(),

    @Column(name = "room_name")
    var roomName: String,

    @Column(name = "room_type")
    var roomType: String,

    @Column(name = "생성_날짜", updatable = false)
    val createdAt: LocalDateTime,

    @Column(name = "수정_날짜")
    var updatedAt: LocalDateTime? = null,


)

 

채팅방 생성 함수 추가

@MutationMapping
    fun createChatRoom(
        @Argument roomName: String,
        @Argument roomType: String,
    ): ChatRoom {

        val chatRoom = chatRoomRepository.save(
            ChatRoom(
                roomName = roomName,
                roomType = roomType.toUpperCase(),
                createdAt = LocalDateTime.now(),
                updatedAt = null
            )
        )
        return chatRoom
    }

 

GraphQL 스키마 추가 

type Message {
    id: ID,
    content: String
    sender: String
    timestamp: String
}
type ChatRoom {
    id: ID
    roomName: String
    roomType: String
    createdAt: String
    updatedAt: String
}

type Mutation {
    sendMessage(content: String!, chatRoomId: ID!): Message
    createChatRoom(roomName: String!, roomType: String!): ChatRoom
}

 

테스트

 

 

 

 

chat_room_member 추가 및 사용자 초대 

엔티티 추가

package hjp.hjchat.domain.chat.entity

import hjp.hjchat.domain.member.entity.MemberEntity
import jakarta.persistence.*
import java.time.LocalDateTime

@Entity
@Table(name = "chat_room_member")
class ChatRoomMember(

    @Id @GeneratedValue
    var id: Long? = null,

    @ManyToOne(fetch = FetchType.LAZY, cascade = [CascadeType.ALL])
    var chatRoom: ChatRoom,

    @ManyToOne(fetch = FetchType.LAZY)
    var member: MemberEntity,

    @Column(name= "채팅방_참여_시간")
    var joinedAt: LocalDateTime = LocalDateTime.now(),
    )

 

함수 추가

@MutationMapping
fun inviteUserToChatRoom(
    @AuthenticationPrincipal user: UserPrincipal,
    @Argument chatRoomId: Long,
    @Argument userId: Long,
): ChatRoomMember {

    val member = oAuthRepository.findById(user.memberId)
        .orElseThrow { IllegalArgumentException("Member not found") }

    val chatRoom = chatRoomRepository.findById(chatRoomId)
        .orElseThrow { IllegalArgumentException("Chat room not found") }

    val invitedMember = oAuthRepository.findById(userId)
        .orElseThrow { IllegalArgumentException("Invited member not found") }

    return chatRoomMemberRepository.save(
        ChatRoomMember(
            chatRoom = chatRoom,
            member = invitedMember,
        )
    )
}

 

기존 채팅방 생성 함수 수정

@MutationMapping
fun createChatRoom(
    @AuthenticationPrincipal user: UserPrincipal,
    @Argument roomName: String,
    @Argument roomType: String,
): ChatRoom {

    val member = oAuthRepository.findById(user.memberId)
        .orElseThrow { IllegalArgumentException("Member not found") }

    val chatRoom = chatRoomRepository.save(
        ChatRoom(
            roomName = roomName,
            roomType = roomType.toUpperCase(),
            createdAt = LocalDateTime.now(),
            updatedAt = null,
            members = mutableListOf(),
        )
    )

    chatRoomMemberRepository.save(
        ChatRoomMember(
            chatRoom = chatRoom,
            member = member,
        )
    )

    return chatRoom
}

 

스키마 추가

type Message {
    id: ID,
    content: String
    sender: String
    timestamp: String
}

type Mutation {
    sendMessage(content: String!, chatRoomId: ID!): Message
    createChatRoom(roomName: String!, roomType: String!): ChatRoom
    inviteUserToChatRoom(chatRoomId: ID!, userId: ID!): ChatRoomMember
}

type ChatRoom {
    id: ID
    roomName: String
    roomType: String
    createdAt: String
    updatedAt: String
    members: [ChatRoomMember]
}

type ChatRoomMember {
    id: ID
    memberId: ID
    chatRoomId: ID
    joinedAt: String
}

type Query {
    getMessages: [Message]
}

 

테스트 (채팅방 생성 및 초대)