src/tdlib/tdlibrequestfactory.cpp - develop - alexashkin/telegraph

src/tdlib/tdlibrequestfactory.cpp
1 381 строка47 KB
mbarashkov
Новый метод в requestFactory
21 фев 2025, 14:51
21 фев 2025, 14:51a2c6bb1
#include "tdlibrequestfactory.h"
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include <QRegularExpressionMatchIterator>
#include <QLocale>
#include <QSettings>
#include <QCoreApplication>
#include "../tdlibsecrets.h"

namespace
{
    const char ID[] = "id";
    const char _TYPE[] = "@type";
    const char TYPE[] = "type";
    const char _EXTRA[] = "@extra";
    const char LAST_NAME[] = "last_name";
    const char FIRST_NAME[] = "first_name";
    const char CHAT_ID[] = "chat_id";
    const char MESSAGE_ID[] = "message_id";
    const char TYPE_INPUT_MESSAGE_REPLY_TO_MESSAGE[] = "inputMessageReplyToMessage";
    const char REPLY_TO[] = "reply_to";
    const char VALUE[] = "value";
    const char USERNAME[] = "username";
    const char CHAT_LIST_MAIN[] = "chatListMain";
    const char CHAT_LIST_FOLDER[] = "chatListFolder";
    const char CHAT_LIST_ARCHIVE[] = "chatListArchive";
    const char THREAD_ID[] = "thread_id";
    const char REACTION_TYPE[] = "reaction_type";
    const char REACTION_TYPE_EMOJI[] = "reactionTypeEmoji";
    const char EMOJI[] = "emoji";
    const char CHAT_FOLDER_ID[] = "chat_folder_id";
}

static bool compareReplacements(const QVariant &replacement1, const QVariant &replacement2)
{
    const QVariantMap replacementMap1 = replacement1.toMap();
    const QVariantMap replacementMap2 = replacement2.toMap();

    return replacementMap1.value("startIndex").toInt() < replacementMap2.value("startIndex").toInt();
}

TDLibRequestFactory::TDLibRequestFactory(QObject *parent): QObject(parent)
{
}

QVariantMap TDLibRequestFactory::authenticationPhoneNumberRequest(const QString &phoneNumber)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setAuthenticationPhoneNumber");
    requestObject.insert("phone_number", phoneNumber);

    QVariantMap phoneNumberSettings;

    phoneNumberSettings.insert("allow_flash_call", false);
    phoneNumberSettings.insert("is_current_phone_number", true);
    requestObject.insert("settings", phoneNumberSettings);
    requestObject.insert(_EXTRA, "setAuthenticationPhoneNumber_extra_marker");
    return requestObject;
}

QVariantMap TDLibRequestFactory::authenticationCodeRequest(const QString &authenticationCode) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "checkAuthenticationCode");
    requestObject.insert("code", authenticationCode);
    requestObject.insert(_EXTRA, "checkAuthenticationCode_extra_marker");
    return requestObject;
}

QVariantMap TDLibRequestFactory::authenticationPasswordRequest(const QString &authenticationPassword) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "checkAuthenticationPassword");
    requestObject.insert("password", authenticationPassword);
    requestObject.insert(_EXTRA, "checkAuthenticationPassword_extra_marker");
    return requestObject;
}

QVariantMap TDLibRequestFactory::registerUserRequest(const QString &firstName, const QString &lastName) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "registerUser");
    requestObject.insert(FIRST_NAME, firstName);
    requestObject.insert(LAST_NAME, lastName);
    return requestObject;
}

QVariantMap TDLibRequestFactory::logoutRequest() {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "logOut");
    return requestObject;
}

QVariantMap TDLibRequestFactory::getChatsRequest(const int limit) {
    QVariantMap requestObject;
    requestObject.insert(_TYPE, "getChats");
    requestObject.insert("limit", limit);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getLoadChatsRequest(const int limit, const QString& chatListKind, const QString& extraMarker) {
    QVariantMap requestObject;
    requestObject.insert(_TYPE, "loadChats");
    QVariantMap chatListType;
    chatListType.insert(_TYPE, chatListKind);
    requestObject.insert("chat_list", chatListType);
    requestObject.insert("limit", limit);
    requestObject.insert(_EXTRA, extraMarker);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getLoadChatsFolderRequest(const qlonglong chatFolderId, const int limit) {
    QVariantMap requestObject;
    requestObject.insert(_TYPE, "loadChats");
    QVariantMap chatListType;
    chatListType.insert(_TYPE, "chatListFolder");
    if (chatFolderId != 0)
        chatListType.insert("chat_folder_id", chatFolderId);

    requestObject.insert("chat_list", chatListType);
    requestObject.insert("limit", limit);
    requestObject.insert(_EXTRA, "chatListFolder_extra_marker_" + QString::number(chatFolderId));
    return requestObject;
}

QVariantMap TDLibRequestFactory::downloadFileRequest(int fileId) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "downloadFile");
    requestObject.insert("file_id", fileId);
    requestObject.insert("synchronous", false);
    requestObject.insert("offset", 0);
    requestObject.insert("limit", 0);
    requestObject.insert("priority", 1);
    return requestObject;
}

QVariantMap TDLibRequestFactory::openChatRequest(const QString &chatId) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "openChat");
    requestObject.insert(CHAT_ID, chatId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::closeChatRequest(const QString &chatId) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "closeChat");
    requestObject.insert(CHAT_ID, chatId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::joinChatRequest(const QString &chatId) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "joinChat");
    requestObject.insert(CHAT_ID, chatId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::leaveChatRequest(const QString &chatId) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "leaveChat");
    requestObject.insert(CHAT_ID, chatId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::deleteChatRequest(const qlonglong chatId) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "deleteChat");
    requestObject.insert(CHAT_ID, chatId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getChatHistoryRequest(qlonglong chatId, qlonglong fromMessageId, int offset, int limit, bool onlyLocal) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getChatHistory");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("from_message_id", fromMessageId);
    requestObject.insert("offset", offset);
    requestObject.insert("limit", limit);
    requestObject.insert("only_local", onlyLocal);
    return requestObject;
}

QVariantMap TDLibRequestFactory::viewMessageRequest(qlonglong chatId, qlonglong messageId, bool force) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "viewMessages");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("force_read", force);

    QVariantList messageIds;

    messageIds.append(messageId);
    requestObject.insert("message_ids", messageIds);
    return requestObject;
}

QVariantMap TDLibRequestFactory::pinMessageRequest(const QString &chatId, const QString &messageId, bool disableNotification) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "pinChatMessage");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert("disable_notification", disableNotification);
    return requestObject;
}

QVariantMap TDLibRequestFactory::unpinMessageRequest(const QString &chatId, const QString &messageId) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "unpinChatMessage");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert(_EXTRA, "unpinChatMessage:" + chatId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::newSendMessageRequest(qlonglong chatId, qlonglong replyToMessageId)
{
    QVariantMap request;

    request.insert(_TYPE, "sendMessage");
    request.insert(CHAT_ID, chatId);

    if (replyToMessageId)
    {
        QVariantMap replyTo;

        replyTo.insert(_TYPE, TYPE_INPUT_MESSAGE_REPLY_TO_MESSAGE);
        replyTo.insert(MESSAGE_ID, replyToMessageId);
        request.insert(REPLY_TO, replyTo);
    }

    return request;
}

QVariantMap TDLibRequestFactory::sendPhotoMessageRequest(qlonglong chatId, const QString &filePath, const QString &message, qlonglong replyToMessageId) {
    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessagePhoto");

    QVariantMap formattedText;

    formattedText.insert("text", message);
    formattedText.insert(_TYPE, "formattedText");
    inputMessageContent.insert("caption", formattedText);

    QVariantMap photoInputFile;

    photoInputFile.insert(_TYPE, "inputFileLocal");
    photoInputFile.insert("path", filePath);
    inputMessageContent.insert("photo", photoInputFile);
    requestObject.insert("input_message_content", inputMessageContent);
    return requestObject;
}

QVariantMap TDLibRequestFactory::sendVideoMessageRequest(qlonglong chatId, const QString &filePath, const QString &message, qlonglong replyToMessageId) {
    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageVideo");

    QVariantMap formattedText;

    formattedText.insert("text", message);
    formattedText.insert(_TYPE, "formattedText");
    inputMessageContent.insert("caption", formattedText);

    QVariantMap videoInputFile;

    videoInputFile.insert(_TYPE, "inputFileLocal");
    videoInputFile.insert("path", filePath);
    inputMessageContent.insert("video", videoInputFile);
    requestObject.insert("input_message_content", inputMessageContent);
    return requestObject;
}

QVariantMap TDLibRequestFactory::sendDocumentMessageRequest(qlonglong chatId, const QString &filePath, const QString &message, qlonglong replyToMessageId) {
    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageDocument");

    QVariantMap formattedText;

    formattedText.insert("text", message);
    formattedText.insert(_TYPE, "formattedText");
    inputMessageContent.insert("caption", formattedText);

    QVariantMap documentInputFile;

    documentInputFile.insert(_TYPE, "inputFileLocal");
    documentInputFile.insert("path", filePath);
    inputMessageContent.insert("document", documentInputFile);
    requestObject.insert("input_message_content", inputMessageContent);
    return requestObject;
}

QVariantMap TDLibRequestFactory::sendVoiceNoteMessageRequest(qlonglong chatId, const QString &filePath, const QString &message, qlonglong replyToMessageId) {
    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageVoiceNote");

    QVariantMap formattedText;

    formattedText.insert("text", message);
    formattedText.insert(_TYPE, "formattedText");
    inputMessageContent.insert("caption", formattedText);

    QVariantMap documentInputFile;

    documentInputFile.insert(_TYPE, "inputFileLocal");
    documentInputFile.insert("path", filePath);
    inputMessageContent.insert("voice_note", documentInputFile);
    requestObject.insert("input_message_content", inputMessageContent);
    return requestObject;
}

QVariantMap TDLibRequestFactory::sendLocationMessageRequest(qlonglong chatId, double latitude, double longitude, double horizontalAccuracy, qlonglong replyToMessageId) {
    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageLocation");

    QVariantMap location;

    location.insert("latitude", latitude);
    location.insert("longitude", longitude);
    location.insert("horizontal_accuracy", horizontalAccuracy);
    location.insert(_TYPE, "location");
    inputMessageContent.insert("location", location);
    inputMessageContent.insert("live_period", 0);
    inputMessageContent.insert("heading", 0);
    inputMessageContent.insert("proximity_alert_radius", 0);
    requestObject.insert("input_message_content", inputMessageContent);
    return requestObject;
}

QVariantMap TDLibRequestFactory::sendStickerMessageRequest(qlonglong chatId, const QString &fileId, qlonglong replyToMessageId) {
    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageSticker");

    QVariantMap stickerInputFile;

    stickerInputFile.insert(_TYPE, "inputFileRemote");
    stickerInputFile.insert(ID, fileId);
    inputMessageContent.insert("sticker", stickerInputFile);
    requestObject.insert("input_message_content", inputMessageContent);
    return requestObject;
}

QVariantMap TDLibRequestFactory::sendPollMessageRequest(qlonglong chatId, const QString &question, const QVariantList &options, bool anonymous, int correctOption, bool multiple, const QString &explanation, qlonglong replyToMessageId) {
    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessagePoll");

    QVariantMap pollType;

    if (correctOption > -1)
    {
        pollType.insert(_TYPE, "pollTypeQuiz");
        pollType.insert("correct_option_id", correctOption);

        if (!explanation.isEmpty())
        {
            QVariantMap formattedExplanation;

            formattedExplanation.insert("text", explanation);
            pollType.insert("explanation", formattedExplanation);
        }
    }
    else
    {
        pollType.insert(_TYPE, "pollTypeRegular");
        pollType.insert("allow_multiple_answers", multiple);
    }

    inputMessageContent.insert(TYPE, pollType);
    inputMessageContent.insert("question", question);
    inputMessageContent.insert("options", options);
    inputMessageContent.insert("is_anonymous", anonymous);
    requestObject.insert("input_message_content", inputMessageContent);
    return requestObject;
}

QVariantMap TDLibRequestFactory::forwardMessagesRequest(const QString &chatId, const QString &fromChatId, const QVariantList &messageIds, bool sendCopy, bool removeCaption)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "forwardMessages");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("from_chat_id", fromChatId);
    requestObject.insert("message_ids", messageIds);
    requestObject.insert("send_copy", sendCopy);
    requestObject.insert("remove_caption", removeCaption);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getMessageRequest(qlonglong chatId, qlonglong messageId) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getMessage");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert(_EXTRA, QString("getMessage:%1:%2").arg(chatId).arg(messageId));
    return requestObject;
}

QVariantMap TDLibRequestFactory::getMessageLinkInfoRequest(const QString &url, const QString &extra) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getMessageLinkInfo");
    requestObject.insert("url", url);
    requestObject.insert(_EXTRA, extra == "" ? url : url + "|" + extra);

    return requestObject;
}

QVariantMap TDLibRequestFactory::getExternalLinkInfoRequest(const QString &url, const QString &extra) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getExternalLinkInfo");
    requestObject.insert("url", url);
    requestObject.insert(_EXTRA, extra == "" ? url : url + "|" + extra);

    return requestObject;
}

QVariantMap TDLibRequestFactory::getCallbackQueryAnswerRequest(const QString &chatId, const QString &messageId, const QVariantMap &payload) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getCallbackQueryAnswer");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert("payload", payload);

    return requestObject;
}

QVariantMap TDLibRequestFactory::getChatPinnedMessageRequest(const qlonglong chatId) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getChatPinnedMessage");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(_EXTRA, "getChatPinnedMessage:" + QString::number(chatId));
    return requestObject;
}

QVariantMap TDLibRequestFactory::sendTextMessageRequest(qlonglong chatId, const QString &message, qlonglong replyToMessageId) {
    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageText");

    // Postprocess message (e.g. for @-mentioning)
    QString processedMessage = message;
    QVariantList replacements;
    QRegularExpression atMentionIdRegex("\\@(\\d+)\\(([^\\)]+)\\)");
    QRegularExpressionMatchIterator atMentionIdMatchIterator = atMentionIdRegex.globalMatch(processedMessage);

    while (atMentionIdMatchIterator.hasNext())
    {
        QRegularExpressionMatch nextAtMentionId = atMentionIdMatchIterator.next();

        QVariantMap replacement;

        replacement.insert("startIndex", nextAtMentionId.capturedStart(0));
        replacement.insert("length", nextAtMentionId.capturedLength(0));
        replacement.insert("userId", nextAtMentionId.captured(1));
        replacement.insert("plainText", nextAtMentionId.captured(2));
        replacements.append(replacement);
    }

    QVariantMap formattedText;

    if (!replacements.isEmpty())
    {
        QVariantList entities;
        std::sort(replacements.begin(), replacements.end(), compareReplacements);
        QListIterator<QVariant> replacementsIterator(replacements);
        int offsetCorrection = 0;

        while (replacementsIterator.hasNext())
        {
            QVariantMap nextReplacement = replacementsIterator.next().toMap();
            int replacementStartOffset = nextReplacement.value("startIndex").toInt();
            int replacementLength = nextReplacement.value("length").toInt();
            QString replacementPlainText = nextReplacement.value("plainText").toString();

            processedMessage = processedMessage.replace(replacementStartOffset - offsetCorrection, replacementLength, replacementPlainText);

            QVariantMap entity;

            entity.insert("offset", replacementStartOffset - offsetCorrection);
            entity.insert("length", replacementPlainText.length());

            QVariantMap entityType;

            entityType.insert(_TYPE, "textEntityTypeMentionName");
            entityType.insert("user_id", nextReplacement.value("userId").toString());
            entity.insert(TYPE, entityType);
            entities.append(entity);
            offsetCorrection += replacementLength - replacementPlainText.length();
        }

        formattedText.insert("entities", entities);
    }

    formattedText.insert("text", processedMessage);
    formattedText.insert(_TYPE, "formattedText");
    inputMessageContent.insert("text", formattedText);
    requestObject.insert("input_message_content", inputMessageContent);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setOptionRequest(const QString &name, const QString &type, const QVariant &value) {
    QVariantMap optionValue;

    optionValue.insert(_TYPE, type);
    optionValue.insert(VALUE, value);

    QVariantMap request;

    request.insert(_TYPE, "setOption");
    request.insert("name", name);
    request.insert(VALUE, optionValue);
    request.insert(_EXTRA, "setOption_extra_marker");
    return request;
}

QVariantMap TDLibRequestFactory::setChatNotificationSettingsRequest(const QString &chatId, const QVariantMap &notificationSettings) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setChatNotificationSettings");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("notification_settings", notificationSettings);
    return requestObject;
}

QVariantMap TDLibRequestFactory::editMessageTextRequest(const QString &chatId, const QString &messageId, const QString &message) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "editMessageText");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);

    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageText");

    QVariantMap formattedText;

    formattedText.insert("text", message);
    inputMessageContent.insert("text", formattedText);
    requestObject.insert("input_message_content", inputMessageContent);
    return requestObject;
}

QVariantMap TDLibRequestFactory::deleteMessagesRequest(const QString &chatId, const QVariantList messageIds) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "deleteMessages");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("message_ids", messageIds);
    requestObject.insert("revoke", true);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getMapThumbnailFileRequest(const QString &chatId, double latitude, double longitude, int width, int height, const QString &extra) {
    QVariantMap location;

    location.insert("latitude", latitude);
    location.insert("longitude", longitude);

    // ensure dimensions are in bounds (16 - 1024)
    int boundsWidth = std::min(std::max(width, 16), 1024);
    int boundsHeight = std::min(std::max(height, 16), 1024);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getMapThumbnailFile");
    requestObject.insert("location", location);
    requestObject.insert("zoom", 17); // 13-20
    requestObject.insert("width", boundsWidth);
    requestObject.insert("height", boundsHeight);
    requestObject.insert("scale", 1); // 1-3
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(_EXTRA, extra);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getRecentStickersRequest() {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getRecentStickers");
    return requestObject;
}

QVariantMap TDLibRequestFactory::getInstalledStickerSetsRequest() {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getInstalledStickerSets");
    return requestObject;
}

QVariantMap TDLibRequestFactory::getStickerSetRequest(const QString &setId) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getStickerSet");
    requestObject.insert("set_id", setId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getSupergroupMembersRequest(const QString &groupId, int limit, int offset) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getSupergroupMembers");
    requestObject.insert(_EXTRA, groupId);
    requestObject.insert("supergroup_id", groupId);
    requestObject.insert("offset", offset);
    requestObject.insert("limit", limit);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getGroupFullInfoRequest(const QString &groupId, bool isSuperGroup) {
    QVariantMap requestObject;

    if (isSuperGroup)
    {
        requestObject.insert(_TYPE, "getSupergroupFullInfo");
        requestObject.insert("supergroup_id", groupId);
    }
    else
    {
        requestObject.insert(_TYPE, "getBasicGroupFullInfo");
        requestObject.insert("basic_group_id", groupId);
    }

    requestObject.insert(_EXTRA, groupId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getUserFullInfoRequest(const QString &userId) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getUserFullInfo");
    requestObject.insert(_EXTRA, userId);
    requestObject.insert("user_id", userId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::createPrivateChatRequest(const QString &userId, const QString &extra) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "createPrivateChat");
    requestObject.insert("user_id", userId);
    requestObject.insert(_EXTRA, extra);
    return requestObject;
}

QVariantMap TDLibRequestFactory::createNewSecretChatRequest(const QString &userId, const QString &extra) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "createNewSecretChat");
    requestObject.insert("user_id", userId);
    requestObject.insert(_EXTRA, extra);
    return requestObject;
}

QVariantMap TDLibRequestFactory::createSupergroupChatRequest(const QString &supergroupId, const QString &extra) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "createSupergroupChat");
    requestObject.insert("supergroup_id", supergroupId);
    requestObject.insert(_EXTRA, extra);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getChatSponsoredMessageRequest(qlonglong chatId) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getChatSponsoredMessages");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(_EXTRA, chatId); // see TDLibReceiver::processSponsoredMessage
    return requestObject;
}

QVariantMap TDLibRequestFactory::createBasicGroupChatRequest(const QString &basicGroupId, const QString &extra) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "createBasicGroupChat");
    requestObject.insert("basic_group_id", basicGroupId);
    requestObject.insert(_EXTRA, extra);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getGroupsInCommonRequest(const QString &userId, int limit, int offset) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getGroupsInCommon");
    requestObject.insert(_EXTRA, userId);
    requestObject.insert("user_id", userId);
    requestObject.insert("offset", offset);
    requestObject.insert("limit", limit);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getUserProfilePhotosRequest(const QString &userId, int limit, int offset) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getUserProfilePhotos");
    requestObject.insert(_EXTRA, userId);
    requestObject.insert("user_id", userId);
    requestObject.insert("offset", offset);
    requestObject.insert("limit", limit);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setChatPermissionsRequest(const QString &chatId, const QVariantMap &chatPermissions) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setChatPermissions");
    requestObject.insert(_EXTRA, chatId);
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("permissions", chatPermissions);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setChatSlowModeDelayRequest(const QString &chatId, int delay) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setChatSlowModeDelay");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("slow_mode_delay", delay);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setChatDescriptionRequest(const QString &chatId, const QString &description) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setChatDescription");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("description", description);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setChatTitleRequest(const QString &chatId, const QString &title) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setChatTitle");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("title", title);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setBioRequest(const QString &bio) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setBio");
    requestObject.insert("bio", bio);
    return requestObject;
}

QVariantMap TDLibRequestFactory::toggleSupergroupIsAllHistoryAvailableRequest(const QString &groupId, bool isAllHistoryAvailable) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "toggleSupergroupIsAllHistoryAvailable");
    requestObject.insert("supergroup_id", groupId);
    requestObject.insert("is_all_history_available", isAllHistoryAvailable);

    return requestObject;
}

QVariantMap TDLibRequestFactory::setPollAnswerRequest(const QString &chatId, qlonglong messageId, QVariantList optionIds) {
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setPollAnswer");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert("option_ids", optionIds);
    return requestObject;
}

QVariantMap TDLibRequestFactory::stopPollRequest(const QString &chatId, qlonglong messageId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "stopPoll");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getPollVotersRequest(const QString &chatId, qlonglong messageId, int optionId, int limit, int offset, const QString &extra)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getPollVoters");
    requestObject.insert(_EXTRA, extra);
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert("option_id", optionId);
    requestObject.insert("offset", offset);
    requestObject.insert("limit", limit); // max 50
    return requestObject;
}

QVariantMap TDLibRequestFactory::searchPublicChatRequest(const QString &userName)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "searchPublicChat");
    requestObject.insert(_EXTRA, "searchPublicChat:" + userName);
    requestObject.insert(USERNAME, userName);
    return requestObject;
}

QVariantMap TDLibRequestFactory::joinChatByInviteLinkRequest(const QString &inviteLink)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "joinChatByInviteLink");
    requestObject.insert("invite_link", inviteLink);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getDeepLinkInfoRequest(const QString &link)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getDeepLinkInfo");
    requestObject.insert("link", link);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getContactsRequest()
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getContacts");
    requestObject.insert(_EXTRA, "contactsRequested");
    return requestObject;
}

QVariantMap TDLibRequestFactory::getSecretChatRequest(qlonglong secretChatId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getSecretChat");
    requestObject.insert("secret_chat_id", secretChatId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::closeSecretChatRequest(qlonglong secretChatId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "closeSecretChat");
    requestObject.insert("secret_chat_id", secretChatId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::importContactsRequest(const QVariantList &contacts)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "importContacts");
    requestObject.insert("contacts", contacts);
    return requestObject;
}

QVariantMap TDLibRequestFactory::searchChatMessagesRequest(qlonglong chatId, const QString &query, qlonglong fromMessageId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "searchChatMessages");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("query", query);
    requestObject.insert("from_message_id", fromMessageId);
    requestObject.insert("offset", 0);
    requestObject.insert("limit", 50);
    requestObject.insert(_EXTRA, "searchChatMessages");
    return requestObject;
}

QVariantMap TDLibRequestFactory::searchPublicChatsRequest(const QString &query)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "searchPublicChats");
    requestObject.insert("query", query);
    requestObject.insert(_EXTRA, "searchPublicChats");
    return requestObject;
}

QVariantMap TDLibRequestFactory::readAllChatMentionsRequest(qlonglong chatId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "readAllChatMentions");
    requestObject.insert(CHAT_ID, chatId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::readAllChatReactionsRequest(qlonglong chatId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "readAllChatReactions");
    requestObject.insert(CHAT_ID, chatId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::toggleChatIsMarkedAsUnreadRequest(qlonglong chatId, bool isMarkedAsUnread)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "toggleChatIsMarkedAsUnread");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("is_marked_as_unread", isMarkedAsUnread);
    return requestObject;
}

QVariantMap TDLibRequestFactory::toggleChatIsPinnedRequest(qlonglong chatId, bool isPinned, QString folder, qlonglong folderId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "toggleChatIsPinned");

    QVariantMap chatListMap;

    if (folder.contains(CHAT_LIST_MAIN)) {
        chatListMap.insert(_TYPE, CHAT_LIST_MAIN);
    }

    if (folder.contains(CHAT_LIST_ARCHIVE)) {
        chatListMap.insert(_TYPE, CHAT_LIST_ARCHIVE);
    }

    if (folder.contains(CHAT_LIST_FOLDER)) {
        chatListMap.insert(_TYPE, CHAT_LIST_FOLDER);
        if (folderId != 0)
            chatListMap.insert("chat_folder_id", folderId);
    }

    requestObject.insert("chat_list", chatListMap);
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("is_pinned", isPinned);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setChatDraftMessageRequest(qlonglong chatId, qlonglong threadId, qlonglong replyToMessageId, const QString &draft)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setChatDraftMessage");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(THREAD_ID, threadId);

    QVariantMap draftMessage;
    QVariantMap inputMessageContent;
    QVariantMap formattedText;

    formattedText.insert("text", draft);
    formattedText.insert("clear_draft", draft.isEmpty());
    formattedText.insert(_TYPE, "formattedText");
    inputMessageContent.insert(_TYPE, "inputMessageText");
    inputMessageContent.insert("text", formattedText);
    draftMessage.insert(_TYPE, "draftMessage");
    draftMessage.insert("input_message_text", inputMessageContent);

    QVariantMap replyTo;

    replyTo.insert(_TYPE, TYPE_INPUT_MESSAGE_REPLY_TO_MESSAGE);
    replyTo.insert(CHAT_ID, chatId);
    replyTo.insert(MESSAGE_ID, replyToMessageId);
    draftMessage.insert(REPLY_TO, replyTo);

    requestObject.insert("draft_message", draftMessage);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getInlineQueryResultsRequest(qlonglong botUserId, qlonglong chatId, const QVariantMap &userLocation, const QString &query, const QString &offset, const QString &extra)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getInlineQueryResults");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("bot_user_id", botUserId);

    if (!userLocation.isEmpty())
        requestObject.insert("user_location", userLocation);

    requestObject.insert("query", query);
    requestObject.insert("offset", offset);
    requestObject.insert(_EXTRA, extra);
    return requestObject;
}

QVariantMap TDLibRequestFactory::sendInlineQueryResultMessageRequest(qlonglong chatId, qlonglong threadId, qlonglong replyToMessageId, const QString &queryId, const QString &resultId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "sendInlineQueryResultMessage");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("message_thread_id", threadId);
    requestObject.insert("reply_to_message_id", replyToMessageId);
    requestObject.insert("query_id", queryId);
    requestObject.insert("result_id", resultId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::sendBotStartMessageRequest(qlonglong botUserId, qlonglong chatId, const QString &parameter, const QString &extra)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "sendBotStartMessage");
    requestObject.insert("bot_user_id", botUserId);
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("parameter", parameter);
    requestObject.insert(_EXTRA, extra);
    return requestObject;
}

QVariantMap TDLibRequestFactory::cancelDownloadFileRequest(int fileId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "cancelDownloadFile");
    requestObject.insert("file_id", fileId);
    requestObject.insert("only_if_pending", false);
    return requestObject;
}

QVariantMap TDLibRequestFactory::cancelUploadFileRequest(int fileId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "cancelUploadFile");
    requestObject.insert("file_id", fileId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::deleteFileRequest(int fileId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "deleteFile");
    requestObject.insert("file_id", fileId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setNameRequest(const QString &firstName, const QString &lastName)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setName");
    requestObject.insert("first_name", firstName);
    requestObject.insert("last_name", lastName);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setUsernameRequest(const QString &userName)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setUsername");
    requestObject.insert("username", userName);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setProfilePhotoRequest(const QString &filePath)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setProfilePhoto");
    requestObject.insert(_EXTRA, "setProfilePhoto");

    QVariantMap inputChatPhoto;

    inputChatPhoto.insert(_TYPE, "inputChatPhotoStatic");

    QVariantMap inputFile;

    inputFile.insert(_TYPE, "inputFileLocal");
    inputFile.insert("path", filePath);
    inputChatPhoto.insert("photo", inputFile);
    requestObject.insert("photo", inputChatPhoto);
    return requestObject;
}

QVariantMap TDLibRequestFactory::deleteProfilePhotoRequest(const QString &profilePhotoId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "deleteProfilePhoto");
    requestObject.insert(_EXTRA, "deleteProfilePhoto");
    requestObject.insert("profile_photo_id", profilePhotoId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::changeStickerSetRequest(const QString &stickerSetId, bool isInstalled)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "changeStickerSet");
    requestObject.insert(_EXTRA, isInstalled ? "installStickerSet" : "removeStickerSet");
    requestObject.insert("set_id", stickerSetId);
    requestObject.insert("is_installed", isInstalled);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getActiveSessionsRequest()
{
    QVariantMap requestObject;
    requestObject.insert(_TYPE, "getActiveSessions");
    return requestObject;
}

QVariantMap TDLibRequestFactory::terminateSessionRequest(const QString &sessionId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "terminateSession");
    requestObject.insert(_EXTRA, "terminateSession");
    requestObject.insert("session_id", sessionId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getMessageAvailableReactionsRequest(qlonglong chatId, qlonglong messageId)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getMessageAvailableReactions");
    requestObject.insert(_EXTRA, QString::number(messageId));
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    return requestObject;
}

QVariantMap TDLibRequestFactory::addMessageReactionRequest(qlonglong chatId, qlonglong messageId, const QString &reaction)
{
    QVariantMap requestObject;

    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert("is_big", false);

    QVariantMap reactionType;

    reactionType.insert(_TYPE, REACTION_TYPE_EMOJI);
    reactionType.insert(EMOJI, reaction);
    requestObject.insert(REACTION_TYPE, reactionType);
    requestObject.insert(_TYPE, "addMessageReaction");
    return requestObject;
}

QVariantMap TDLibRequestFactory::removeMessageReactionRequest(qlonglong chatId, qlonglong messageId, const QString &reaction)
{
    QVariantMap requestObject;

    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);

    QVariantMap reactionType;

    reactionType.insert(_TYPE, REACTION_TYPE_EMOJI);
    reactionType.insert(EMOJI, reaction);
    requestObject.insert(REACTION_TYPE, reactionType);
    requestObject.insert(_TYPE, "removeMessageReaction");
    return requestObject;
}

QVariantMap TDLibRequestFactory::setInactiveSessionTtlRequest(int days)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setInactiveSessionTtl");
    requestObject.insert("inactive_session_ttl_days", days);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setEncryptionKeyRequest()
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "checkDatabaseEncryptionKey");
    // see https://github.com/tdlib/td/issues/188#issuecomment-379536139
    requestObject.insert("encryption_key", "");
    return requestObject;
}

QVariantMap TDLibRequestFactory::setLogVerbosityLevelRequest()
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setLogVerbosityLevel");
    requestObject.insert("new_verbosity_level", 2);
    requestObject.insert(_EXTRA, "setLogVerbosityLevel_extra_marker");
    return requestObject;
}

QVariantMap TDLibRequestFactory::getChatFolderRequest(qlonglong folderID)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getChatFolder");
    requestObject.insert(CHAT_FOLDER_ID, folderID);
    requestObject.insert(_EXTRA, "getChatFolder_extra_marker_" + QString::number(folderID));
    return requestObject;
}

QVariantMap TDLibRequestFactory::setNetworkTypeRequest(TDLibConstants::NetworkType networkType)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setNetworkType");
    requestObject.insert(_EXTRA, "setNetworkType");

    QVariantMap networkTypeObject;

    switch (networkType)
    {
    case TDLibConstants::NetworkType::Mobile:
        networkTypeObject.insert(_TYPE, "networkTypeMobile");
        break;
    case TDLibConstants::NetworkType::MobileRoaming:
        networkTypeObject.insert(_TYPE, "networkTypeMobileRoaming");
        break;
    case TDLibConstants::NetworkType::None:
        networkTypeObject.insert(_TYPE, "networkTypeNone");
        break;
    case TDLibConstants::NetworkType::Other:
        networkTypeObject.insert(_TYPE, "networkTypeOther");
        break;
    case TDLibConstants::NetworkType::WiFi:
        networkTypeObject.insert(_TYPE, "networkTypeWiFi");
        break;
    default:
        networkTypeObject.insert(_TYPE, "networkTypeOther");
        break;
    }

    requestObject.insert(TYPE, networkTypeObject);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setUserPrivacySettingRuleRequest(TDLibConstants::UserPrivacySetting setting, TDLibConstants::UserPrivacySettingRule rule)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setUserPrivacySettingRules");

    QVariantMap settingMap;

    switch (setting)
    {
    case TDLibConstants::SettingShowStatus:
        settingMap.insert(_TYPE, "userPrivacySettingShowStatus");
        break;
    case TDLibConstants::SettingShowPhoneNumber:
        settingMap.insert(_TYPE, "userPrivacySettingShowPhoneNumber");
        break;
    case TDLibConstants::SettingAllowChatInvites:
        settingMap.insert(_TYPE, "userPrivacySettingAllowChatInvites");
        break;
    case TDLibConstants::SettingShowProfilePhoto:
        settingMap.insert(_TYPE, "userPrivacySettingShowProfilePhoto");
        break;
    case TDLibConstants::SettingAllowFindingByPhoneNumber:
        settingMap.insert(_TYPE, "userPrivacySettingAllowFindingByPhoneNumber");
        break;
    case TDLibConstants::SettingShowLinkInForwardedMessages:
        settingMap.insert(_TYPE, "userPrivacySettingShowLinkInForwardedMessages");
        break;
    case TDLibConstants::SettingUnknown:
        break;
    }

    requestObject.insert("setting", settingMap);

    QVariantMap ruleMap;

    switch (rule)
    {
    case TDLibConstants::RuleAllowAll:
        ruleMap.insert(_TYPE, "userPrivacySettingRuleAllowAll");
        break;
    case TDLibConstants::RuleAllowContacts:
        ruleMap.insert(_TYPE, "userPrivacySettingRuleAllowContacts");
        break;
    case TDLibConstants::RuleRestrictAll:
        ruleMap.insert(_TYPE, "userPrivacySettingRuleRestrictAll");
        break;
    }

    QVariantList ruleMaps;

    ruleMaps.append(ruleMap);

    QVariantMap encapsulatedRules;

    encapsulatedRules.insert(_TYPE, "userPrivacySettingRules");
    encapsulatedRules.insert("rules", ruleMaps);
    requestObject.insert("rules", encapsulatedRules);
    return requestObject;
}

QVariantMap TDLibRequestFactory::getUserPrivacySettingRulesRequest(TDLibConstants::UserPrivacySetting setting)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getUserPrivacySettingRules");
    requestObject.insert(_EXTRA, setting);

    QVariantMap settingMap;

    switch (setting)
    {
    case TDLibConstants::SettingShowStatus:
        settingMap.insert(_TYPE, "userPrivacySettingShowStatus");
        break;
    case TDLibConstants::SettingShowPhoneNumber:
        settingMap.insert(_TYPE, "userPrivacySettingShowPhoneNumber");
        break;
    case TDLibConstants::SettingAllowChatInvites:
        settingMap.insert(_TYPE, "userPrivacySettingAllowChatInvites");
        break;
    case TDLibConstants::SettingShowProfilePhoto:
        settingMap.insert(_TYPE, "userPrivacySettingShowProfilePhoto");
        break;
    case TDLibConstants::SettingAllowFindingByPhoneNumber:
        settingMap.insert(_TYPE, "userPrivacySettingAllowFindingByPhoneNumber");
        break;
    case TDLibConstants::SettingShowLinkInForwardedMessages:
        settingMap.insert(_TYPE, "userPrivacySettingShowLinkInForwardedMessages");
        break;
    }

    requestObject.insert("setting", settingMap);
    return requestObject;
}

QVariantMap TDLibRequestFactory::setTdLibParametersRequest(QString dbDirectory)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setTdlibParameters");
    requestObject.insert(_EXTRA, "setTdlibParameters_extra_marker");

    requestObject.insert("api_id", TDLIB_API_ID);
    requestObject.insert("api_hash", TDLIB_API_HASH);
    requestObject.insert("database_directory", dbDirectory + "/tdlib");

    requestObject.insert("use_file_database", true);
    requestObject.insert("use_chat_info_database", true);
    requestObject.insert("use_message_database", true);
    requestObject.insert("use_secret_chats", true);
    requestObject.insert("system_language_code", QLocale::system().name());

    QSettings hardwareSettings("/etc/hw-release", QSettings::NativeFormat);

    requestObject.insert("device_model", hardwareSettings.value("NAME", "Unknown Mobile Device").toString());
    requestObject.insert("system_version", QSysInfo::prettyProductName());
    requestObject.insert("application_version", QCoreApplication::instance()->applicationVersion());
    requestObject.insert("enable_storage_optimizer", true);
    return requestObject;
}