File indexing completed on 2024-05-12 05:17:25

 /*
     Copyright (c) 2009 Kevin Ottens <ervin@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library 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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "storejob.h"
 
 #include "kimap_debug.h"
 
 #include "job_p.h"
 #include "message_p.h"
 #include "session_p.h"
 
 namespace KIMAP2
 {
 class StoreJobPrivate : public JobPrivate
 {
 public:
     StoreJobPrivate(Session *session, const QString &name) : JobPrivate(session, name) { }
     ~StoreJobPrivate() { }
 
     QByteArray addFlags(const QByteArray &param, const MessageFlags &flags)
     {
         QByteArray parameters;
         switch (mode) {
         case StoreJob::SetFlags:
             parameters += param;
             break;
         case StoreJob::AppendFlags:
             parameters += "+" + param;
             break;
         case StoreJob::RemoveFlags:
             parameters += "-" + param;
             break;
         }
 
         parameters += " (";
         foreach (const QByteArray &flag, flags) {
             parameters += flag + ' ';
         }
         if (!flags.isEmpty()) {
             parameters.chop(1);
         }
         parameters += ')';
 
         return parameters;
     }
 
     ImapSet set;
     bool uidBased;
     StoreJob::StoreMode mode;
     MessageFlags flags;
     MessageFlags gmLabels;
 
     QMap<int, MessageFlags> resultingFlags;
 };
 }
 
 using namespace KIMAP2;
 
 StoreJob::StoreJob(Session *session)
     : Job(*new StoreJobPrivate(session, "Store"))
 {
     Q_D(StoreJob);
     d->uidBased = false;
     d->mode = SetFlags;
 }
 
 StoreJob::~StoreJob()
 {
 }
 
 void StoreJob::setSequenceSet(const ImapSet &set)
 {
     Q_D(StoreJob);
     d->set = set;
 }
 
 ImapSet StoreJob::sequenceSet() const
 {
     Q_D(const StoreJob);
     return d->set;
 }
 
 void StoreJob::setUidBased(bool uidBased)
 {
     Q_D(StoreJob);
     d->uidBased = uidBased;
 }
 
 bool StoreJob::isUidBased() const
 {
     Q_D(const StoreJob);
     return d->uidBased;
 }
 
 void StoreJob::setFlags(const MessageFlags &flags)
 {
     Q_D(StoreJob);
     d->flags = flags;
 }
 
 MessageFlags StoreJob::flags() const
 {
     Q_D(const StoreJob);
     return d->flags;
 }
 
 void StoreJob::setGMLabels(const MessageFlags &gmLabels)
 {
     Q_D(StoreJob);
     d->gmLabels = gmLabels;
 }
 
 MessageFlags StoreJob::gmLabels() const
 {
     Q_D(const StoreJob);
     return d->gmLabels;
 }
 
 void StoreJob::setMode(StoreMode mode)
 {
     Q_D(StoreJob);
     d->mode = mode;
 }
 
 StoreJob::StoreMode StoreJob::mode() const
 {
     Q_D(const StoreJob);
     return d->mode;
 }
 
 QMap<int, MessageFlags> StoreJob::resultingFlags() const
 {
     Q_D(const StoreJob);
     return d->resultingFlags;
 }
 
 void StoreJob::doStart()
 {
     Q_D(StoreJob);
 
     if (d->set.isEmpty()) {
         qCWarning(KIMAP2_LOG) << "Empty uid set passed to store job";
         setError(KJob::UserDefinedError);
         setErrorText(QStringLiteral("Empty uid set passed to store job"));
         emitResult();
         return;
     }
 
     d->set.optimize();
     QByteArray parameters = d->set.toImapSequenceSet() + ' ';
 
     if (!d->flags.isEmpty() || d->mode == SetFlags) {
         parameters += d->addFlags("FLAGS", d->flags);
     }
     if (!d->gmLabels.isEmpty()) {
         if (!d->flags.isEmpty()) {
             parameters += ' ';
         }
         parameters += d->addFlags("X-GM-LABELS", d->gmLabels);
     }
 
     qCDebug(KIMAP2_LOG) << parameters;
 
     QByteArray command = "STORE";
     if (d->uidBased) {
         command = "UID " + command;
     }
 
     d->sendCommand(command, parameters);
 }
 
 void StoreJob::handleResponse(const Message &response)
 {
     Q_D(StoreJob);
 
     if (handleErrorReplies(response) == NotHandled) {
         if (response.content.size() == 4 &&
                 response.content[2].toString() == "FETCH" &&
                 response.content[3].type() == Message::Part::List) {
 
             int id = response.content[1].toString().toInt();
             qint64 uid = 0;
             bool uidFound = false;
             QList<QByteArray> resultingFlags;
 
             QList<QByteArray> content = response.content[3].toList();
 
             for (QList<QByteArray>::ConstIterator it = content.constBegin();
                     it != content.constEnd(); ++it) {
                 QByteArray str = *it;
                 ++it;
 
                 if (str == "FLAGS") {
                     if ((*it).startsWith('(') && (*it).endsWith(')')) {
                         QByteArray str = *it;
                         str.chop(1);
                         str.remove(0, 1);
                         resultingFlags = str.split(' ');
                     } else {
                         resultingFlags << *it;
                     }
                 } else if (str == "UID") {
                     uid = it->toLongLong(&uidFound);
                 }
             }
 
             if (!d->uidBased) {
                 d->resultingFlags[id] = resultingFlags;
             } else if (uidFound) {
                 d->resultingFlags[uid] = resultingFlags;
             } else {
                 qCWarning(KIMAP2_LOG) << "We asked for UID but the server didn't give it back, resultingFlags not stored.";
             }
         }
     }
 }