fun getSlackMessageEvent()

in space-slack-sync/src/main/kotlin/org/jetbrains/spaceSlackSync/slack/SlackMessageType.kt [99:211]
102 lines of code
5 McCabe index (conditional complexity)

fun getSlackMessageEvent(requestBodyJson: JsonElement, requestBody: String): SlackMessageEvent? {
    val eventJson = requestBodyJson.jsonObject["event"]
    if (eventJson == null) {
        log.debug("SKIP Slack message: `event` JSON field is not found")
        return null
    }

    val type = getSlackMessageType(eventJson)

    return when (type) {
        SlackMessageType.NEW_MESSAGE -> {
            val message = gson.fromJson(requestBody, MessagePayload::class.java)
            val messageEvent = message.event
            val attachmentBlocks = message.event.attachments.orEmpty().flatMap { it.blocks.orEmpty() }
            val fields = message.event.attachments.orEmpty().flatMap { it.fields.orEmpty() }
            val color = message.event.attachments.orEmpty().firstOrNull()?.color
            SlackMessageEvent.MessageCreated(
                channelId = messageEvent.channel,
                teamId = messageEvent.team ?: message.teamId,
                messageId = messageEvent.ts,
                threadId = messageEvent.threadTs,
                files = messageEvent.files,
                blocks = messageEvent.blocks.orEmpty() + attachmentBlocks,
                fields = fields,
                text = messageEvent.text,
                botProfile = messageEvent.botProfile,
                userId = messageEvent.user,
                color = color,
            )
        }

        SlackMessageType.MESSAGE_EDITED -> {
            val message = gson.fromJson(requestBody, MessagePayload::class.java)
            val messageEvent = message.event
            val newMessageJson = eventJson.jsonObject["message"]
            if (newMessageJson == null) {
                log.debug("SKIP Slack message: `event -> message` JSON field not found for ${SlackMessageType.MESSAGE_EDITED} message type")
                return null
            }

            val previousMessageJson = eventJson.jsonObject["previous_message"]
            if (previousMessageJson == null) {
                log.debug("SKIP Slack message: `event -> previous_message` JSON field not found for ${SlackMessageType.MESSAGE_EDITED} message type")
                return null
            }

            val previousMessage = gson.fromJson(previousMessageJson.toString(), MessageEvent::class.java)
            val newMessage = gson.fromJson(newMessageJson.toString(), MessageEvent::class.java)
            val fields = newMessage.attachments.orEmpty().flatMap { it.fields.orEmpty() }
            val attachmentBlocks = newMessage.attachments.orEmpty().flatMap { it.blocks.orEmpty() }
            val color = newMessage.attachments.orEmpty().firstOrNull()?.color

            SlackMessageEvent.MessageUpdated(
                channelId = messageEvent.channel,
                teamId = newMessage.team ?: previousMessage.team ?: message.teamId,
                messageId = previousMessage.ts,
                threadId = previousMessage.threadTs,
                files = newMessage.files,
                blocks = newMessage.blocks.orEmpty() + attachmentBlocks,
                fields = fields,
                text = newMessage.text,
                botProfile = newMessage.botProfile,
                userId = newMessage.user,
                editedTs = newMessage.ts,
                color = color,
            )
        }

        SlackMessageType.MESSAGE_DELETED -> {
            val message = gson.fromJson(requestBody, MessagePayload::class.java)
            val messageEvent = message.event

            val previousMessageJson = eventJson.jsonObject["previous_message"]
            if (previousMessageJson == null) {
                log.debug("SKIP Slack message: `event -> previous_message` JSON field not found for ${SlackMessageType.MESSAGE_DELETED} message type")
                return null
            }

            val previousMessage = gson.fromJson(previousMessageJson.toString(), MessageEvent::class.java)
            SlackMessageEvent.MessageDeleted(
                channelId = messageEvent.channel,
                teamId = previousMessage.team ?: message.teamId,
                messageId = previousMessage.ts,
                threadId = previousMessage.threadTs,
                userId = previousMessage.user,
            )
        }

        SlackMessageType.USER_JOINED_CHANNEL -> {
            val message = gson.fromJson(requestBody, MessagePayload::class.java)
            val messageEvent = message.event
            val invitedById = eventJson.jsonObject["inviter"]?.jsonPrimitive?.content
            SlackMessageEvent.ChannelJoin(
                teamId = message.teamId,
                channelId = messageEvent.channel,
                messageId = messageEvent.ts,
                joinedUserId = messageEvent.user,
                invitedById = invitedById
            )
        }

        SlackMessageType.USER_LEFT_CHANNEL -> {
            val message = gson.fromJson(requestBody, MessagePayload::class.java)
            val messageEvent = message.event
            SlackMessageEvent.ChannelLeave(
                teamId = message.teamId,
                channelId = messageEvent.channel,
                messageId = messageEvent.ts,
                leftUserId = messageEvent.user,
            )
        }
    }
}