src/data/messagedata.cpp - develop - erhoof/telegraf

src/data/messagedata.cpp
240 строк8 KB
Nikolay Sinyov
- Добавление логики для работы с комментариеями в канале
16 сен 2025, 14:15
16 сен 2025, 14:1547faecf
#include "messagedata.h"

namespace {
    const char CONTENT[] = "content";
    const char SENDER_ID[] = "sender_id";
    const char USER_ID[] = "user_id";
    const char REPLY_MARKUP[] = "reply_markup";
    const char _TYPE[] = "@type";
    const char INTERACTION_INFO[] = "interaction_info";
    const char VIEW_COUNT[] = "view_count";
    const char REACTIONS[] = "reactions";
    const char CHAT_ID[] = "chat_id";
    const char TYPE_SPONSORED_MESSAGE[] = "sponsoredMessage";
    const char MESSAGE_THREAD_ID[] = "message_thread_id";
}

ChatModel::MessageData::MessageData(const QVariantMap &data, qlonglong msgid) :
    messageData(data),
    messageId(msgid),
    messageThreadId(data.value(MESSAGE_THREAD_ID).toLongLong()),
    messageType(data.value(_TYPE).toString()),
    messageContentType(data.value(CONTENT).toMap().value(_TYPE).toString()),
    viewCount(data.value(INTERACTION_INFO).toMap().value(VIEW_COUNT).toInt()),
    reactions(data.value(INTERACTION_INFO).toMap().value(REACTIONS).toMap().value(REACTIONS).toList()),
    albumEntryFilter(false),
    albumMessageIds(QVariantList())
{
}

QVector<int> ChatModel::MessageData::flagsToRoles(uint flags)
{
    QVector<int> roles;
    if (flags & RoleFlagDisplay) {
        roles.append(RoleDisplay);
    }
    if (flags & RoleFlagMessageId) {
        roles.append(RoleMessageId);
    }
    if (flags & RoleFlagMessageThreadId) {
        roles.append(RoleMessageThreadId);
    }
    if (flags & RoleFlagMessageContentType) {
        roles.append(RoleMessageContentType);
    }
    if (flags & RoleFlagMessageViewCount) {
        roles.append(RoleMessageViewCount);
    }
    if (flags & RoleFlagMessageReactions) {
        roles.append(RoleMessageReactions);
    }
    if (flags & RoleFlagMessageAlbumEntryFilter) {
        roles.append(RoleMessageAlbumEntryFilter);
    }
    if (flags & RoleFlagMessageAlbumMessageIds) {
        roles.append(RoleMessageAlbumMessageIds);
    }
    return roles;
}

qlonglong ChatModel::MessageData::senderUserId() const
{
    return messageData.value(SENDER_ID).toMap().value(USER_ID).toLongLong();
}

qlonglong ChatModel::MessageData::senderChatId() const
{
    return messageData.value(SENDER_ID).toMap().value(CHAT_ID).toLongLong();
}

bool ChatModel::MessageData::senderIsChat() const
{
    return messageData.value(SENDER_ID).toMap().value(_TYPE).toString() == "messageSenderChat";
}

QVector<int> ChatModel::MessageData::diff(const MessageData *message) const
{
    QVector<int> roles;
    if (message != this) {
        roles.append(RoleDisplay);
        if (message->messageId != messageId) {
            roles.append(RoleMessageId);
        }
        if (message->messageThreadId != messageThreadId) {
            roles.append(RoleMessageThreadId);
        }
        if (message->messageContentType != messageContentType) {
            roles.append(RoleMessageContentType);
        }
        if (message->viewCount != viewCount) {
            roles.append(RoleMessageViewCount);
        }
        if (message->reactions != reactions) {
            roles.append(RoleMessageReactions);
        }
        if (message->albumEntryFilter != albumEntryFilter) {
            roles.append(RoleMessageAlbumEntryFilter);
        }
        if (message->albumMessageIds != albumMessageIds) {
            roles.append(RoleMessageAlbumMessageIds);
        }
    }
    return roles;
}

uint ChatModel::MessageData::updateMessageData(const QVariantMap &data)
{
    messageData = data;
    messageType = data.value(_TYPE).toString();
    messageThreadId = data.value(MESSAGE_THREAD_ID).toLongLong();
    return RoleFlagDisplay |
        updateContentType(data.value(CONTENT).toMap()) |
        updateInteractionInfo(data.value(INTERACTION_INFO).toMap());
}

QVector<int> ChatModel::MessageData::setMessageData(const QVariantMap &data)
{
    return flagsToRoles(updateMessageData(data));
}

uint ChatModel::MessageData::updateContentType(const QVariantMap &content)
{
    const QString oldContentType(messageContentType);
    messageContentType = content.value(_TYPE).toString();
    return (oldContentType == messageContentType) ? 0 : RoleFlagMessageContentType;
}

uint ChatModel::MessageData::updateContent(const QVariantMap &content)
{
    messageData.insert(CONTENT, content);
    return RoleFlagDisplay | updateContentType(content);
}

QVector<int> ChatModel::MessageData::setContent(const QVariantMap &content)
{
    return flagsToRoles(updateContent(content));
}

uint ChatModel::MessageData::updateReplyMarkup(const QVariantMap &replyMarkup)
{
    messageData.insert(REPLY_MARKUP, replyMarkup);
    return RoleFlagDisplay;
}

QVector<int> ChatModel::MessageData::setReplyMarkup(const QVariantMap &replyMarkup)
{
    return flagsToRoles(updateReplyMarkup(replyMarkup));
}

uint ChatModel::MessageData::updateViewCount(const QVariantMap &interactionInfo)
{
    const int oldViewCount = viewCount;
    viewCount = interactionInfo.value(VIEW_COUNT).toInt();
    return (viewCount == oldViewCount) ? 0 : RoleFlagMessageViewCount;
}

uint ChatModel::MessageData::updateInteractionInfo(const QVariantMap &interactionInfo)
{
    messageData.insert(INTERACTION_INFO, interactionInfo);
    return RoleFlagDisplay | updateViewCount(interactionInfo) | updateReactions(interactionInfo);
}

uint ChatModel::MessageData::updateReactions(const QVariantMap &interactionInfo)
{
    const QVariantList oldReactions = reactions;
    reactions = interactionInfo.value(REACTIONS).toMap().value(REACTIONS).toList();
    return (reactions == oldReactions) ? 0 : RoleFlagMessageReactions;
}

uint ChatModel::MessageData::updateAlbumEntryFilter(const bool isAlbumChild)
{
    const bool oldAlbumFiltered = albumEntryFilter;
    albumEntryFilter = isAlbumChild;
    return (isAlbumChild == oldAlbumFiltered) ? 0 : RoleFlagMessageAlbumEntryFilter;
}


QVector<int> ChatModel::MessageData::setAlbumEntryFilter(bool isAlbumChild)
{
    return flagsToRoles(updateAlbumEntryFilter(isAlbumChild));
}

uint ChatModel::MessageData::updateAlbumEntryMessageIds(const QVariantList &newAlbumMessageIds)
{
    const QVariantList oldAlbumMessageIds = albumMessageIds;
    albumMessageIds = newAlbumMessageIds;
    return (newAlbumMessageIds == oldAlbumMessageIds) ? 0 : RoleFlagMessageAlbumMessageIds;
}

QVector<int> ChatModel::MessageData::setAlbumEntryMessageIds(const QVariantList &newAlbumMessageIds)
{
    return flagsToRoles(updateAlbumEntryMessageIds(newAlbumMessageIds));
}

QVector<int> ChatModel::MessageData::setProperties(bool canBeEdited, bool canBePinned, bool canBeDeleted, bool canGetMessageThread)
{
    QVector<int> roles;
    if(canBeEdited != this->canBeEdited)
    {
        this->canBeEdited = canBeEdited;
        roles.append(RoleCanBeEdited);
    }
    if(canBePinned != this->canBePinned)
    {
        this->canBePinned = canBePinned;
        roles.append(RoleCanBePinned);
    }
    if(canBeDeleted != this->canBeDeleted)
    {
        this->canBeDeleted = canBeDeleted;
        roles.append(RoleCanBeDeleted);
    }

    if (canGetMessageThread != this->canGetMessageThread)
    {
        this->canGetMessageThread = canGetMessageThread;
        roles.append(RoleCanGetMessageThread);
    }
    return roles;
}

QVector<int> ChatModel::MessageData::setInteractionInfo(const QVariantMap &info)
{
    return flagsToRoles(updateInteractionInfo(info));
}

bool ChatModel::MessageData::lessThan(const MessageData *message1, const MessageData *message2)
{
    bool message1Sponsored = message1->messageType == TYPE_SPONSORED_MESSAGE;
    bool message2Sponsored = message2->messageType == TYPE_SPONSORED_MESSAGE;
    if (message1Sponsored && message2Sponsored) {
        return message1->messageId < message2->messageId;
    }
    if (message1Sponsored && !message2Sponsored) {
        return false;
    }
    if (!message1Sponsored && message2Sponsored) {
        return true;
    }
    return message1->messageId < message2->messageId;
}