Differential D2221 Diff 5307 framework/domain/mimetreeparser/interface.cpp

Changeset View

Standalone View

View Options

framework/domain/mimetreeparser/interface.cpp

  • This file was added.
1​/*
2​ Copyright (c) 2016 Sandro Knauß <knauss@kolabsystems.com>
3​
4​ This library is free software; you can redistribute it and/or modify it
5​ under the terms of the GNU Library General Public License as published by
6​ the Free Software Foundation; either version 2 of the License, or (at your
7​ option) any later version.
8​
9​ This library is distributed in the hope that it will be useful, but WITHOUT
10​ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11​ FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
12​ License for more details.
13​
14​ You should have received a copy of the GNU Library General Public License
15​ along with this library; see the file COPYING.LIB. If not, write to the
16​ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17​ 02110-1301, USA.
18​*/
19​
20​#include "interface.h"
21​
22​#include "stringhtmlwriter.h"
23​#include "objecttreesource.h"
24​
25​#include <KMime/Content>
26​#include <MimeTreeParser/ObjectTreeParser>
27​#include <MimeTreeParser/MessagePart>
28​#include <MimeTreeParser/NodeHelper>
29​
30​#include <QDebug>
31​#include <QImage>
32​
33​class PartPrivate
34​{
35​public:
36​ PartPrivate(Part *part);
37​ void appendSubPart(Part::Ptr subpart);
38​
39​ QVector<Part::Ptr> subParts();
40​
41​ Part *parent() const;
42​private:
43​ Part *q;
44​ Part *mParent;
45​ QVector<Part::Ptr> mSubParts;
46​};
47​
48​PartPrivate::PartPrivate(Part* part)
49​ : q(part)
50​ , mParent(Q_NULLPTR)
51​{
52​
53​}
54​
55​void PartPrivate::appendSubPart(Part::Ptr subpart)
56​{
57​ subpart->d->mParent = q;
58​ mSubParts.append(subpart);
59​}
60​
61​Part *PartPrivate::parent() const
62​{
63​ return mParent;
64​}
65​
66​QVector< Part::Ptr > PartPrivate::subParts()
67​{
68​ return mSubParts;
69​}
70​
71​Part::Part()
72​ : d(std::unique_ptr<PartPrivate>(new PartPrivate(this)))
73​{
74​
75​}
76​
77​bool Part::hasSubParts() const
78​{
79​ return !subParts().isEmpty();
80​}
81​
82​QVector<Part::Ptr> Part::subParts() const
83​{
84​ return d->subParts();
85​}
86​
87​QByteArray Part::type() const
88​{
89​ return "Part";
90​}
91​
92​QVector<Encryption> Part::encryptions() const
93​{
94​ auto parent = d->parent();
95​ if (parent) {
96​ return parent->encryptions();
97​ } else {
98​ return QVector<Encryption>();
99​ }
100​}
101​
102​QVector<Signature> Part::signatures() const
103​{
104​ auto parent = d->parent();
105​ if (parent) {
106​ return parent->signatures();
107​ } else {
108​ return QVector<Signature>();
109​ }
110​}
111​
112​class ContentPrivate
113​{
114​public:
115​ QByteArray mContent;
116​ QByteArray mCodec;
117​ Part *mParent;
118​ Content *q;
119​};
120​
121​Content::Content(const QByteArray& content, ContentPart *parent)
122​ : d(std::unique_ptr<ContentPrivate>(new ContentPrivate))
123​{
124​ d->q = this;
125​ d->mContent = content;
126​ d->mCodec = "utf-8";
127​ d->mParent = parent;
128​}
129​
130​Content::~Content()
131​{
132​}
133​
134​QVector< Encryption > Content::encryptions() const
135​{
136​ if (d->mParent) {
137​ return d->mParent->encryptions();
138​ }
139​ return QVector<Encryption>();
140​}
141​
142​QVector< Signature > Content::signatures() const
143​{
144​ if (d->mParent) {
145​ return d->mParent->signatures();
146​ }
147​ return QVector<Signature>();
148​}
149​
150​QByteArray Content::content() const
151​{
152​ return d->mContent;
153​}
154​
155​QByteArray Content::charset() const
156​{
157​ return d->mCodec;
158​}
159​
160​class ContentPartPrivate
161​{
162​public:
163​ void fillFrom(MimeTreeParser::TextMessagePart::Ptr part);
164​ void fillFrom(MimeTreeParser::HtmlMessagePart::Ptr part);
165​ void fillFrom(MimeTreeParser::AlternativeMessagePart::Ptr part);
166​
167​ QVector<Content::Ptr> content() const;
168​
169​ ContentPart *q;
170​
171​ ContentPart::Types types() const;
172​
173​private:
174​ QVector<Content::Ptr> mContent;
175​ ContentPart::Types mTypes;
176​};
177​
178​void ContentPartPrivate::fillFrom(MimeTreeParser::TextMessagePart::Ptr part)
179​{
180​ mTypes = ContentPart::PlainText;
181​ foreach (const auto &mp, part->subParts()) {
182​ auto content = std::make_shared<Content>(mp->text().toLocal8Bit(), q);
183​ mContent.append(content);
184​ }
185​}
186​
187​void ContentPartPrivate::fillFrom(MimeTreeParser::HtmlMessagePart::Ptr part)
188​{
189​ mTypes = ContentPart::Html;
190​}
191​
192​void ContentPartPrivate::fillFrom(MimeTreeParser::AlternativeMessagePart::Ptr part)
193​{
194​ mTypes = ContentPart::Html | ContentPart::PlainText;
195​}
196​
197​ContentPart::Types ContentPartPrivate::types() const
198​{
199​ return mTypes;
200​}
201​
202​QVector<Content::Ptr> ContentPartPrivate::content() const
203​{
204​ return mContent;
205​}
206​
207​QVector<Content::Ptr> ContentPart::content(ContentPart::Type ct) const
208​{
209​ return d->content();
210​}
211​
212​
213​ContentPart::ContentPart()
214​ : d(std::unique_ptr<ContentPartPrivate>(new ContentPartPrivate))
215​{
216​ d->q = this;
217​}
218​
219​ContentPart::~ContentPart()
220​{
221​
222​}
223​
224​QByteArray ContentPart::type() const
225​{
226​ return "ContentPart";
227​}
228​
229​ContentPart::Types ContentPart::availableContents() const
230​{
231​ return d->types();
232​}
233​
234​class MimePartPrivate
235​{
236​public:
237​ void fillFrom(MimeTreeParser::MessagePart::Ptr part);
238​};
239​
240​QByteArray MimePart::type() const
241​{
242​ return "MimePart";
243​}
244​
245​class AttachmentPartPrivate
246​{
247​public:
248​ void fillFrom(MimeTreeParser::AttachmentMessagePart::Ptr part);
249​};
250​
251​void AttachmentPartPrivate::fillFrom(MimeTreeParser::AttachmentMessagePart::Ptr part)
252​{
253​
254​}
255​
256​QByteArray AttachmentPart::type() const
257​{
258​ return "AttachmentPart";
259​}
260​
261​class ParserPrivate
262​{
263​public:
264​ ParserPrivate(Parser *parser);
265​
266​ void setMessage(const QByteArray &mimeMessage);
267​ void createTree(const MimeTreeParser::MessagePart::Ptr& start, const Part::Ptr& tree);
268​
269​ Part::Ptr mTree;
270​private:
271​ Parser *q;
272​
273​ MimeTreeParser::MessagePart::Ptr mPartTree;
274​ std::shared_ptr<MimeTreeParser::NodeHelper> mNodeHelper;
275​ QString mHtml;
276​ QMap<QByteArray, QUrl> mEmbeddedPartMap;
277​};
278​
279​ParserPrivate::ParserPrivate(Parser* parser)
280​ : q(parser)
281​ , mNodeHelper(std::make_shared<MimeTreeParser::NodeHelper>())
282​{
283​
284​}
285​
286​void ParserPrivate::setMessage(const QByteArray& mimeMessage)
287​{
288​ const auto mailData = KMime::CRLFtoLF(mimeMessage);
289​ KMime::Message::Ptr msg(new KMime::Message);
290​ msg->setContent(mailData);
291​ msg->parse();
292​
293​ // render the mail
294​ StringHtmlWriter htmlWriter;
295​ QImage paintDevice;
cmollekopfUnsubmitted
Done

Remove

cmollekopf: Remove
296​ ObjectTreeSource source(&htmlWriter);
297​ MimeTreeParser::ObjectTreeParser otp(&source, mNodeHelper.get());
298​
299​ otp.parseObjectTree(msg.data());
300​ mPartTree = otp.parsedPart().dynamicCast<MimeTreeParser::MessagePart>();
301​
302​ mEmbeddedPartMap = htmlWriter.embeddedParts();
cmollekopfUnsubmitted
Done

Remove

cmollekopf: Remove
303​ mHtml = htmlWriter.html();
cmollekopfUnsubmitted
Done

Remove?

cmollekopf: Remove?
304​
305​ mTree = std::make_shared<Part>();
306​ createTree(mPartTree, mTree);
307​}
308​
309​
310​void ParserPrivate::createTree(const MimeTreeParser::MessagePart::Ptr &start, const Part::Ptr &tree)
311​{
312​ foreach (const auto &mp, start->subParts()) {
313​ const auto m = mp.dynamicCast<MimeTreeParser::MessagePart>();
314​ const auto text = mp.dynamicCast<MimeTreeParser::TextMessagePart>();
315​ const auto alternative = mp.dynamicCast<MimeTreeParser::AlternativeMessagePart>();
316​ const auto html = mp.dynamicCast<MimeTreeParser::HtmlMessagePart>();
317​ const auto attachment = mp.dynamicCast<MimeTreeParser::AttachmentMessagePart>();
318​ if (text) {
319​ auto part = std::make_shared<ContentPart>();
320​ part->d->fillFrom(text);
321​ mTree->d->appendSubPart(part);
322​ } else if (alternative) {
323​ auto part = std::make_shared<ContentPart>();
324​ part->d->fillFrom(alternative);
325​ mTree->d->appendSubPart(part);
326​ } else if (html) {
327​ auto part = std::make_shared<ContentPart>();
328​ part->d->fillFrom(html);
329​ mTree->d->appendSubPart(part);
330​ } else if (attachment) {
331​ auto part = std::make_shared<AttachmentPart>();
332​ part->d->fillFrom(attachment);
333​ mTree->d->appendSubPart(part);
334​ } else {
335​ createTree(m, tree);
336​ }
337​ }
338​}
339​
340​Parser::Parser(const QByteArray& mimeMessage)
341​ :d(std::unique_ptr<ParserPrivate>(new ParserPrivate(this)))
342​{
343​ d->setMessage(mimeMessage);
344​}
345​
346​Parser::~Parser()
347​{
348​}
349​
350​ContentPart::Ptr Parser::collectContentPart(const Part::Ptr &start) const
351​{
352​ const auto ret = collect<ContentPart>(start, [](const Part::Ptr &p){return p->type() == "ContentPart";}, [](const ContentPart::Ptr &p){return true;});
353​ if (ret.size() > 0) {
354​ return ret[0];
355​ };
356​ return ContentPart::Ptr();
357​}
358​
359​ContentPart::Ptr Parser::collectContentPart() const
360​{
361​ return collectContentPart(d->mTree);
362​}
363​
364​template <typename T>
365​QVector<typename T::Ptr> Parser::collect(const Part::Ptr &start, std::function<bool(const Part::Ptr &)> select, std::function<bool(const typename T::Ptr &)> filter) const
366​{
367​ QVector<typename T::Ptr> ret;
368​ foreach (const auto &part, start->subParts()) {
369​ if (select(part)){
370​ const auto p = std::dynamic_pointer_cast<T>(part);
371​ if (p && filter(p)) {
372​ ret.append(p);
373​ }
374​ ret += collect<T>(part, select, filter);
375​ }
376​ }
377​ return ret;
378​}