Для тех, кто не в теме, PureData — это визуальная среда для создания музыки и мультимедиа-инсталляций, где логика также строится из соединенных друг с другом блоков. И там ценность часто имеет не только звучание, но и сам визуальный вид получившегося «патча» — сложное, причудливое переплетение связей становится частью шоу.

import groovy.json.JsonSlurper

def flowFile = session.get()
if (!flowFile) return

try {
    def content = session.read(flowFile).getText('UTF-8')
    def update = new JsonSlurper().parseText(content)

    def eventType = update.callback_query ? "callback" :
                    update.message?.text?.startsWith('/') ? "command" : "unknown"
    def messageData = update.callback_query?.data ?: update.message?.text ?: ""
    def chatId = update.message?.chat?.id ?: update.callback_query?.message?.chat?.id ?: ""

    // Сохраняем все в атрибуты и передаем дальше
    flowFile = session.putAllAttributes(flowFile, [
        'telegram.event_type': eventType,
        'telegram.message_data': messageData,
        'telegram.chat_id': chatId.toString()
    ])

    // Просто передаем дальше, а роутинг сделаем RouteOnAttribute
    session.transfer(flowFile, REL_SUCCESS)

} catch (e) {
    log.error("Ошибка формирования запроса: " + e, e)
    flowFile = session.putAttribute(flowFile, 'error.message', e.message)
    session.transfer(flowFile, REL_FAILURE)
}

import groovy.json.JsonSlurper
import groovy.json.JsonOutput

def flowFile = session.get()
if (!flowFile) return

try {
    // 1. Получаем данные из атрибутов
    def callbackData = flowFile.getAttribute('telegram.message_data')
    def currentScene = flowFile.getAttribute('current_scene') ?: "start"
    def configFile = flowFile.getAttribute('configFile')  

    // 2. Загружаем конфигурацию
    def config = new JsonSlurper().parse(new File(configFile))
    // 3. Обрабатываем callback и получаем результат
    def result = processCallback(callbackData, currentScene, config)
    def response = result.response
    def newScene = result.scene 

    // Определяем endpoint based on media type
    def endpoint = 'sendMessage'
        if (response.photo) {
            endpoint = 'sendPhoto'
        } else if (response.video) {
            endpoint = 'sendVideo'
        } else if (response.audio) {
            endpoint = 'sendAudio'
        }

    // 4. Добавляем кнопки меню
    addMenuButtons(response)

    // Сохраняем результат
    flowFile = session.putAllAttributes(flowFile, [
        'current_scene': newScene,
        'telegram.endpoint': endpoint,
        'response.json': JsonOutput.toJson(response),
        'response.parse_mode': 'MarkdownV2'
    ])

    session.transfer(flowFile, REL_SUCCESS)
} catch (e) {
    log.error("Ошибка формирования запроса: " + e, e)
    flowFile = session.putAttribute(flowFile, 'error.message', e.message)
    session.transfer(flowFile, REL_FAILURE)
}

// Главная функция обработки callback
def processCallback(callbackData, currentScene, config) {
    def result = [response: [:], scene: currentScene]
    switch (callbackData) {
        case { it?.startsWith("scene:") }:
            result = handleSceneTransition(callbackData, config, currentScene)
            break
        case { it?.startsWith("quest:") && !it?.contains(":answer:") }:
            result = handleQuestStart(callbackData, config, currentScene)
            break
        case { it?.startsWith("quest:") && it?.contains(":answer:") }:
            result = handleQuestAnswer(callbackData, config, currentScene)
            break
        default:
            result.response = [text: "⚠️ Неизвестная команда"]
            break
    }
    return result
} 

// Обработка переходов между сценами
def handleSceneTransition(callbackData, config, currentScene) {
    def sceneName = callbackData.replace("scene:", "")
    return [
        response: config.scenes[sceneName],
        scene: sceneName
    ]
}  

// Обработка начала квеста
def handleQuestStart(callbackData, config, currentScene) {
    def questId = callbackData.replace("quest:", "")
    def quest = config.quests[questId]
    if (quest) {
        return [
            response: buildQuestResponse(quest),
            scene: "quest:" + questId
        ]
    } else {
        return [
            response: [text: "❌ Задание не найдено"],
            scene: currentScene
        ]
    }
}

// Обработка ответов на вопросы квестов
def handleQuestAnswer(callbackData, config, currentScene) {
    def parts = callbackData.split(":")
    if (parts.size() >= 4) {
        def questId = parts[1]
        def quest = config.quests[questId]
        if (quest) {
            def answer = quest.answers[callbackData]
            if (answer) {
                return handleAnswerTransition(answer, config, currentScene)
            } else {
                return [
                    response: [text: "❌ Ответ не найден"],
                    scene: currentScene
                ]
            }
        } else {
            return [
                response: [text: "❌ Задание не найдено"],
                scene: currentScene
            ]
        }
    } else {
        return [
            response: [text: "⚠️ Неверный формат ответа"],
            scene: currentScene
        ]
    }
}

// Обработка перехода к следующему квесту (тоже нужно обновить)
def handleQuestTransition(nextQuestId, config, currentScene) {
    def questId = nextQuestId.replace("quest:", "")
    def nextQuest = config.quests[questId]
    if (nextQuest) {
        return [
            response: buildQuestResponse(nextQuest),
            scene: "quest:" + questId
        ]
    } else {
        return [
            response: [text: "❌ Следующее задание не найдено"],
            scene: currentScene
        ]
    }
}

  

// Обновленная функция создания ответа для квеста
def buildQuestResponse(quest) {
    if (!quest) return [text: "❌ Ошибка: задание не найдено"]
    def response = [:]
    // Добавляем медиафайлы если есть
    if (quest.image) {
        response.photo = "/opt/nifi/quest/images/" + quest.image
        response.caption = quest.text
        response.parse_mode = 'MarkdownV2'
    } else if (quest.video) {
        response.video = "/opt/nifi/quest/video/" + quest.video  
        response.caption = quest.text
        response.parse_mode = 'MarkdownV2'
    } else if (quest.audio) {
        response.audio = "/opt/nifi/quest/audio/" + quest.audio
        response.caption = quest.text
        response.parse_mode = 'MarkdownV2'
    } else {
        // Если нет медиа - просто текст
        response.text = quest.text
        response.parse_mode = 'MarkdownV2'
    }

    // Добавляем кнопки ответов если есть
    if (quest.answers) {
        def keyboard = []
        quest.answers.each { key, answer ->
            keyboard << [text: answer.text, callback_data: key]
        }
        response.reply_markup = [inline_keyboard: [keyboard]]
    }
    return response
}

// Добавление кнопок меню к ответу
def addMenuButtons(response) {
    if (response && response instanceof Map) {
        // Если response - простой текст (без reply_markup)
        if (!response.reply_markup && response.text) {
            response.reply_markup = [inline_keyboard: []]
        }

        // Добавляем кнопки меню
        if (response.reply_markup) {
            def menuButton = [text: "? Меню", callback_data: "scene:start"]
            def helpButton = [text: "❓ Помощь", callback_data: "scene:help"]
            def menuRow = [menuButton, helpButton]
            if (response.reply_markup.inline_keyboard instanceof List) {
                response.reply_markup.inline_keyboard.add(menuRow)
            } else {
                response.reply_markup.inline_keyboard = [menuRow]
            }
        }
    }
}

// Обработка переходов по ответам
def handleAnswerTransition(answer, config, currentScene) {
    if (!answer) {
        return [response: [text: "❌ Ответ не распознан"], scene: currentScene]
    }

    def result = [scene: currentScene]
    // Обрабатываем переход
    if (answer.next) {
        if (answer.next.startsWith("quest:")) {
            def nextQuestId = answer.next.replace("quest:", "")
            def nextQuest = config.quests[nextQuestId]
            if (nextQuest) {
                result.response = buildQuestResponse(nextQuest)
                result.scene = "quest:" + nextQuestId
            }
        } else if (answer.next.startsWith("scene:")) {
            def sceneName = answer.next.replace("scene:", "")
            def nextScene = config.scenes[sceneName]
            if (nextScene) {
                result.response = nextScene
                result.scene = sceneName
            }
        }
    }

    // Если есть response - добавляем/заменяем текст

    if (answer.response) {
        if (result.response && result.response.text) {
            // Добавляем response к существующему тексту
            result.response.text = answer.response + "\n\n" + result.response.text
        } else {
            // Создаем новое текстовое сообщение
            result.response = [text: answer.response, parse_mode: 'MarkdownV2']
        }
    }
    return result
}

import org.apache.nifi.processor.io.StreamCallback
import groovy.json.JsonSlurper
import groovy.json.JsonOutput

def flowFile = session.get()
if (!flowFile) return

try {
    // Берем готовый JSON из атрибута
    def responseJson = flowFile.getAttribute('response.json')
    def telegramRequest = new JsonSlurper().parseText(responseJson)
    
    // Добавляем обязательные поля
    telegramRequest.chat_id = flowFile.getAttribute('telegram.chat_id')
    telegramRequest.parse_mode = flowFile.getAttribute('response.parse_mode') ?: 'MarkdownV2'
    
    // Конвертируем обратно в JSON
    def jsonOutput = JsonOutput.toJson(telegramRequest)
    
    // Перезаписываем содержимое FlowFile
    flowFile = session.write(flowFile, { inputStream, outputStream ->
        outputStream.write(jsonOutput.getBytes('UTF-8'))
    } as StreamCallback)
    
    session.transfer(flowFile, REL_SUCCESS)
} catch (e) {
    log.error("Ошибка формирования запроса: " + e, e)
    flowFile = session.putAttribute(flowFile, 'error.message', e.message)
    session.transfer(flowFile, REL_FAILURE)
}