squawk/core/contact.cpp

346 lines
10 KiB
C++
Raw Normal View History

/*
* <one line to give the program's name and a brief idea of what it does.>
* 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 "contact.h"
#include <QDebug>
Core::Contact::Contact(const QString& pJid, const QString& account, QObject* parent):
QObject(parent),
jid(pJid),
name(),
groups(),
2019-04-19 09:12:12 +00:00
archiveState(empty),
archive(new Archive(jid)),
2019-04-21 19:17:04 +00:00
subscriptionState(Shared::unknown),
syncronizing(false),
requestedCount(0),
2019-04-26 12:52:34 +00:00
requestedBefore(),
2019-04-21 19:17:04 +00:00
hisoryCache(),
appendCache(),
2019-04-26 12:52:34 +00:00
responseCache(),
requestCache()
{
archive->open(account);
2019-04-21 19:17:04 +00:00
if (archive->isFromTheBeginning()) {
archiveState = beginning;
} else {
if (archive->size() != 0) {
archiveState = chunk;
}
}
}
Core::Contact::~Contact()
{
delete archive;
}
Core::Contact::ArchiveState Core::Contact::getArchiveState() const
{
2019-04-19 09:12:12 +00:00
return archiveState;
}
QSet<QString> Core::Contact::getGroups() const
{
return groups;
}
QString Core::Contact::getName() const
{
return name;
}
void Core::Contact::setName(const QString& n)
{
if (name != n) {
name = n;
2019-04-19 09:12:12 +00:00
emit nameChanged(name);
}
}
2019-04-19 09:12:12 +00:00
Shared::SubscriptionState Core::Contact::getSubscriptionState() const
{
return subscriptionState;
}
void Core::Contact::setGroups(const QSet<QString>& set)
{
QSet<QString> toRemove = groups - set;
QSet<QString> toAdd = set - groups;
groups = set;
for (QSet<QString>::iterator itr = toRemove.begin(), end = toRemove.end(); itr != end; ++itr) {
emit groupRemoved(*itr);
}
for (QSet<QString>::iterator itr = toAdd.begin(), end = toAdd.end(); itr != end; ++itr) {
emit groupAdded(*itr);
}
}
void Core::Contact::setSubscriptionState(Shared::SubscriptionState state)
{
if (subscriptionState != state) {
subscriptionState = state;
emit subscriptionStateChanged(subscriptionState);
}
}
unsigned int Core::Contact::groupsCount() const
{
return groups.size();
}
2019-04-21 19:17:04 +00:00
void Core::Contact::addMessageToArchive(const Shared::Message& msg)
{
2019-04-28 21:34:28 +00:00
if (msg.getId().size() > 0 && msg.getBody().size() > 0) {
hisoryCache.emplace_back(msg);
}
2019-04-21 19:17:04 +00:00
}
void Core::Contact::requestHistory(int count, const QString& before)
{
if (syncronizing) {
requestCache.emplace_back(count, before);
} else {
2019-04-24 14:50:54 +00:00
performRequest(count, before);
}
}
void Core::Contact::nextRequest()
{
2019-04-26 12:52:34 +00:00
if (syncronizing) {
if (requestedCount != -1) {
emit historyResponse(responseCache);
}
}
2019-04-24 14:50:54 +00:00
if (requestCache.size() > 0) {
std::pair<int, QString> request = requestCache.front();
requestCache.pop_front();
performRequest(request.first, request.second);
} else {
syncronizing = false;
requestedCount = 0;
2019-04-26 12:52:34 +00:00
requestedBefore = "";
2019-04-24 14:50:54 +00:00
hisoryCache.clear();
responseCache.clear();
}
}
void Core::Contact::performRequest(int count, const QString& before)
{
syncronizing = true;
requestedCount = count;
2019-04-26 12:52:34 +00:00
requestedBefore = before;
2019-04-24 14:50:54 +00:00
hisoryCache.clear();
responseCache.clear();
switch (archiveState) {
case empty:
emit needHistory(before, "");
2019-04-24 14:50:54 +00:00
break;
2019-04-26 12:52:34 +00:00
case chunk:
2019-04-28 21:34:28 +00:00
case beginning:
if (count != -1) {
requestCache.emplace_back(requestedCount, before);
requestedCount = -1;
2019-04-24 14:50:54 +00:00
}
emit needHistory("", archive->newestId());
2019-04-24 14:50:54 +00:00
break;
2019-04-28 21:34:28 +00:00
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 (Archive::NotFound e) {
requestCache.emplace_back(requestedCount, before);
requestedCount = -1;
emit needHistory(archive->oldestId(), "");
}
2019-04-26 12:52:34 +00:00
if (found) {
int rSize = responseCache.size();
if (rSize < count) {
if (rSize != 0) {
emit needHistory(responseCache.front().getId(), "");
2019-04-26 12:52:34 +00:00
} else {
emit needHistory(before, "");
2019-04-26 12:52:34 +00:00
}
} else {
2019-04-25 05:27:01 +00:00
nextRequest();
}
2019-04-24 14:50:54 +00:00
}
2019-04-28 21:34:28 +00:00
} else {
emit needHistory(archive->oldestId(), "");
2019-04-24 14:50:54 +00:00
}
break;
case complete:
try {
std::list<Shared::Message> arc = archive->getBefore(requestedCount - responseCache.size(), before);
responseCache.insert(responseCache.begin(), arc.begin(), arc.end());
} catch (Archive::NotFound e) {
2019-04-26 12:52:34 +00:00
qDebug("requesting id hasn't been found in archive, skipping");
}
nextRequest();
2019-04-24 14:50:54 +00:00
break;
}
}
void Core::Contact::appendMessageToArchive(const Shared::Message& msg)
{
2019-04-28 21:34:28 +00:00
const QString& id = msg.getId();
if (id.size() > 0) {
if (msg.getBody().size() > 0) {
switch (archiveState) {
case empty:
if (archive->addElement(msg)) {
archiveState = end;
};
if (!syncronizing) {
requestHistory(-1, id);
}
break;
case beginning:
appendCache.emplace_back(msg);
if (!syncronizing) {
requestHistory(-1, id);
}
break;
case end:
archive->addElement(msg);
break;
case chunk:
appendCache.emplace_back(msg);
if (!syncronizing) {
requestHistory(-1, id);
}
break;
case complete:
archive->addElement(msg);
break;
}
} else if (!syncronizing && archiveState == empty) {
requestHistory(-1, id);
2019-04-21 19:17:04 +00:00
}
}
}
2019-04-26 12:52:34 +00:00
2019-04-28 21:34:28 +00:00
void Core::Contact::flushMessagesToArchive(bool finished, const QString& firstId, const QString& lastId)
2019-04-26 12:52:34 +00:00
{
unsigned int added(0);
2019-04-26 12:52:34 +00:00
if (hisoryCache.size() > 0) {
added = archive->addElements(hisoryCache);
qDebug() << "Added" << added << "messages to the archive";
2019-04-28 21:34:28 +00:00
hisoryCache.clear();
2019-04-26 12:52:34 +00:00
}
2019-04-28 21:34:28 +00:00
switch (archiveState) {
case beginning:
if (finished) {
archiveState = complete;
archive->addElements(appendCache);
appendCache.clear();
2019-04-26 12:52:34 +00:00
nextRequest();
2019-04-28 21:34:28 +00:00
} else {
emit needHistory("", lastId);
2019-04-26 12:52:34 +00:00
}
break;
2019-04-28 21:34:28 +00:00
case chunk:
if (finished) {
archiveState = end;
archive->addElements(appendCache);
appendCache.clear();
2019-04-28 21:34:28 +00:00
nextRequest();
} else {
emit needHistory("", lastId);
2019-04-26 12:52:34 +00:00
}
2019-04-28 21:34:28 +00:00
break;
case empty:
archiveState = end;
case end:
if (finished) {
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 (Archive::NotFound e) {}
if (!found || requestedCount < responseCache.size()) {
2019-04-28 21:34:28 +00:00
if (archiveState == complete) {
nextRequest();
} else {
emit needHistory(firstId, "");
2019-04-28 21:34:28 +00:00
}
} else {
nextRequest();
}
} else {
if (added != 0) {
nextRequest();
} else {
emit needHistory(firstId, "");
}
2019-04-28 21:34:28 +00:00
}
break;
case complete:
nextRequest();
break;
2019-04-26 12:52:34 +00:00
}
}
void Core::Contact::requestFromEmpty(int count, const QString& before)
{
if (syncronizing) {
qDebug("perform from empty didn't work, another request queued");
} else {
if (archiveState != empty) {
qDebug("perform from empty didn't work, the state is not empty");
requestHistory(count, before);
} else {
syncronizing = true;
requestedCount = count;
requestedBefore = "";
hisoryCache.clear();
responseCache.clear();
emit needHistory(before, "");
}
}
}