squawk/core/rosteritem.cpp

567 lines
17 KiB
C++
Raw Normal View History

/*
* Squawk messenger.
* Copyright (C) 2019 Yury Gubich <blue@macaw.me>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "rosteritem.h"
2019-12-30 20:22:04 +00:00
#include "account.h"
#include <QDebug>
Core::RosterItem::RosterItem(const QString& pJid, const QString& pAccount, QObject* parent):
QObject(parent),
jid(pJid),
account(pAccount),
name(),
archiveState(empty),
archive(new Archive(jid)),
syncronizing(false),
requestedCount(0),
requestedBefore(),
hisoryCache(),
appendCache(),
responseCache(),
2019-08-28 11:40:55 +00:00
requestCache(),
toCorrect(),
2019-08-28 11:40:55 +00:00
muc(false)
{
archive->open(account);
2019-08-28 11:40:55 +00:00
if (archive->size() != 0) {
if (archive->isFromTheBeginning()) {
archiveState = beginning;
} else {
archiveState = chunk;
}
}
}
Core::RosterItem::~RosterItem()
{
delete archive;
}
Core::RosterItem::ArchiveState Core::RosterItem::getArchiveState() const
{
return archiveState;
}
QString Core::RosterItem::getName() const
{
return name;
}
void Core::RosterItem::setName(const QString& n)
{
if (name != n) {
name = n;
emit nameChanged(name);
}
}
void Core::RosterItem::addMessageToArchive(const Shared::Message& msg)
{
if (msg.storable()) {
hisoryCache.push_back(msg);
std::map<QString, Shared::Message>::iterator itr = toCorrect.find(msg.getId());
if (itr != toCorrect.end()) {
hisoryCache.back().change({
{"body", itr->second.getBody()},
{"stamp", itr->second.getTime()}
});
toCorrect.erase(itr);
}
}
}
void Core::RosterItem::correctMessageInArchive(const QString& originalId, const Shared::Message& msg)
{
if (msg.storable()) {
QDateTime thisTime = msg.getTime();
std::map<QString, Shared::Message>::iterator itr = toCorrect.find(originalId);
if (itr != toCorrect.end()) {
if (itr->second.getTime() < thisTime) {
itr->second = msg;
}
return;
}
bool found = changeMessage(originalId, {
{"body", msg.getBody()},
{"stamp", thisTime}
});
if (!found) {
toCorrect.insert(std::make_pair(originalId, msg));
}
}
}
void Core::RosterItem::requestHistory(int count, const QString& before)
{
if (syncronizing) {
requestCache.emplace_back(count, before);
} else {
performRequest(count, before);
}
}
void Core::RosterItem::nextRequest()
{
if (syncronizing) {
if (requestedCount != -1) {
bool last = false;
if (archiveState == beginning || archiveState == complete) {
QString firstId = archive->oldestId();
if (responseCache.size() == 0) {
if (requestedBefore == firstId) {
last = true;
}
} else {
if (responseCache.front().getId() == firstId) {
last = true;
}
}
} else if (archiveState == empty && responseCache.size() == 0) {
last = true;
}
emit historyResponse(responseCache, last);
}
}
if (requestCache.size() > 0) {
std::pair<int, QString> request = requestCache.front();
requestCache.pop_front();
performRequest(request.first, request.second);
} else {
syncronizing = false;
requestedCount = 0;
requestedBefore = "";
hisoryCache.clear();
responseCache.clear();
}
}
void Core::RosterItem::performRequest(int count, const QString& before)
{
syncronizing = true;
requestedCount = count;
requestedBefore = before;
hisoryCache.clear();
responseCache.clear();
switch (archiveState) {
case empty:
emit needHistory(before, "");
break;
case chunk:
case beginning: {
if (count != -1) {
requestCache.emplace_back(requestedCount, before);
requestedCount = -1;
}
Shared::Message msg = archive->newest();
emit needHistory("", getId(msg), msg.getTime());
}
break;
case end:
if (count != -1) {
QString lBefore;
if (responseCache.size() > 0) {
lBefore = responseCache.front().getId();
} else {
lBefore = before;
}
bool found = false;
try {
std::list<Shared::Message> arc = archive->getBefore(requestedCount - responseCache.size(), lBefore);
responseCache.insert(responseCache.begin(), arc.begin(), arc.end());
found = true;
} catch (const Archive::NotFound& e) {
requestCache.emplace_back(requestedCount, before);
requestedCount = -1;
emit needHistory(getId(archive->oldest()), "");
} catch (const Archive::Empty& e) {
requestCache.emplace_back(requestedCount, before);
requestedCount = -1;
emit needHistory(getId(archive->oldest()), "");
}
if (found) {
int rSize = responseCache.size();
if (rSize < count) {
if (rSize != 0) {
emit needHistory(getId(responseCache.front()), "");
} else {
QString bf;
if (muc) {
bf = archive->stanzaIdById(before);
if (bf.size() < 0) {
qDebug() << "Didn't find stanzaId for id requesting history for" << jid << ", falling back to requesting by id";
bf = before;
}
} else {
bf = before;
}
emit needHistory(bf, "");
}
} else {
nextRequest();
}
}
} else {
emit needHistory(getId(archive->oldest()), "");
}
break;
case complete:
try {
std::list<Shared::Message> arc = archive->getBefore(requestedCount - responseCache.size(), before);
responseCache.insert(responseCache.begin(), arc.begin(), arc.end());
} catch (const Archive::NotFound& e) {
qDebug("requesting id hasn't been found in archive, skipping");
} catch (const Archive::Empty& e) {
qDebug("requesting id hasn't been found in archive, skipping");
}
nextRequest();
break;
}
}
QString Core::RosterItem::getId(const Shared::Message& msg)
{
QString id;
if (muc) {
id = msg.getStanzaId();
} else {
id = msg.getId();
}
return id;
}
void Core::RosterItem::appendMessageToArchive(const Shared::Message& msg)
{
if (msg.getId().size() > 0) {
if (msg.storable()) {
switch (archiveState) {
case empty:
if (archive->addElement(msg)) {
archiveState = end;
}
if (!syncronizing) {
requestHistory(-1, getId(msg));
}
break;
case beginning:
if (!archive->hasElement(msg.getId())) {
appendCache.push_back(msg);
if (!syncronizing) {
requestHistory(-1, getId(msg));
}
}
break;
case end:
archive->addElement(msg);
break;
case chunk:
if (!archive->hasElement(msg.getId())) {
appendCache.push_back(msg);
if (!syncronizing) {
requestHistory(-1, getId(msg));
}
}
break;
case complete:
archive->addElement(msg);
break;
}
} else if (!syncronizing && archiveState == empty) {
requestHistory(-1, getId(msg));
}
}
}
bool Core::RosterItem::changeMessage(const QString& id, const QMap<QString, QVariant>& data)
{
bool found = false;
for (Shared::Message& msg : appendCache) {
if (msg.getId() == id) {
msg.change(data);
found = true;
break;
}
}
if (!found) {
for (Shared::Message& msg : hisoryCache) {
if (msg.getId() == id) {
msg.change(data);
found = true;
break;
}
}
}
if (!found) {
try {
archive->changeMessage(id, data);
found = true;
} catch (const Archive::NotFound& e) {
qDebug() << "An attempt to change state to the message" << id << "but it couldn't be found";
}
}
if (found) {
for (Shared::Message& msg : responseCache) {
if (msg.getId() == id) {
msg.change(data);
break;
}
}
}
return found;
}
void Core::RosterItem::flushMessagesToArchive(bool finished, const QString& firstId, const QString& lastId)
{
unsigned int added(0);
if (hisoryCache.size() > 0) {
added = archive->addElements(hisoryCache);
qDebug() << "Added" << added << "messages to the archive";
hisoryCache.clear();
}
bool wasEmpty = false;
switch (archiveState) {
case beginning:
if (finished) {
archiveState = complete;
2019-08-28 11:40:55 +00:00
added += archive->addElements(appendCache);
appendCache.clear();
nextRequest();
} else {
emit needHistory("", lastId);
}
break;
case chunk:
if (finished) {
archiveState = end;
2019-08-28 11:40:55 +00:00
added += archive->addElements(appendCache);
appendCache.clear();
nextRequest();
} else {
emit needHistory("", lastId);
}
break;
case empty:
wasEmpty = true;
archiveState = end;
[[fallthrough]];
case end:
2019-08-28 11:40:55 +00:00
added += archive->addElements(appendCache);
appendCache.clear();
if (finished && (added > 0 || !wasEmpty)) {
archiveState = complete;
archive->setFromTheBeginning(true);
}
if (requestedCount != -1) {
QString before;
if (responseCache.size() > 0) {
before = responseCache.front().getId();
} else {
before = requestedBefore;
}
bool found = false;
try {
std::list<Shared::Message> arc = archive->getBefore(requestedCount - responseCache.size(), before);
responseCache.insert(responseCache.begin(), arc.begin(), arc.end());
found = true;
} catch (const Archive::NotFound& e) {
} catch (const Archive::Empty& e) {
}
if (!found || requestedCount > responseCache.size()) {
if (archiveState == complete) {
nextRequest();
} else {
emit needHistory(firstId, "");
}
} else {
nextRequest();
}
} else {
if (added != 0) {
nextRequest();
} else {
emit needHistory(firstId, "");
}
}
break;
case complete:
nextRequest();
break;
}
}
2019-08-28 11:40:55 +00:00
QString Core::RosterItem::getServer() const
{
QStringList lst = jid.split("@");
return lst.back();
}
bool Core::RosterItem::isMuc() const
{
return muc;
}
2019-12-30 20:22:04 +00:00
QString Core::RosterItem::avatarPath(const QString& resource) const
2020-04-13 19:57:23 +00:00
{
QString path = folderPath() + "/" + (resource.size() == 0 ? jid : resource);
return path;
}
QString Core::RosterItem::folderPath() const
{
QString path(QStandardPaths::writableLocation(QStandardPaths::CacheLocation));
2020-04-13 19:57:23 +00:00
path += "/" + account + "/" + jid;
return path;
}
2020-04-13 19:57:23 +00:00
bool Core::RosterItem::setAvatar(const QByteArray& data, Archive::AvatarInfo& info, const QString& resource)
{
2020-04-13 19:57:23 +00:00
bool result = archive->setAvatar(data, info, false, resource);
2019-12-30 20:22:04 +00:00
if (resource.size() == 0 && result) {
if (data.size() == 0) {
emit avatarChanged(Shared::Avatar::empty, "");
} else {
2020-04-13 19:57:23 +00:00
emit avatarChanged(Shared::Avatar::valid, avatarPath(resource) + "." + info.type);
}
}
2019-12-30 20:22:04 +00:00
return result;
}
2019-12-30 20:22:04 +00:00
bool Core::RosterItem::setAutoGeneratedAvatar(const QString& resource)
2020-04-13 19:57:23 +00:00
{
Archive::AvatarInfo info;
return setAutoGeneratedAvatar(info, resource);
}
bool Core::RosterItem::setAutoGeneratedAvatar(Archive::AvatarInfo& info, const QString& resource)
{
QImage image(96, 96, QImage::Format_ARGB32_Premultiplied);
QPainter painter(&image);
quint8 colorIndex = rand() % Shared::colorPalette.size();
const QColor& bg = Shared::colorPalette[colorIndex];
painter.fillRect(image.rect(), bg);
QFont f;
f.setBold(true);
f.setPixelSize(72);
painter.setFont(f);
if (bg.lightnessF() > 0.5) {
painter.setPen(Qt::black);
} else {
painter.setPen(Qt::white);
}
2019-12-30 20:22:04 +00:00
painter.drawText(image.rect(), Qt::AlignCenter | Qt::AlignVCenter, resource.size() == 0 ? jid.at(0).toUpper() : resource.at(0).toUpper());
QByteArray arr;
QBuffer stream(&arr);
stream.open(QBuffer::WriteOnly);
image.save(&stream, "PNG");
stream.close();
2020-04-13 19:57:23 +00:00
bool result = archive->setAvatar(arr, info, true, resource);
2019-12-30 20:22:04 +00:00
if (resource.size() == 0 && result) {
emit avatarChanged(Shared::Avatar::autocreated, avatarPath(resource) + ".png");
}
2019-12-30 20:22:04 +00:00
return result;
}
bool Core::RosterItem::readAvatarInfo(Archive::AvatarInfo& target, const QString& resource) const
{
return archive->readAvatarInfo(target, resource);
}
2019-12-30 20:22:04 +00:00
Shared::VCard Core::RosterItem::handleResponseVCard(const QXmppVCardIq& card, const QString& resource)
{
Archive::AvatarInfo info;
2020-04-13 19:57:23 +00:00
Archive::AvatarInfo newInfo;
2019-12-30 20:22:04 +00:00
bool hasAvatar = readAvatarInfo(info, resource);
QByteArray ava = card.photo();
Shared::VCard vCard;
initializeVCard(vCard, card);
Shared::Avatar type = Shared::Avatar::empty;
QString path = "";
if (ava.size() > 0) {
2020-04-13 19:57:23 +00:00
bool changed = setAvatar(ava, newInfo, resource);
2019-12-30 20:22:04 +00:00
if (changed) {
type = Shared::Avatar::valid;
2020-04-13 19:57:23 +00:00
path = avatarPath(resource) + "." + newInfo.type;
2019-12-30 20:22:04 +00:00
} else if (hasAvatar) {
if (info.autogenerated) {
type = Shared::Avatar::autocreated;
path = avatarPath(resource) + ".png";
} else {
type = Shared::Avatar::valid;
path = avatarPath(resource) + "." + info.type;
}
}
} else {
if (!hasAvatar || !info.autogenerated) {
setAutoGeneratedAvatar(resource);
}
type = Shared::Avatar::autocreated;
path = avatarPath(resource) + ".png";
2019-12-30 20:22:04 +00:00
}
vCard.setAvatarType(type);
vCard.setAvatarPath(path);
if (resource.size() == 0) {
emit avatarChanged(vCard.getAvatarType(), vCard.getAvatarPath());
}
return vCard;
}
void Core::RosterItem::clearArchiveRequests()
{
syncronizing = false;
requestedCount = 0;
requestedBefore = "";
for (const std::pair<int, QString>& pair : requestCache) {
if (pair.first != -1) {
emit historyResponse(responseCache, false); //just to notify those who still waits with whatever happened to be left in caches yet
}
responseCache.clear();
}
hisoryCache.clear();
responseCache.clear(); //in case the cycle never runned
appendCache.clear();
requestCache.clear();
}
void Core::RosterItem::downgradeDatabaseState()
{
if (archiveState == ArchiveState::complete) {
archiveState = ArchiveState::beginning;
}
if (archiveState == ArchiveState::end) {
archiveState = ArchiveState::chunk;
}
}