src/data/chatdata.cpp - develop - s5z6/telegraf

src/data/chatdata.cpp
351 строка10 KB
mbarashkov
Оптимизации
13 июн 2025, 17:11
13 июн 2025, 17:116d7f9cd
#include "../util/telegrafutils.h"
#include "chatlistmodel.h"
#include "usersmodel.h"

ChatListModel::ChatData::ChatData(const QVariantMap &data, QObject *parent) :
    QObject(parent),
    chatData(data),
    chatId(data.value(ID).toLongLong()),
    order(data.value(ORDER).toLongLong()),
    groupId(0),
    verified(false),
    rkn_verified(false),
    archived(false),
    memberStatus(TDLibConstants::ChatMemberStatusUnknown),
    secretChatState(TDLibConstants::SecretChatStateUnknown)
{
    const QVariantMap type(data.value(TYPE).toMap());
    switch (chatType = TDLibConstants::getInstance()->chatTypeFromString(type.value(_TYPE).toString())) {
    case TDLibConstants::ChatTypeBasicGroup:
        groupId = type.value(BASIC_GROUP_ID).toLongLong();
        break;
    case TDLibConstants::ChatTypeSuperGroup:
        groupId = type.value(SUPERGROUP_ID).toLongLong();
        break;
    case TDLibConstants::ChatTypeUnknown:
    case TDLibConstants::ChatTypePrivate:
    case TDLibConstants::ChatTypeSecret:
    case TDLibConstants::ChatTypeBot:
        break;
    }
    photoSmallCache = chatData.value(PHOTO).toMap().value(SMALL).toMap();
}

int ChatListModel::ChatData::compareTo(const ChatData *other) const
{
    return senderMessageDate() < other->senderMessageDate() ? 1 : -1;
}

bool ChatListModel::ChatData::setOrder(const QString &newOrder)
{
    if (!newOrder.isEmpty()) {
        chatData.insert(ORDER, newOrder);
        order = newOrder.toLongLong();
        return true;
    }
    return false;
}

inline const QVariant ChatListModel::ChatData::lastMessage(const QString &key) const
{
    return chatData.value(LAST_MESSAGE).toMap().value(key);
}

QString ChatListModel::ChatData::title() const
{
    return chatData.value(TITLE).toString();
}

int ChatListModel::ChatData::unreadCount() const
{
    return chatData.value(UNREAD_COUNT).toInt();
}

int ChatListModel::ChatData::unreadMentionCount() const
{
    return chatData.value(UNREAD_MENTION_COUNT).toInt();
}

QVariant ChatListModel::ChatData::availableReactions() const
{
    return chatData.value(AVAILABLE_REACTIONS);
}

int ChatListModel::ChatData::unreadReactionCount() const
{
    return chatData.value(UNREAD_REACTION_COUNT).toInt();
}

QVariantMap ChatListModel::ChatData::photoSmall() const
{
    return photoSmallCache;
}

qlonglong ChatListModel::ChatData::lastReadInboxMessageId() const
{
    return chatData.value(LAST_READ_INBOX_MESSAGE_ID).toLongLong();
}

qlonglong ChatListModel::ChatData::senderUserId() const
{
    return lastMessage(SENDER_ID).toMap().value(USER_ID).toLongLong();
}

qlonglong ChatListModel::ChatData::senderChatId() const
{
    return lastMessage(SENDER_ID).toMap().value(CHAT_ID).toLongLong();
}

bool ChatListModel::ChatData::senderIsChat() const
{
    return lastMessage(SENDER_ID).toMap().value(_TYPE).toString() == "messageSenderChat";
}

qlonglong ChatListModel::ChatData::senderMessageDate() const
{
    return lastMessage(DATE).toLongLong();
}

QString ChatListModel::ChatData::senderMessageText() const
{
    qlonglong myUserId = TDLibState::getInstance()->getMyUserId();
    return TelegrafUtils::getMessageShortText(TDLibDataRepository::getInstance(), lastMessage(CONTENT).toMap(), isChannel(), myUserId, lastMessage(SENDER_ID).toMap() );
}

QString ChatListModel::ChatData::senderMessageStatus() const
{
    qlonglong myUserId = TDLibState::getInstance()->getMyUserId();
    if (isChannel() || myUserId != senderUserId() || myUserId == chatId) {
        return "";
    }
    if (lastMessage(ID) == chatData.value(LAST_READ_OUTBOX_MESSAGE_ID)) {
        return "&nbsp;&nbsp;✅";
    } else {
        QVariantMap lastMessage = chatData.value(LAST_MESSAGE).toMap();
        if (lastMessage.contains(SENDING_STATE)) {
            QVariantMap sendingState = lastMessage.value(SENDING_STATE).toMap();
            if (sendingState.value(_TYPE).toString() == "messageSendingStatePending") {
                return "&nbsp;&nbsp;🕙";
            } else {
                return "&nbsp;&nbsp;❌";
            }
        } else {
            return "&nbsp;&nbsp;☑️";
        }
    }
}

qlonglong ChatListModel::ChatData::draftMessageDate() const
{
    QVariantMap draft = chatData.value(DRAFT_MESSAGE).toMap();
    if(draft.isEmpty()) {
        return qlonglong(0);
    }
    return draft.value(DATE).toLongLong();
}

QString ChatListModel::ChatData::draftMessageText() const
{
    QVariantMap draft = chatData.value(DRAFT_MESSAGE).toMap();
    if(draft.isEmpty()) {
        return QString();
    }
    return draft.value("input_message_text").toMap().value(TEXT).toMap().value(TEXT).toString();
}

bool ChatListModel::ChatData::isBasicGroup() const
{
    return chatType == TDLibConstants::ChatTypeBasicGroup;
}

bool ChatListModel::ChatData::isSuperGroup() const
{
    return chatType == TDLibConstants::ChatTypeSuperGroup;
}

bool ChatListModel::ChatData::isGroup() const
{
    return isSuperGroup() || isBasicGroup();
}

bool ChatListModel::ChatData::isPrivate() const
{
    return chatType == TDLibConstants::ChatTypePrivate;
}

qlonglong ChatListModel::ChatData::respondentUserId() const
{
    //NOTE: will work only for chatType = ChatTypePrivate
    return chatData.value(TYPE).toMap().value(USER_ID).toLongLong();
}

bool ChatListModel::ChatData::isContact() const
{
    auto userId = respondentUserId();
    if (TDLibDataRepository::getInstance()->containsUserById(userId)) {
        return TDLibDataRepository::getInstance()->getUserById(respondentUserId()).value("is_contact").toBool();
    }
    return false;
}

bool ChatListModel::ChatData::isBot() const
{
    //need to refactor
    auto userId = respondentUserId();
    if (TDLibDataRepository::getInstance()->containsUserById(userId)) {
        auto type = TDLibDataRepository::getInstance()->getUserById(respondentUserId()).value(TYPE).toMap().value(_TYPE).toString();
        return type.contains("userTypeBot");
    }

    return false;
}

bool ChatListModel::ChatData::isMute() const
{
    return chatData.value(NOTIFICATION_SETTINGS).toMap().value("mute_for").toULongLong() > 0;
}

bool ChatListModel::ChatData::isChannel() const
{
    return chatData.value(TYPE).toMap().value(IS_CHANNEL).toBool();
}

bool ChatListModel::ChatData::isForum() const
{
    return chatData.value(TYPE).toMap().value(IS_FORUM).toBool();
}

bool ChatListModel::ChatData::isHidden() const
{
    // Cover all enum values so that compiler warns us when/if enum gets extended
    switch (chatType) {
    case TDLibConstants::ChatTypeBasicGroup:
    case TDLibConstants::ChatTypeSuperGroup:
        switch (memberStatus) {
        case TDLibConstants::ChatMemberStatusLeft:
        case TDLibConstants::ChatMemberStatusUnknown:
        case TDLibConstants::ChatMemberStatusBanned:
            return true;
        case TDLibConstants::ChatMemberStatusCreator:
        case TDLibConstants::ChatMemberStatusAdministrator:
        case TDLibConstants::ChatMemberStatusMember:
        case TDLibConstants::ChatMemberStatusRestricted:
            if (chatData.value(LAST_MESSAGE).isNull()) {
                return true;
            }
            break;
        }
        break;
    case TDLibConstants::ChatTypeUnknown:
        return true;
    case TDLibConstants::ChatTypePrivate:
    case TDLibConstants::ChatTypeBot:
        if (chatData.value(LAST_MESSAGE).isNull()) {
            return true;
        }
        break;
    case TDLibConstants::ChatTypeSecret:
        if (secretChatState == TDLibConstants::SecretChatStateClosed) {
            return true;
        }
        break;
    }
    return false;
}

bool ChatListModel::ChatData::isMarkedAsUnread() const
{
    return chatData.value(IS_MARKED_AS_UNREAD).toBool();
}

void ChatListModel::ChatData::updateUnreadCount(int count)
{
    chatData.insert(UNREAD_COUNT, count);
}

void ChatListModel::ChatData::updateLastReadInboxMessageId(qlonglong messageId)
{
    chatData.insert(LAST_READ_INBOX_MESSAGE_ID, messageId);
}

void ChatListModel::ChatData::updateLastMessage(const QVariantMap &message)
{
    chatData.insert(LAST_MESSAGE, message);
}

QVector<int> ChatListModel::ChatData::updateGroup(const GroupModel *group)
{
    QVector<int> changedRoles;

    if (group && groupId == group->groupId) {
        const TDLibConstants::ChatMemberStatus groupMemberStatus = group->chatMemberStatus();
        if (memberStatus != groupMemberStatus) {
            memberStatus = groupMemberStatus;
            changedRoles.append(RoleChatMemberStatus);
        }
        auto groupVerified = group->isVerified();
        if(verified != groupVerified)
        {
            verified = groupVerified;
            changedRoles.append(RoleIsVerified);
        }
        auto groupRKNVerified = group->isRKNVerified();
        if(rkn_verified != groupRKNVerified)
        {
            rkn_verified = groupRKNVerified;
            changedRoles.append(RoleIsRKNVerified);
        }
    }
    return changedRoles;
}

QVector<int> ChatListModel::ChatData::updateSecretChat(const QVariantMap &secretChatDetails)
{
    QVector<int> changedRoles;

    TDLibConstants::SecretChatState newSecretChatState = TDLibConstants::getInstance()->secretChatStateFromString(secretChatDetails.value("state").toMap().value(_TYPE).toString());
    if (newSecretChatState != secretChatState) {
        secretChatState = newSecretChatState;
        changedRoles.append(RoleSecretChatState);
    }
    return changedRoles;
}

ChatListModel::ChatData* ChatListModel::ChatData::clone() {
    QVariantMap clonedChatData;

    QList<QString> keys = chatData.keys();
    for(int i = 0; i < keys.count(); i++) {
        clonedChatData.insert(keys[i], QVariant(chatData[keys[i]]));
    }
    ChatData* res = new ChatData(clonedChatData, this);
    res->chatId = chatId;
    res->order = order;
    res->groupId = groupId;
    res->verified = verified;
    res->archived = archived;
    res->chatType = chatType;
    res->memberStatus = memberStatus;
    res->secretChatState = secretChatState;
    return res;
}

QVector<int> ChatListModel::ChatData::updateVerification()
{
    QVector<int> changedRoles;

    auto _verified = UsersModel::getInstance()->isVerified(chatId);
    auto _rkn_verified = UsersModel::getInstance()->isRKNVerified(chatId);

    if(verified != _verified)
    {
        verified = _verified;
        changedRoles.append(RoleIsVerified);
    }
    if(rkn_verified != _rkn_verified)
    {
        rkn_verified = _rkn_verified;
        changedRoles.append(RoleIsRKNVerified);
    }
    return changedRoles;
}