diff --git a/autotests/identitytest.cpp b/autotests/identitytest.cpp index a35b042e..85a661d4 100644 --- a/autotests/identitytest.cpp +++ b/autotests/identitytest.cpp @@ -1,101 +1,244 @@ /* Copyright (c) 2008 Thomas McGuire 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 "qtest.h" #include "identitytest.h" #include "identitymanager.h" #include "identity.h" #include #include #include #include +#include using namespace KIdentityManagement; QTEST_GUILESS_MAIN(IdentityTester) void IdentityTester::initTestCase() { QStandardPaths::setTestModeEnabled(true); } +bool IdentityTester::compareIdentities(const Identity &actual, const Identity &expected) +{ + bool ok = false; + [&]() { + QCOMPARE(actual.uoid(), expected.uoid()); + // Don't compare isDefault - only one copy can be default, so this property + // is not copied! It does not affect result of operator==() either. + //QCOMPARE(actual.isDefault(), expected.isDefault()); + QCOMPARE(actual.identityName(), expected.identityName()); + QCOMPARE(actual.fullName(), expected.fullName()); + QCOMPARE(actual.organization(), expected.organization()); + QCOMPARE(actual.pgpEncryptionKey(), expected.pgpEncryptionKey()); + QCOMPARE(actual.pgpSigningKey(), expected.pgpSigningKey()); + QCOMPARE(actual.smimeEncryptionKey(), expected.smimeEncryptionKey()); + QCOMPARE(actual.smimeSigningKey(), expected.smimeSigningKey()); + QCOMPARE(actual.preferredCryptoMessageFormat(), expected.preferredCryptoMessageFormat()); + QCOMPARE(actual.emailAliases(), expected.emailAliases()); + QCOMPARE(actual.primaryEmailAddress(), expected.primaryEmailAddress()); + QCOMPARE(actual.vCardFile(), expected.vCardFile()); + QCOMPARE(actual.replyToAddr(), expected.replyToAddr()); + QCOMPARE(actual.bcc(), expected.bcc()); + QCOMPARE(actual.cc(), expected.cc()); + QCOMPARE(actual.attachVcard(), expected.attachVcard()); + QCOMPARE(actual.autocorrectionLanguage(), expected.autocorrectionLanguage()); + QCOMPARE(actual.disabledFcc(), expected.disabledFcc()); + QCOMPARE(actual.pgpAutoSign(), expected.pgpAutoSign()); + QCOMPARE(actual.pgpAutoEncrypt(), expected.pgpAutoEncrypt()); + QCOMPARE(actual.defaultDomainName(), expected.defaultDomainName()); + QCOMPARE(actual.signatureText(), expected.signatureText()); + QCOMPARE(const_cast(actual).signature(), const_cast(expected).signature()); + QCOMPARE(actual.transport(), expected.transport()); + QCOMPARE(actual.fcc(), expected.fcc()); + QCOMPARE(actual.drafts(), expected.drafts()); + QCOMPARE(actual.templates(), expected.templates()); + QCOMPARE(actual.dictionary(), expected.dictionary()); + QCOMPARE(actual.isXFaceEnabled(), expected.isXFaceEnabled()); + QCOMPARE(actual.xface(), expected.xface()); + ok = true; + }(); + + return ok; +} + + +void IdentityTester::test_Identity() +{ + Identity identity; + identity.setUoid(42); + QCOMPARE(identity.uoid(), 42u); + identity.setIsDefault(true); + QCOMPARE(identity.isDefault(), true); + identity.setIdentityName(QStringLiteral("01234")); + QCOMPARE(identity.identityName(), QStringLiteral("01234")); + identity.setFullName(QStringLiteral("Daniel Vrátil")); + QCOMPARE(identity.fullName(), QStringLiteral("Daniel Vrátil")); + identity.setOrganization(QStringLiteral("KDE")); + QCOMPARE(identity.organization(), QStringLiteral("KDE")); + identity.setPGPEncryptionKey("0x0123456789ABCDEF"); + QCOMPARE(identity.pgpEncryptionKey(), QByteArray("0x0123456789ABCDEF")); + identity.setPGPSigningKey("0xFEDCBA9876543210"); + QCOMPARE(identity.pgpSigningKey(), QByteArray("0xFEDCBA9876543210")); + identity.setSMIMEEncryptionKey("0xABCDEF0123456789"); + QCOMPARE(identity.smimeEncryptionKey(), QByteArray("0xABCDEF0123456789")); + identity.setSMIMESigningKey("0xFEDCBA9876543210"); + QCOMPARE(identity.smimeSigningKey(), QByteArray("0xFEDCBA9876543210")); + identity.setPreferredCryptoMessageFormat(QStringLiteral("PGP")); + QCOMPARE(identity.preferredCryptoMessageFormat(), QStringLiteral("PGP")); + identity.setPrimaryEmailAddress(QStringLiteral("dvratil@kde.org")); + const QStringList aliases = { QStringLiteral("dvratil1@kde.org"), QStringLiteral("example@example.org") }; + identity.setEmailAliases(aliases); + QCOMPARE(identity.emailAliases(), aliases); + QVERIFY(identity.matchesEmailAddress(QStringLiteral("dvratil@kde.org"))); + QVERIFY(identity.matchesEmailAddress(aliases[0])); + QVERIFY(identity.matchesEmailAddress(aliases[1])); + + QCOMPARE(identity.primaryEmailAddress(), QStringLiteral("dvratil@kde.org")); + const auto vcardFile = QStringLiteral("BEGIN:VCARD\n" + "VERSION:2.1\n" + "N:Vrátil;Daniel;;\n" + "END:VCARD"); + identity.setVCardFile(vcardFile); + QCOMPARE(identity.vCardFile(), vcardFile); + identity.setReplyToAddr(QStringLiteral("dvratil+reply@kde.org")); + QCOMPARE(identity.replyToAddr(), QStringLiteral("dvratil+reply@kde.org")); + identity.setBcc(QStringLiteral("dvratil+bcc@kde.org")); + QCOMPARE(identity.bcc(), QStringLiteral("dvratil+bcc@kde.org")); + identity.setCc(QStringLiteral("dvratil+cc@kde.org")); + QCOMPARE(identity.cc(), QStringLiteral("dvratil+cc@kde.org")); + identity.setAttachVcard(true); + QCOMPARE(identity.attachVcard(), true); + identity.setAutocorrectionLanguage(QStringLiteral("cs_CZ")); + QCOMPARE(identity.autocorrectionLanguage(), QStringLiteral("cs_CZ")); + identity.setDisabledFcc(true); + QCOMPARE(identity.disabledFcc(), true); + identity.setPgpAutoSign(true); + QCOMPARE(identity.pgpAutoSign(), true); + identity.setPgpAutoEncrypt(true); + QCOMPARE(identity.pgpAutoEncrypt(), true); + identity.setDefaultDomainName(QStringLiteral("kde.org")); + QCOMPARE(identity.defaultDomainName(), QStringLiteral("kde.org")); + Signature sig; + sig.setEnabledSignature(true); + sig.setText(QStringLiteral("Regards,\nDaniel")); + identity.setSignature(sig); + QCOMPARE(identity.signature(), sig); + identity.setTransport(QStringLiteral("smtp")); + QCOMPARE(identity.transport(), QStringLiteral("smtp")); + identity.setFcc(QStringLiteral("123")); // must be an Akonadi::Collection::Id + QCOMPARE(identity.fcc(), QStringLiteral("123")); + identity.setDrafts(QStringLiteral("124")); + QCOMPARE(identity.drafts(), QStringLiteral("124")); + identity.setTemplates(QStringLiteral("125")); + QCOMPARE(identity.templates(), QStringLiteral("125")); + identity.setDictionary(QStringLiteral("Čeština")); + QCOMPARE(identity.dictionary(), QStringLiteral("Čeština")); + identity.setXFaceEnabled(true); + QCOMPARE(identity.isXFaceEnabled(), true); + identity.setXFace(QStringLiteral(":-P")); + QCOMPARE(identity.xface(), QStringLiteral(":-P")); + + // Test copy + { + const Identity copy = identity; + QCOMPARE(copy, identity); + // Test that the operator==() actually works + QVERIFY(compareIdentities(copy, identity)); + + identity.setXFace(QStringLiteral(":-(")); + QVERIFY(!(copy == identity)); + } + + // Test serialization + { + QByteArray ba; + QDataStream inStream(&ba, QIODevice::WriteOnly); + inStream << identity; + + Identity copy; + QDataStream outStream(&ba, QIODevice::ReadOnly); + outStream >> copy; + + // We already verified that operator==() works, so this should be enough + QVERIFY(compareIdentities(copy, identity)); + } +} + + void IdentityTester::test_NullIdentity() { IdentityManager manager; QVERIFY(manager.identityForAddress(QStringLiteral("thisaddressforsuredoesnotexist@kde.org")).isNull()); } void IdentityTester::test_Aliases() { IdentityManager manager; // It is picking up identities from older tests somethimes, so cleanup while (manager.identities().size() > 1) { manager.removeIdentity(manager.identities().at(0)); manager.commit(); } Identity &i1 = manager.newFromScratch(QStringLiteral("Test1")); i1.setPrimaryEmailAddress(QStringLiteral("firstname.lastname@example.com")); i1.setEmailAliases(QStringList() << QStringLiteral("firstname@example.com") << QStringLiteral("lastname@example.com")); QVERIFY(i1.matchesEmailAddress(QStringLiteral("\"Lastname, Firstname\" "))); QVERIFY(i1.matchesEmailAddress(QStringLiteral("\"Lastname, Firstname\" "))); QCOMPARE(i1.emailAliases().size(), 2); KConfig testConfig(QStringLiteral("test")); KConfigGroup testGroup(&testConfig, "testGroup"); i1.writeConfig(testGroup); i1.readConfig(testGroup); QCOMPARE(i1.emailAliases().size(), 2); manager.commit(); Identity &i2 = manager.newFromScratch(QStringLiteral("Test2")); i2.setPrimaryEmailAddress(QStringLiteral("test@test.de")); QVERIFY(i2.emailAliases().isEmpty()); manager.commit(); // Remove the first identity, which we couldn't remove above manager.removeIdentity(manager.identities().at(0)); manager.commit(); QCOMPARE(manager.allEmails().size(), 4); QCOMPARE(manager.identityForAddress(QStringLiteral("firstname@example.com")).identityName().toLatin1().data(), "Test1"); } void IdentityTester::test_toMimeData() { - IdentityManager manager; - Identity &identity = manager.newFromScratch(QStringLiteral("Test1")); + Identity identity(QStringLiteral("Test1")); identity.setFullName(QStringLiteral("name")); QMimeData mimeData; identity.populateMimeData(&mimeData); Identity identity2 = Identity::fromMimeData(&mimeData); - // The deserializer fills in the QHash will lots of invalid variants, which is OK, but the CTOR doesn't fill - // The hash with the missing fields, so this comparison will fail. Maybe do a smarter Identity== where missing - // from the hash or being invalid is equivalent - QEXPECT_FAIL("", "The deserialized instance is different", Continue); + QVERIFY(compareIdentities(identity, identity2)); QCOMPARE(identity, identity2); - QEXPECT_FAIL("", "Missing qRegisterMetaTypeStreamOperators() I guess ?", Continue); QCOMPARE(identity.fullName(), identity2.fullName()); } diff --git a/autotests/identitytest.h b/autotests/identitytest.h index 6ca1a573..8710fc2b 100644 --- a/autotests/identitytest.h +++ b/autotests/identitytest.h @@ -1,36 +1,45 @@ /* Copyright (c) 2008 Thomas McGuire 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. */ #ifndef IDENTITYTEST_H #define IDENTITYTEST_H #include +namespace KIdentityManagement { +class Identity; +} + class IdentityTester : public QObject { Q_OBJECT +private: + bool compareIdentities(const KIdentityManagement::Identity &actual, + const KIdentityManagement::Identity &expected); + private Q_SLOTS: void initTestCase(); + void test_Identity(); void test_NullIdentity(); void test_Aliases(); void test_toMimeData(); }; #endif diff --git a/src/identity.cpp b/src/identity.cpp index 6e002c38..367fb49b 100644 --- a/src/identity.cpp +++ b/src/identity.cpp @@ -1,733 +1,772 @@ /* Copyright (c) 2002-2004 Marc Mutz Copyright (c) 2007 Tom Albers 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 "identity.h" #include "signature.h" #include "kidentitymanagement_debug.h" #include #include #include #include #include using namespace KIdentityManagement; // TODO: should use a kstaticdeleter? static Identity *identityNull = Q_NULLPTR; +Q_DECLARE_METATYPE(KIdentityManagement::Signature) + Identity::Identity(const QString &id, const QString &fullName, const QString &emailAddr, const QString &organization, const QString &replyToAddr) : mIsDefault(false) { + qRegisterMetaType(); + qRegisterMetaTypeStreamOperators(); + setProperty(QLatin1String(s_uoid), 0); setProperty(QLatin1String(s_identity), id); setProperty(QLatin1String(s_name), fullName); setProperty(QLatin1String(s_primaryEmail), emailAddr); setProperty(QLatin1String(s_organization), organization); setProperty(QLatin1String(s_replyto), replyToAddr); // FIXME KF5: Sonnet::defaultLanguageName is gone //setDictionary( Sonnet::defaultLanguageName() ); setProperty(QLatin1String(s_disabledFcc), false); setProperty(QLatin1String(s_defaultDomainName), QHostInfo::localHostName()); } const Identity &Identity::null() { if (!identityNull) { identityNull = new Identity; } return *identityNull; } bool Identity::isNull() const { bool empty = true; QHash::const_iterator i = mPropertiesMap.constBegin(); while (i != mPropertiesMap.constEnd()) { // Take into account that the defaultDomainName for a null identity is not empty if (i.key() == QLatin1String(s_defaultDomainName)) { ++i; continue; } // Take into account that the dictionary for a null identity is not empty if (i.key() == QLatin1String(s_dict)) { ++i; continue; } // Take into account that disableFcc == false for a null identity if (i.key() == QLatin1String(s_disabledFcc) && i.value().toBool() == false) { ++i; continue; } // The uoid is 0 by default, so ignore this if (!(i.key() == QLatin1String(s_uoid) && i.value().toUInt() == 0)) { if (!i.value().isNull() || (i.value().type() == QVariant::String && !i.value().toString().isEmpty())) { empty = false; } } ++i; } return empty; } void Identity::readConfig(const KConfigGroup &config) { // get all keys and convert them to our QHash. QMap entries = config.entryMap(); QMap::const_iterator i = entries.constBegin(); QMap::const_iterator end = entries.constEnd(); while (i != end) { if (i.key() == QLatin1String(s_emailAliases)) { // HACK: Read s_emailAliases as a stringlist mPropertiesMap.insert(i.key(), config.readEntry(i.key(), QStringList())); } else { mPropertiesMap.insert(i.key(), config.readEntry(i.key())); } ++i; } mSignature.readConfig(config); } void Identity::writeConfig(KConfigGroup &config) const { QHash::const_iterator i = mPropertiesMap.constBegin(); QHash::const_iterator end = mPropertiesMap.constEnd(); while (i != end) { config.writeEntry(i.key(), i.value()); qCDebug(KIDENTITYMANAGEMENT_LOG) << "Store:" << i.key() << ":" << i.value(); ++i; } mSignature.writeConfig(config); } bool Identity::mailingAllowed() const { return !property(QLatin1String(s_primaryEmail)).toString().isEmpty(); } QString Identity::mimeDataType() { return QStringLiteral("application/x-kmail-identity-drag"); } bool Identity::canDecode(const QMimeData *md) { return md->hasFormat(mimeDataType()); } void Identity::populateMimeData(QMimeData *md) const { QByteArray a; { QDataStream s(&a, QIODevice::WriteOnly); s << *this; } md->setData(mimeDataType(), a); } Identity Identity::fromMimeData(const QMimeData *md) { Identity i; if (canDecode(md)) { QByteArray ba = md->data(mimeDataType()); QDataStream s(&ba, QIODevice::ReadOnly); s >> i; } return i; } // ------------------ Operators --------------------------// QDataStream &KIdentityManagement::operator<< (QDataStream &stream, const KIdentityManagement::Identity &i) { return stream << static_cast(i.uoid()) - << i.identityName() - << i.fullName() - << i.organization() - << i.pgpSigningKey() - << i.pgpEncryptionKey() - << i.smimeSigningKey() - << i.smimeEncryptionKey() - << i.primaryEmailAddress() - << i.emailAliases() - << i.replyToAddr() - << i.bcc() - << i.vCardFile() - << i.transport() - << i.fcc() - << i.drafts() - << i.templates() - << i.mPropertiesMap[QLatin1String(s_signature)] - << i.dictionary() - << i.xface() - << i.preferredCryptoMessageFormat() - << i.cc() - << i.attachVcard() - << i.autocorrectionLanguage() - << i.disabledFcc() - << i.pgpAutoSign() - << i.pgpAutoEncrypt() - << i.defaultDomainName(); + << i.mPropertiesMap[QLatin1String(s_identity)] + << i.mPropertiesMap[QLatin1String(s_name)] + << i.mPropertiesMap[QLatin1String(s_organization)] + << i.mPropertiesMap[QLatin1String(s_pgps)] + << i.mPropertiesMap[QLatin1String(s_pgpe)] + << i.mPropertiesMap[QLatin1String(s_smimes)] + << i.mPropertiesMap[QLatin1String(s_smimee)] + << i.mPropertiesMap[QLatin1String(s_primaryEmail)] + << i.mPropertiesMap[QLatin1String(s_emailAliases)] + << i.mPropertiesMap[QLatin1String(s_replyto)] + << i.mPropertiesMap[QLatin1String(s_bcc)] + << i.mPropertiesMap[QLatin1String(s_vcard)] + << i.mPropertiesMap[QLatin1String(s_transport)] + << i.mPropertiesMap[QLatin1String(s_fcc)] + << i.mPropertiesMap[QLatin1String(s_drafts)] + << i.mPropertiesMap[QLatin1String(s_templates)] + << i.mSignature + << i.mPropertiesMap[QLatin1String(s_dict)] + << i.mPropertiesMap[QLatin1String(s_xface)] + << i.mPropertiesMap[QLatin1String(s_xfaceenabled)] + << i.mPropertiesMap[QLatin1String(s_prefcrypt)] + << i.mPropertiesMap[QLatin1String(s_cc)] + << i.mPropertiesMap[QLatin1String(s_attachVcard)] + << i.mPropertiesMap[QLatin1String(s_autocorrectionLanguage)] + << i.mPropertiesMap[QLatin1String(s_disabledFcc)] + << i.mPropertiesMap[QLatin1String(s_pgpautosign)] + << i.mPropertiesMap[QLatin1String(s_pgpautoencrypt)] + << i.mPropertiesMap[QLatin1String(s_defaultDomainName)]; } QDataStream &KIdentityManagement::operator>> (QDataStream &stream, KIdentityManagement::Identity &i) { quint32 uoid; stream >> uoid >> i.mPropertiesMap[QLatin1String(s_identity)] >> i.mPropertiesMap[QLatin1String(s_name)] >> i.mPropertiesMap[QLatin1String(s_organization)] >> i.mPropertiesMap[QLatin1String(s_pgps)] >> i.mPropertiesMap[QLatin1String(s_pgpe)] >> i.mPropertiesMap[QLatin1String(s_smimes)] >> i.mPropertiesMap[QLatin1String(s_smimee)] >> i.mPropertiesMap[QLatin1String(s_primaryEmail)] >> i.mPropertiesMap[QLatin1String(s_emailAliases)] >> i.mPropertiesMap[QLatin1String(s_replyto)] >> i.mPropertiesMap[QLatin1String(s_bcc)] >> i.mPropertiesMap[QLatin1String(s_vcard)] >> i.mPropertiesMap[QLatin1String(s_transport)] >> i.mPropertiesMap[QLatin1String(s_fcc)] >> i.mPropertiesMap[QLatin1String(s_drafts)] >> i.mPropertiesMap[QLatin1String(s_templates)] - >> i.mPropertiesMap[QLatin1String(s_signature)] + >> i.mSignature >> i.mPropertiesMap[QLatin1String(s_dict)] >> i.mPropertiesMap[QLatin1String(s_xface)] + >> i.mPropertiesMap[QLatin1String(s_xfaceenabled)] >> i.mPropertiesMap[QLatin1String(s_prefcrypt)] >> i.mPropertiesMap[QLatin1String(s_cc)] >> i.mPropertiesMap[QLatin1String(s_attachVcard)] >> i.mPropertiesMap[QLatin1String(s_autocorrectionLanguage)] >> i.mPropertiesMap[QLatin1String(s_disabledFcc)] >> i.mPropertiesMap[QLatin1String(s_pgpautosign)] >> i.mPropertiesMap[QLatin1String(s_pgpautoencrypt)] >> i.mPropertiesMap[QLatin1String(s_defaultDomainName)]; i.setProperty(QLatin1String(s_uoid), uoid); return stream; } bool Identity::operator< (const Identity &other) const { if (isDefault()) { return true; } if (other.isDefault()) { return false; } return identityName() < other.identityName(); } bool Identity::operator> (const Identity &other) const { if (isDefault()) { return false; } if (other.isDefault()) { return true; } return identityName() > other.identityName(); } bool Identity::operator<= (const Identity &other) const { return !operator> (other); } bool Identity::operator>= (const Identity &other) const { return !operator< (other); } bool Identity::operator== (const Identity &other) const { - return mPropertiesMap == other.mPropertiesMap && - mSignature == other.mSignature; + // The deserializer fills in the QHash will lots of invalid variants, which + // is OK, but the CTOR doesn't fill the hash with the missing fields, so + // regular mPropertiesMap == other.mPropertiesMap comparison will fail. + // This algo considers both maps equal even if one map does not contain the + // key and the other one contains the key but with an invalid value + for (const auto &pair : { qMakePair(mPropertiesMap, other.mPropertiesMap), + qMakePair(other.mPropertiesMap, mPropertiesMap) }) { + const auto lhs = pair.first; + const auto rhs = pair.second; + for (auto lhsIt = lhs.constBegin(), lhsEnd = lhs.constEnd(); lhsIt != lhsEnd; ++lhsIt) { + const auto rhsIt = rhs.constFind(lhsIt.key()); + // Does the other map contain the key? + if (rhsIt == rhs.constEnd()) { + // It does not, so check if our value is invalid, if yes, consider it + // equal to not present and continue + if (lhsIt->isValid()) { + return false; + } + } else if (lhsIt.value() != rhsIt.value()) { + // Both maps have the key, but different value -> different maps + return false; + } + } + } + + return mSignature == other.mSignature; } bool Identity::operator!= (const Identity &other) const { return !operator== (other); } // --------------------- Getters -----------------------------// QVariant Identity::property(const QString &key) const { - return mPropertiesMap.value(key); + if (key == QLatin1String(s_signature)) { + return QVariant::fromValue(mSignature); + } else { + return mPropertiesMap.value(key); + } } QString Identity::fullEmailAddr(void) const { const QString name = mPropertiesMap.value(QLatin1String(s_name)).toString(); const QString mail = mPropertiesMap.value(QLatin1String(s_primaryEmail)).toString(); if (name.isEmpty()) { return mail; } const QString specials(QStringLiteral("()<>@,.;:[]")); QString result; // add DQUOTE's if necessary: bool needsQuotes = false; const int nameLength(name.length()); for (int i = 0; i < nameLength; i++) { if (specials.contains(name[i])) { needsQuotes = true; } else if (name[i] == QLatin1Char('\\') || name[i] == QLatin1Char('"')) { needsQuotes = true; result += QLatin1Char('\\'); } result += name[i]; } if (needsQuotes) { result.insert(0, QLatin1Char('"')); result += QLatin1Char('"'); } result += QLatin1String(" <") + mail + QLatin1Char('>'); return result; } QString Identity::identityName() const { return property(QLatin1String(s_identity)).toString(); } QString Identity::signatureText(bool *ok) const { return mSignature.withSeparator(ok); } bool Identity::signatureIsInlinedHtml() const { return mSignature.isInlinedHtml(); } bool Identity::isDefault() const { return mIsDefault; } uint Identity::uoid() const { return property(QLatin1String(s_uoid)).toInt(); } QString Identity::fullName() const { return property(QLatin1String(s_name)).toString(); } QString Identity::organization() const { return property(QLatin1String(s_organization)).toString(); } QByteArray Identity::pgpEncryptionKey() const { return property(QLatin1String(s_pgpe)).toByteArray(); } QByteArray Identity::pgpSigningKey() const { return property(QLatin1String(s_pgps)).toByteArray(); } QByteArray Identity::smimeEncryptionKey() const { return property(QLatin1String(s_smimee)).toByteArray(); } QByteArray Identity::smimeSigningKey() const { return property(QLatin1String(s_smimes)).toByteArray(); } QString Identity::preferredCryptoMessageFormat() const { return property(QLatin1String(s_prefcrypt)).toString(); } QString Identity::primaryEmailAddress() const { return property(QLatin1String(s_primaryEmail)).toString(); } const QStringList Identity::emailAliases() const { return property(QLatin1String(s_emailAliases)).toStringList(); } QString Identity::vCardFile() const { return property(QLatin1String(s_vcard)).toString(); } bool Identity::attachVcard() const { return property(QLatin1String(s_attachVcard)).toBool(); } QString Identity::replyToAddr() const { return property(QLatin1String(s_replyto)).toString(); } QString Identity::bcc() const { return property(QLatin1String(s_bcc)).toString(); } QString Identity::cc() const { return property(QLatin1String(s_cc)).toString(); } Signature &Identity::signature() { return mSignature; } bool Identity::isXFaceEnabled() const { return property(QLatin1String(s_xfaceenabled)).toBool(); } QString Identity::xface() const { return property(QLatin1String(s_xface)).toString(); } QString Identity::dictionary() const { return property(QLatin1String(s_dict)).toString(); } QString Identity::templates() const { const QString str = property(QLatin1String(s_templates)).toString(); return verifyAkonadiId(str); } QString Identity::drafts() const { const QString str = property(QLatin1String(s_drafts)).toString(); return verifyAkonadiId(str); } QString Identity::fcc() const { const QString str = property(QLatin1String(s_fcc)).toString(); return verifyAkonadiId(str); } QString Identity::transport() const { return property(QLatin1String(s_transport)).toString(); } bool Identity::signatureIsCommand() const { return mSignature.type() == Signature::FromCommand; } bool Identity::signatureIsPlainFile() const { return mSignature.type() == Signature::FromFile; } bool Identity::signatureIsInline() const { return mSignature.type() == Signature::Inlined; } bool Identity::useSignatureFile() const { return signatureIsPlainFile() || signatureIsCommand(); } QString Identity::signatureInlineText() const { return mSignature.text(); } QString Identity::signatureFile() const { return mSignature.path(); } QString Identity::autocorrectionLanguage() const { return property(QLatin1String(s_autocorrectionLanguage)).toString(); } // --------------------- Setters -----------------------------// void Identity::setProperty(const QString &key, const QVariant &value) { - if (value.isNull() || - (value.type() == QVariant::String && value.toString().isEmpty())) { - mPropertiesMap.remove(key); + if (key == QLatin1String(s_signature)) { + mSignature = value.value(); } else { - mPropertiesMap.insert(key, value); + if (value.isNull() || + (value.type() == QVariant::String && value.toString().isEmpty())) { + mPropertiesMap.remove(key); + } else { + mPropertiesMap.insert(key, value); + } } } void Identity::setUoid(uint aUoid) { setProperty(QLatin1String(s_uoid), aUoid); } void Identity::setIdentityName(const QString &name) { setProperty(QLatin1String(s_identity), name); } void Identity::setFullName(const QString &str) { setProperty(QLatin1String(s_name), str); } void Identity::setOrganization(const QString &str) { setProperty(QLatin1String(s_organization), str); } void Identity::setPGPSigningKey(const QByteArray &str) { setProperty(QLatin1String(s_pgps), QLatin1String(str)); } void Identity::setPGPEncryptionKey(const QByteArray &str) { setProperty(QLatin1String(s_pgpe), QLatin1String(str)); } void Identity::setSMIMESigningKey(const QByteArray &str) { setProperty(QLatin1String(s_smimes), QLatin1String(str)); } void Identity::setSMIMEEncryptionKey(const QByteArray &str) { setProperty(QLatin1String(s_smimee), QLatin1String(str)); } void Identity::setPrimaryEmailAddress(const QString &email) { setProperty(QLatin1String(s_primaryEmail), email); } void Identity::setEmailAliases(const QStringList &aliases) { setProperty(QLatin1String(s_emailAliases), aliases); } void Identity::setVCardFile(const QString &str) { setProperty(QLatin1String(s_vcard), str); } void Identity::setAttachVcard(bool attachment) { setProperty(QLatin1String(s_attachVcard), attachment); } void Identity::setReplyToAddr(const QString &str) { setProperty(QLatin1String(s_replyto), str); } void Identity::setSignatureFile(const QString &str) { mSignature.setPath(str, signatureIsCommand()); } void Identity::setSignatureInlineText(const QString &str) { mSignature.setText(str); } void Identity::setTransport(const QString &str) { setProperty(QLatin1String(s_transport), str); } void Identity::setFcc(const QString &str) { setProperty(QLatin1String(s_fcc), str); } void Identity::setDrafts(const QString &str) { setProperty(QLatin1String(s_drafts), str); } void Identity::setTemplates(const QString &str) { setProperty(QLatin1String(s_templates), str); } void Identity::setDictionary(const QString &str) { setProperty(QLatin1String(s_dict), str); } void Identity::setBcc(const QString &str) { setProperty(QLatin1String(s_bcc), str); } void Identity::setCc(const QString &str) { setProperty(QLatin1String(s_cc), str); } void Identity::setIsDefault(bool flag) { mIsDefault = flag; } void Identity::setPreferredCryptoMessageFormat(const QString &str) { setProperty(QLatin1String(s_prefcrypt), str); } void Identity::setXFace(const QString &str) { QString strNew = str; strNew.remove(QLatin1Char(' ')); strNew.remove(QLatin1Char('\n')); strNew.remove(QLatin1Char('\r')); setProperty(QLatin1String(s_xface), strNew); } void Identity::setXFaceEnabled(const bool on) { setProperty(QLatin1String(s_xfaceenabled), on); } void Identity::setSignature(const Signature &sig) { mSignature = sig; } bool Identity::matchesEmailAddress(const QString &addr) const { const QString addrSpec = KEmailAddress::extractEmailAddress(addr).toLower(); if (addrSpec == primaryEmailAddress().toLower()) { return true; } foreach (const QString &alias, emailAliases()) { if (alias.toLower() == addrSpec) { return true; } } return false; } void Identity::setAutocorrectionLanguage(const QString &language) { setProperty(QLatin1String(s_autocorrectionLanguage), language); } bool Identity::disabledFcc() const { const QVariant var = property(QLatin1String(s_disabledFcc)); if (var.isNull()) { return false; } else { return var.toBool(); } } void Identity::setDisabledFcc(bool disable) { setProperty(QLatin1String(s_disabledFcc), disable); } bool Identity::pgpAutoSign() const { const QVariant var = property(QLatin1String(s_pgpautosign)); if (var.isNull()) { return false; } else { return var.toBool(); } } void Identity::setPgpAutoSign(bool autoSign) { setProperty(QLatin1String(s_pgpautosign), autoSign); } bool Identity::pgpAutoEncrypt() const { const QVariant var = property(QLatin1String(s_pgpautoencrypt)); if (var.isNull()) { return false; } else { return var.toBool(); } } void Identity::setPgpAutoEncrypt(bool autoEncrypt) { setProperty(QLatin1String(s_pgpautoencrypt), autoEncrypt); } QString Identity::defaultDomainName() const { return property(QLatin1String(s_defaultDomainName)).toString(); } void Identity::setDefaultDomainName(const QString &domainName) { setProperty(QLatin1String(s_defaultDomainName), domainName); } QString Identity::verifyAkonadiId(const QString &str) const { if (str.isEmpty()) { return str; } bool ok = false; const qlonglong val = str.toLongLong(&ok); Q_UNUSED(val); if (ok) { return str; } else { return QString(); } }