Page MenuHome GnuPG
Files F34166251

No OneTemporary
Actions

View Options

diff --git a/server/autotests/infoparttest.cpp b/server/autotests/infoparttest.cpp
index caf4532..1fb30c3 100644
--- a/server/autotests/infoparttest.cpp
+++ b/server/autotests/infoparttest.cpp
@@ -1,38 +1,37 @@
/*
SPDX-FileCopyrightText: 2014-2024 Laurent Montel <montel@kde.org>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "infoparttest.h"
#include "../editor/part/infopart.h"
#include <QTest>
InfoPartTest::InfoPartTest(QObject *parent)
: QObject(parent)
{
}
InfoPartTest::~InfoPartTest() = default;
void InfoPartTest::shouldHaveDefaultValue()
{
MessageComposer::InfoPart infopart;
- QCOMPARE(infopart.transportId(), 0);
QVERIFY(!infopart.urgent());
QVERIFY(infopart.from().isEmpty());
QVERIFY(infopart.to().isEmpty());
QVERIFY(infopart.cc().isEmpty());
QVERIFY(infopart.bcc().isEmpty());
QVERIFY(infopart.replyTo().isEmpty());
QVERIFY(infopart.subject().isEmpty());
QVERIFY(infopart.fcc().isEmpty());
QVERIFY(infopart.userAgent().isEmpty());
QVERIFY(infopart.inReplyTo().isEmpty());
QVERIFY(infopart.references().isEmpty());
QVERIFY(infopart.extraHeaders().isEmpty());
}
QTEST_MAIN(InfoPartTest)
#include "moc_infoparttest.cpp"
diff --git a/server/editor/job/skeletonmessagejob.cpp b/server/editor/job/skeletonmessagejob.cpp
index a4bfbe2..70f51b5 100644
--- a/server/editor/job/skeletonmessagejob.cpp
+++ b/server/editor/job/skeletonmessagejob.cpp
@@ -1,280 +1,273 @@
/*
SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>
SPDX-License-Identifier: LGPL-2.0-or-later
*/
#include "skeletonmessagejob.h"
#include "jobbase_p.h"
#include "messagecomposersettings.h"
#include "../part/globalpart.h"
#include "../part/infopart.h"
#include <QHostInfo>
#include <QUrl>
#include "editor_debug.h"
#include <KEmailAddress>
#include <KMime/KMimeMessage>
using namespace MessageComposer;
class MessageComposer::SkeletonMessageJobPrivate : public JobBasePrivate
{
public:
SkeletonMessageJobPrivate(SkeletonMessageJob *qq)
: JobBasePrivate(qq)
{
}
void doStart(); // slot
InfoPart *infoPart = nullptr;
GlobalPart *globalPart = nullptr;
KMime::Message *message = nullptr;
Q_DECLARE_PUBLIC(SkeletonMessageJob)
};
void SkeletonMessageJobPrivate::doStart()
{
Q_Q(SkeletonMessageJob);
Q_ASSERT(infoPart);
Q_ASSERT(message == nullptr);
message = new KMime::Message;
// From:
{
auto from = new KMime::Headers::From;
KMime::Types::Mailbox address;
address.fromUnicodeString(KEmailAddress::normalizeAddressesAndEncodeIdn(infoPart->from()));
from->fromUnicodeString(QString::fromLatin1(address.as7BitString("utf-8")), "utf-8");
message->setHeader(from);
}
// To:
{
auto to = new KMime::Headers::To;
QByteArray sTo;
const QStringList lstTo = infoPart->to();
for (const QString &a : lstTo) {
KMime::Types::Mailbox address;
address.fromUnicodeString(KEmailAddress::normalizeAddressesAndEncodeIdn(a));
if (!sTo.isEmpty()) {
sTo.append(",");
}
sTo.append(address.as7BitString("utf-8"));
}
to->fromUnicodeString(QString::fromLatin1(sTo), "utf-8");
message->setHeader(to);
}
// Reply To:
if (!infoPart->replyTo().isEmpty()) {
auto replyTo = new KMime::Headers::ReplyTo;
const QStringList lstReplyTo = infoPart->replyTo();
QByteArray sReplyTo;
for (const QString &a : lstReplyTo) {
KMime::Types::Mailbox address;
address.fromUnicodeString(KEmailAddress::normalizeAddressesAndEncodeIdn(a));
if (!sReplyTo.isEmpty()) {
sReplyTo.append(",");
}
sReplyTo.append(address.as7BitString("utf-8"));
}
replyTo->fromUnicodeString(QString::fromLatin1(sReplyTo), "utf-8");
message->setHeader(replyTo);
}
// Cc:
{
auto cc = new KMime::Headers::Cc;
QByteArray sCc;
const QStringList lstCc = infoPart->cc();
for (const QString &a : lstCc) {
KMime::Types::Mailbox address;
address.fromUnicodeString(KEmailAddress::normalizeAddressesAndEncodeIdn(a));
if (!sCc.isEmpty()) {
sCc.append(",");
}
sCc.append(address.as7BitString("utf-8"));
}
cc->fromUnicodeString(QString::fromLatin1(sCc), "utf-8");
message->setHeader(cc);
}
// Bcc:
{
auto bcc = new KMime::Headers::Bcc;
QByteArray sBcc;
const QStringList lstBcc = infoPart->bcc();
for (const QString &a : lstBcc) {
KMime::Types::Mailbox address;
address.fromUnicodeString(KEmailAddress::normalizeAddressesAndEncodeIdn(a));
if (!sBcc.isEmpty()) {
sBcc.append(",");
}
sBcc.append(address.as7BitString("utf-8"));
}
bcc->fromUnicodeString(QString::fromLatin1(sBcc), "utf-8");
message->setHeader(bcc);
}
// Subject:
{
auto subject = new KMime::Headers::Subject;
subject->fromUnicodeString(infoPart->subject(), "utf-8");
// TODO should we be more specific about the charset?
message->setHeader(subject);
}
// Date:
{
auto date = new KMime::Headers::Date;
date->setDateTime(QDateTime::currentDateTime());
message->setHeader(date);
}
// Fcc:
if (!infoPart->fcc().isEmpty()) {
auto header = new KMime::Headers::Generic("X-KMail-Fcc");
header->fromUnicodeString(infoPart->fcc(), "utf-8");
message->setHeader(header);
}
- // Transport:
- if (infoPart->transportId() > -1) {
- auto header = new KMime::Headers::Generic("X-KMail-Transport");
- header->fromUnicodeString(QString::number(infoPart->transportId()), "utf-8");
- message->setHeader(header);
- }
-
// Message-ID
{
auto messageId = new KMime::Headers::MessageID();
QByteArray fqdn;
if (MessageComposer::MessageComposerSettings::self()->useCustomMessageIdSuffix()) {
fqdn = QUrl::toAce(MessageComposer::MessageComposerSettings::self()->customMsgIDSuffix());
}
if (fqdn.isEmpty()) {
fqdn = QUrl::toAce(QHostInfo::localHostName());
}
if (fqdn.isEmpty()) {
qCWarning(EDITOR_LOG) << "Unable to generate a Message-ID, falling back to 'localhost.localdomain'.";
fqdn = "local.domain";
}
messageId->generate(fqdn);
message->setHeader(messageId);
}
// Extras
const KMime::Headers::Base::List extraHeaders = infoPart->extraHeaders();
for (KMime::Headers::Base *extra : extraHeaders) {
const QByteArray headerType(extra->type());
auto copyHeader = KMime::Headers::createHeader(headerType);
if (!copyHeader) {
copyHeader = new KMime::Headers::Generic(headerType.constData(), headerType.size());
}
copyHeader->from7BitString(extra->as7BitString(false));
message->setHeader(copyHeader);
}
// Request Delivery Confirmation
{
if (globalPart->requestDeleveryConfirmation()) {
// TODO fix me multi address
const QString addr = infoPart->replyTo().isEmpty() ? infoPart->from() : infoPart->replyTo().at(0);
auto requestDeleveryConfirmation = new KMime::Headers::Generic("Return-Receipt-To");
requestDeleveryConfirmation->fromUnicodeString(addr, "utf-8");
message->setHeader(requestDeleveryConfirmation);
}
}
// MDN
{
if (globalPart->MDNRequested()) {
// TODO fix me multi address
const QString addr = infoPart->replyTo().isEmpty() ? infoPart->from() : infoPart->replyTo().at(0);
auto mdn = new KMime::Headers::Generic("Disposition-Notification-To");
mdn->fromUnicodeString(addr, "utf-8");
message->setHeader(mdn);
}
}
// Urgent header
if (infoPart->urgent()) {
auto urg1 = new KMime::Headers::Generic("X-PRIORITY");
urg1->fromUnicodeString(QStringLiteral("2 (High)"), "utf-8");
auto urg2 = new KMime::Headers::Generic("Priority");
urg2->fromUnicodeString(QStringLiteral("urgent"), "utf-8");
message->setHeader(urg1);
message->setHeader(urg2);
}
// In-Reply-To
if (!infoPart->inReplyTo().isEmpty()) {
auto header = new KMime::Headers::InReplyTo;
header->fromUnicodeString(infoPart->inReplyTo(), "utf-8");
message->setHeader(header);
}
// References
if (!infoPart->references().isEmpty()) {
auto header = new KMime::Headers::References;
header->fromUnicodeString(infoPart->references(), "utf-8");
message->setHeader(header);
}
q->emitResult(); // Success.
}
SkeletonMessageJob::SkeletonMessageJob(InfoPart *infoPart, GlobalPart *globalPart, QObject *parent)
: JobBase(*new SkeletonMessageJobPrivate(this), parent)
{
Q_D(SkeletonMessageJob);
d->infoPart = infoPart;
d->globalPart = globalPart;
}
SkeletonMessageJob::~SkeletonMessageJob() = default;
InfoPart *SkeletonMessageJob::infoPart() const
{
Q_D(const SkeletonMessageJob);
return d->infoPart;
}
void SkeletonMessageJob::setInfoPart(InfoPart *part)
{
Q_D(SkeletonMessageJob);
d->infoPart = part;
}
GlobalPart *SkeletonMessageJob::globalPart() const
{
Q_D(const SkeletonMessageJob);
return d->globalPart;
}
void SkeletonMessageJob::setGlobalPart(GlobalPart *part)
{
Q_D(SkeletonMessageJob);
d->globalPart = part;
}
KMime::Message *SkeletonMessageJob::message() const
{
Q_D(const SkeletonMessageJob);
return d->message;
}
void SkeletonMessageJob::start()
{
Q_D(SkeletonMessageJob);
d->doStart();
}
#include "moc_skeletonmessagejob.cpp"
diff --git a/server/editor/part/infopart.cpp b/server/editor/part/infopart.cpp
index af7f86e..bd58789 100644
--- a/server/editor/part/infopart.cpp
+++ b/server/editor/part/infopart.cpp
@@ -1,209 +1,198 @@
/*
SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>
SPDX-License-Identifier: LGPL-2.0-or-later
*/
#include "infopart.h"
using namespace MessageComposer;
class InfoPart::InfoPartPrivate
{
public:
InfoPartPrivate() = default;
KMime::Headers::Base::List extraHeaders;
QStringList to;
QStringList cc;
QStringList bcc;
QStringList replyTo;
QString subject;
QString from;
QString fcc;
QString userAgent;
QString inReplyTo;
QString references;
- int transportId = 0;
bool urgent = false;
};
InfoPart::InfoPart(QObject *parent)
: MessagePart(parent)
, d(new InfoPartPrivate)
{
}
InfoPart::~InfoPart() = default;
QString InfoPart::from() const
{
return d->from;
}
void InfoPart::setFrom(const QString &from)
{
if (d->from == from) {
return;
}
d->from = from;
Q_EMIT fromChanged();
}
QStringList InfoPart::to() const
{
return d->to;
}
void InfoPart::setTo(const QStringList &to)
{
if (d->to == to) {
return;
}
d->to = to;
Q_EMIT toChanged();
}
QStringList InfoPart::cc() const
{
return d->cc;
}
void InfoPart::setCc(const QStringList &cc)
{
if (d->cc == cc) {
return;
}
d->cc = cc;
Q_EMIT ccChanged();
}
QStringList InfoPart::bcc() const
{
return d->bcc;
}
void InfoPart::setBcc(const QStringList &bcc)
{
if (d->bcc == bcc) {
return;
}
d->bcc = bcc;
Q_EMIT bccChanged();
}
QString InfoPart::subject() const
{
return d->subject;
}
void InfoPart::setSubject(const QString &subject)
{
if (d->subject == subject) {
return;
}
d->subject = subject;
Q_EMIT subjectChanged();
}
QStringList InfoPart::replyTo() const
{
return d->replyTo;
}
void InfoPart::setReplyTo(const QStringList &replyTo)
{
if (d->replyTo == replyTo) {
return;
}
d->replyTo = replyTo;
Q_EMIT replyToChanged();
}
-int InfoPart::transportId() const
-{
- return d->transportId;
-}
-
-void InfoPart::setTransportId(int tid)
-{
- d->transportId = tid;
-}
-
void InfoPart::setFcc(const QString &fcc)
{
if (d->fcc == fcc) {
return;
}
d->fcc = fcc;
Q_EMIT fccChanged();
}
QString InfoPart::fcc() const
{
return d->fcc;
}
bool InfoPart::urgent() const
{
return d->urgent;
}
void InfoPart::setUrgent(bool urgent)
{
if (d->urgent == urgent) {
return;
}
d->urgent = urgent;
Q_EMIT urgentChanged();
}
QString InfoPart::inReplyTo() const
{
return d->inReplyTo;
}
void InfoPart::setInReplyTo(const QString &inReplyTo)
{
if (d->inReplyTo == inReplyTo) {
return;
}
d->inReplyTo = inReplyTo;
Q_EMIT inReplyToChanged();
}
QString InfoPart::references() const
{
return d->references;
}
void InfoPart::setReferences(const QString &references)
{
d->references = references;
}
void InfoPart::setExtraHeaders(const KMime::Headers::Base::List &headers)
{
d->extraHeaders = headers;
}
KMime::Headers::Base::List InfoPart::extraHeaders() const
{
return d->extraHeaders;
}
QString InfoPart::userAgent() const
{
return d->userAgent;
}
void InfoPart::setUserAgent(const QString &userAgent)
{
if (d->userAgent == userAgent) {
return;
}
d->userAgent = userAgent;
Q_EMIT userAgentChanged();
}
#include "moc_infopart.cpp"
diff --git a/server/editor/part/infopart.h b/server/editor/part/infopart.h
index 4a19d9d..b74d832 100644
--- a/server/editor/part/infopart.h
+++ b/server/editor/part/infopart.h
@@ -1,112 +1,109 @@
/*
SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>
SPDX-License-Identifier: LGPL-2.0-or-later
*/
#pragma once
#include "messagepart.h"
#include <QStringList>
#include <KMime/Headers>
#include <KMime/KMimeMessage>
#include <memory>
namespace MessageComposer
{
/**
* @brief The InfoPart class contains the message header.
*/
class InfoPart : public MessageComposer::MessagePart
{
Q_OBJECT
/// The email address and optionally the name of the author of the mail.
Q_PROPERTY(QString from READ from WRITE setFrom NOTIFY fromChanged)
/// The email address and optionally the name of the primary recipients.
Q_PROPERTY(QStringList to READ to WRITE setTo NOTIFY toChanged)
/// Carbon copy: The email address and optionally the name of the secondary recipients.
Q_PROPERTY(QStringList cc READ cc WRITE setCc NOTIFY ccChanged)
/// Blind Carbon copy: The email address and optionally the name of the secondary recipients.
/// Only specified during SMTP delivery but not in the final mail delivery.
Q_PROPERTY(QStringList bcc READ bcc WRITE setBcc NOTIFY bccChanged)
/// Reply-To: Email address that should be used to reply to this mail.
Q_PROPERTY(QStringList replyTo READ replyTo WRITE setReplyTo NOTIFY replyToChanged)
/// Subject of the message.
Q_PROPERTY(QString subject READ subject WRITE setSubject NOTIFY subjectChanged)
/// The name of a file, to which a copy of the sent message should be appended.
Q_PROPERTY(QString fcc READ fcc WRITE setFcc NOTIFY fccChanged)
/// User agent of the sender.
Q_PROPERTY(QString userAgent READ userAgent WRITE setUserAgent NOTIFY userAgentChanged)
/// Set urgency of the message.
Q_PROPERTY(bool urgent READ urgent WRITE setUrgent NOTIFY urgentChanged)
/// In-Reply-To: Id of the message this message is a reply to.
Q_PROPERTY(QString inReplyTo READ inReplyTo WRITE setInReplyTo NOTIFY inReplyToChanged)
public:
explicit InfoPart(QObject *parent = nullptr);
~InfoPart() override;
[[nodiscard]] QString from() const;
void setFrom(const QString &from);
[[nodiscard]] QStringList to() const;
void setTo(const QStringList &to);
[[nodiscard]] QStringList cc() const;
void setCc(const QStringList &cc);
[[nodiscard]] QStringList bcc() const;
void setBcc(const QStringList &bcc);
[[nodiscard]] QStringList replyTo() const;
void setReplyTo(const QStringList &replyTo);
[[nodiscard]] QString subject() const;
void setSubject(const QString &subject);
[[nodiscard]] QString fcc() const;
void setFcc(const QString &fcc);
[[nodiscard]] QString userAgent() const;
void setUserAgent(const QString &userAgent);
[[nodiscard]] bool urgent() const;
void setUrgent(bool);
[[nodiscard]] QString inReplyTo() const;
void setInReplyTo(const QString &inReplyTo);
[[nodiscard]] QString references() const;
void setReferences(const QString &references);
void setExtraHeaders(const KMime::Headers::Base::List &headers);
[[nodiscard]] KMime::Headers::Base::List extraHeaders() const;
- [[nodiscard]] int transportId() const;
- void setTransportId(int tid);
-
Q_SIGNALS:
void toChanged();
void fromChanged();
void ccChanged();
void bccChanged();
void replyToChanged();
void subjectChanged();
void urgentChanged();
void userAgentChanged();
void inReplyToChanged();
void fccChanged();
private:
class InfoPartPrivate;
std::unique_ptr<InfoPartPrivate> const d;
};
} // namespace MessageComposer

File Metadata

Mime Type
text/x-diff
Expires
Fri, Dec 12, 11:45 AM (1 d, 22 h)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
a4/a1/31977f386e9ad21ec8c852fb4b46

Event Timeline