bool SortTask::handleStateHelper(const Imap::Responses::State *const resp)
{
if (resp->tag.isEmpty()) {
if (resp->kind == Responses::NO && resp->respCode == Responses::NOUPDATE) {
// * NO [NOUPDATE "tag"] means that the server won't be providing further updates for our SEARCH/SORT criteria
const Responses::RespData<QString> *const untaggedTag = dynamic_cast<const Responses::RespData<QString>* const>(
resp->respCodeData.data());
Q_ASSERT(untaggedTag);
if (untaggedTag->data.toUtf8() == sortTag) {
m_persistentSearch = false;
model->m_taskModel->slotTaskMighHaveChanged(this);
if (m_firstCommandCompleted) {
// The server decided that it will no longer inform us about the updated SORT order, and the original
// response has been already received and processed. That means that we're done here and shall declare
// ourselves as completed.
_completed();
}
// We actually support even more benevolent mode of operation where the server can tell us at any time that
// this context updating is no longer supported. Yay for that; let's hope that it's reasonably bug-free now.
return true;
}
}
return false;
}
if (resp->tag == sortTag) {
m_firstCommandCompleted = true;
if (resp->kind == Responses::OK) {
emit sortingAvailable(sortResult);
if (!m_persistentSearch || _aborted) {
// This is a one-shot operation, we shall not remain as an active task, listening for further updates
_completed();
} else {
// got to prod the TaskPresentationModel
model->m_taskModel->slotTaskMighHaveChanged(this);
// Even though we aren't "finished" at this point, the KeepMailboxOpenTask is now free to issue its IDLE thing,
// as that won't interfere with our mode of operation. Let's kick it around.
KeepMailboxOpenTask *keepTask = dynamic_cast<KeepMailboxOpenTask*>(conn);
Q_ASSERT(keepTask);
keepTask->activateTasks();
}
} else {
_failed(tr("Sorting command has failed"));
}
return true;
} else if (resp->tag == cancelUpdateTag) {
m_persistentSearch = false;
model->m_taskModel->slotTaskMighHaveChanged(this);
_completed();
return true;
} else {
return false;
}
}
bool SubscribeUnsubscribeTask::handleStateHelper(const Imap::Responses::State *const resp)
{
if (resp->tag.isEmpty())
return false;
if (resp->tag == tag) {
if (resp->kind == Responses::OK) {
TreeItemMailbox *mailbox = dynamic_cast<TreeItemMailbox *>(static_cast<TreeItem *>(mailboxIndex.internalPointer()));
QString subscribed = QLatin1String("\\SUBSCRIBED");
switch (operation) {
case SUBSCRIBE:
if (mailbox && !mailbox->m_metadata.flags.contains(subscribed)) {
mailbox->m_metadata.flags.append(subscribed);
}
break;
case UNSUBSCRIBE:
if (mailbox) {
mailbox->m_metadata.flags.removeOne(subscribed);
}
}
_completed();
} else {
_failed("SUBSCRIBE/UNSUBSCRIBE has failed");
// FIXME: error handling
}
return true;
} else {
return false;
}
}
void
RemoteLister::canceled()
{
debug() << "canceled: " << url().prettyURL() << endl;
QTimer::singleShot( 0, this, SLOT(_completed()) );
}
bool CreateMailboxTask::handleStateHelper(const Imap::Responses::State *const resp)
{
if (resp->tag.isEmpty())
return false;
if (resp->tag == tagCreate) {
if (resp->kind == Responses::OK) {
EMIT_LATER(model, mailboxCreationSucceded, Q_ARG(QString, mailbox));
if (_dead) {
// Got to check if we're still allowed to execute before launching yet another command
_failed("Asked to die");
return true;
}
tagList = parser->list(QLatin1String(""), mailbox);
// Don't call _completed() yet, we're going to update mbox list before that
} else {
EMIT_LATER(model, mailboxCreationFailed, Q_ARG(QString, mailbox), Q_ARG(QString, resp->message));
_failed("Cannot create mailbox");
}
return true;
} else if (resp->tag == tagList) {
if (resp->kind == Responses::OK) {
model->finalizeIncrementalList(parser, mailbox);
_completed();
} else {
_failed("Error with the LIST command after the CREATE");
}
return true;
} else {
return false;
}
}
void SubscribeUnsubscribeTask::perform()
{
parser = conn->parser;
markAsActiveTask();
IMAP_TASK_CHECK_ABORT_DIE;
if (! mailboxIndex.isValid()) {
// FIXME: add proper fix
log("Mailbox vanished before we could ask for number of messages inside");
_completed();
return;
}
TreeItemMailbox *mailbox = dynamic_cast<TreeItemMailbox *>(static_cast<TreeItem *>(mailboxIndex.internalPointer()));
Q_ASSERT(mailbox);
switch (operation) {
case SUBSCRIBE:
tag = parser->subscribe(mailbox->mailbox());
break;
case UNSUBSCRIBE:
tag = parser->unSubscribe(mailbox->mailbox());
break;
default:
Q_ASSERT(false);
}
}
bool AppendTask::handleStateHelper(const Imap::Responses::State *const resp)
{
if (resp->tag.isEmpty())
return false;
if (resp->tag == tag) {
if (resp->kind == Responses::OK) {
if (resp->respCode == Responses::APPENDUID) {
const Responses::RespData<QPair<uint, Sequence> > *const respData =
dynamic_cast<const Responses::RespData<QPair<uint, Sequence> >* const>(resp->respCodeData.data());
Q_ASSERT(respData);
auto uids = respData->data.second.toVector();
if (uids.size() != 1) {
log(QLatin1String("APPENDUID: malformed data, cannot extract a single UID"));
} else {
emit appendUid(respData->data.first, uids.front());
}
}
// nothing should be needed here
_completed();
} else {
_failed(resp->message);
}
return true;
} else {
return false;
}
}
bool SubscribeUnsubscribeTask::handleStateHelper(const Imap::Responses::State *const resp)
{
if (resp->tag.isEmpty())
return false;
if (resp->tag == tag) {
if (resp->kind == Responses::OK) {
TreeItemMailbox *mailbox = dynamic_cast<TreeItemMailbox *>(model->findMailboxByName(mailboxName));
QString subscribed = QStringLiteral("\\SUBSCRIBED");
switch (operation) {
case SUBSCRIBE:
if (mailbox && !mailbox->m_metadata.flags.contains(subscribed)) {
mailbox->m_metadata.flags.append(subscribed);
}
break;
case UNSUBSCRIBE:
if (mailbox) {
mailbox->m_metadata.flags.removeOne(subscribed);
}
}
if (mailbox) {
auto index = mailbox->toIndex(model);
emit model->dataChanged(index, index);
}
_completed();
} else {
_failed(tr("SUBSCRIBE/UNSUBSCRIBE has failed"));
// FIXME: error handling
}
return true;
} else {
return false;
}
}
void
RemoteLister::completed()
{
debug() << "completed: " << url().prettyURL() << endl;
//as usual KDE documentation didn't suggest I needed to do this at all
//I had to figure it out myself
// -- avoid crash
QTimer::singleShot( 0, this, SLOT(_completed()) );
}
bool UnSelectTask::handleStateHelper(const Imap::Responses::State *const resp)
{
if (resp->tag.isEmpty()) {
switch (resp->respCode) {
case Responses::UNSEEN:
case Responses::PERMANENTFLAGS:
case Responses::UIDNEXT:
case Responses::UIDVALIDITY:
case Responses::NOMODSEQ:
case Responses::HIGHESTMODSEQ:
case Responses::CLOSED:
return true;
default:
break;
}
}
if (!resp->tag.isEmpty()) {
if (resp->tag == unSelectTag) {
if (resp->kind == Responses::OK) {
// nothing should be needed here
_completed();
} else {
// This is really bad.
throw MailboxException("Attempted to unselect current mailbox, but the server denied our request. "
"Can't continue, to avoid possible data corruption.", *resp);
}
return true;
} else if (resp->tag == selectMissingTag) {
if (resp->kind == Responses::OK) {
QTimer::singleShot(0, this, SLOT(doFakeSelect()));
log(QStringLiteral("The emergency EXAMINE command has unexpectedly succeeded, trying to get out of here..."), Common::LOG_MAILBOX_SYNC);
} else {
// This is very good :)
_completed();
}
return true;
}
}
return false;
}
bool NumberOfMessagesTask::handleStateHelper(const Imap::Responses::State *const resp)
{
if (resp->tag.isEmpty())
return false;
if (resp->tag == tag) {
if (resp->kind == Responses::OK) {
_completed();
} else {
_failed(tr("STATUS has failed"));
// FIXME: error handling
}
return true;
} else {
return false;
}
}
bool IdTask::handleStateHelper(const Imap::Responses::State *const resp)
{
if (resp->tag.isEmpty())
return false;
if (resp->tag == tag) {
if (resp->kind == Responses::OK) {
// nothing should be needed here
_completed();
} else {
_failed(tr("ID failed, strange"));
// But hey, we can just ignore this one
}
return true;
} else {
return false;
}
}
bool FetchMsgMetadataTask::handleStateHelper(const Imap::Responses::State *const resp)
{
if (resp->tag.isEmpty())
return false;
if (resp->tag == tag) {
if (resp->kind == Responses::OK) {
_completed();
} else {
_failed("UID FETCH failed");
// FIXME: error handling
}
return true;
} else {
return false;
}
}
bool GenUrlAuthTask::handleStateHelper(const Imap::Responses::State *const resp)
{
if (resp->tag.isEmpty())
return false;
if (resp->tag == tag) {
if (resp->kind == Responses::OK) {
// nothing should be needed here
_completed();
} else {
_failed(resp->message);
}
return true;
} else {
return false;
}
}
void NumberOfMessagesTask::perform()
{
parser = conn->parser;
markAsActiveTask();
IMAP_TASK_CHECK_ABORT_DIE;
if (! mailboxIndex.isValid()) {
// FIXME: add proper fix
log(QLatin1String("Mailbox vanished before we could ask for number of messages inside"));
_completed();
return;
}
TreeItemMailbox *mailbox = dynamic_cast<TreeItemMailbox *>(static_cast<TreeItem *>(mailboxIndex.internalPointer()));
Q_ASSERT(mailbox);
tag = parser->status(mailbox->mailbox(), requestedStatusOptions());
}
bool NoopTask::handleStateHelper(const Imap::Responses::State *const resp)
{
if (resp->tag.isEmpty())
return false;
if (resp->tag == tag) {
if (resp->kind == Responses::OK) {
// nothing should be needed here
_completed();
} else {
_failed("NOOP failed, strange");
// FIXME: error handling
}
return true;
} else {
return false;
}
}
bool ThreadTask::handleStateHelper(const Imap::Responses::State *const resp)
{
if (resp->tag.isEmpty())
return false;
if (resp->tag == tag) {
if (resp->kind == Responses::OK) {
if (!m_incrementalMode)
emit model->threadingAvailable(mailboxIndex, algorithm, searchCriteria, mapping);
_completed();
} else {
_failed("Threading command has failed");
}
mapping.clear();
return true;
} else {
return false;
}
}
void CommandBase::Completed()
{
if(!_completed.empty())
_completed(shared_from_this());
}
