1 files changed, 335 insertions, 0 deletions

diff --git a/framework/domain/mimetreeparser/interface.cpp b/framework/domain/mimetreeparser/interface.cpp
new file mode 100644
index 00000000..6a399015
--- /dev/null
+++ b/framework/domain/mimetreeparser/interface.cpp
@@ -0,0 +1,335 @@
+/*
+    Copyright (c) 2016 Sandro Knauß <knauss@kolabsystems.com>
+
+    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 "interface.h"
+
+#include "stringhtmlwriter.h"
+#include "objecttreesource.h"
+
+#include <KMime/Content>
+#include <MimeTreeParser/ObjectTreeParser>
+#include <MimeTreeParser/MessagePart>
+#include <MimeTreeParser/NodeHelper>
+
+#include <QDebug>
+#include <QImage>
+
+class PartPrivate
+{
+public:
+    PartPrivate(Part *part);
+    void appendSubPart(Part::Ptr subpart);
+
+    QVector<Part::Ptr> subParts();
+
+    const std::weak_ptr<Part> &parent() const;
+private:
+    Part *q;
+    std::weak_ptr<Part> mParent;
+    QVector<Part::Ptr> mSubParts;
+};
+
+PartPrivate::PartPrivate(Part* part)
+    :q(part)
+{
+
+}
+
+void PartPrivate::appendSubPart(Part::Ptr subpart)
+{
+    subpart->d->mParent = Part::Ptr(q);
+    mSubParts.append(subpart);
+}
+
+const std::weak_ptr<Part> &PartPrivate::parent() const
+{
+    return mParent;
+}
+
+QVector< Part::Ptr > PartPrivate::subParts()
+{
+    return mSubParts;
+}
+
+Part::Part()
+    : d(std::unique_ptr<PartPrivate>(new PartPrivate(this)))
+{
+
+}
+
+bool Part::hasSubParts() const
+{
+    return !subParts().isEmpty();
+}
+
+QVector<Part::Ptr> Part::subParts() const
+{
+    return d->subParts();
+}
+
+QByteArray Part::type() const
+{
+    return "Part";
+}
+
+QVector<Encryption> Part::encryptions() const
+{
+    auto parent = d->parent().lock();
+    if (parent) {
+        return parent->encryptions();
+    } else {
+        return QVector<Encryption>();
+    }
+}
+
+QVector<Signature> Part::signatures() const
+{
+    auto parent = d->parent().lock();
+    if (parent) {
+        return parent->signatures();
+    } else {
+        return QVector<Signature>();
+    }
+}
+
+class ContentPrivate
+{
+public:
+    QByteArray mContent;
+    QByteArray mCodec;
+    Part *mParent;
+    Content *q;
+};
+
+Content::Content(const QByteArray& content, ContentPart *parent)
+    : d(std::unique_ptr<ContentPrivate>(new ContentPrivate))
+{
+    d->q = this;
+    d->mContent = content;
+    d->mCodec = "utf-8";
+    d->mParent = parent;
+}
+
+Content::~Content()
+{
+}
+
+QVector< Encryption > Content::encryptions() const
+{
+    if (d->mParent) {
+        return d->mParent->encryptions();
+    }
+    return QVector<Encryption>();
+}
+
+QVector< Signature > Content::signatures() const
+{
+    if (d->mParent) {
+        return d->mParent->signatures();
+    }
+    return QVector<Signature>();
+}
+
+class ContentPartPrivate
+{
+public:
+    void fillFrom(MimeTreeParser::TextMessagePart::Ptr part);
+    void fillFrom(MimeTreeParser::HtmlMessagePart::Ptr part);
+    void fillFrom(MimeTreeParser::AlternativeMessagePart::Ptr part);
+
+    QVector<Content::Ptr> contents() const;
+
+    ContentPart *q;
+    
+private:
+    QVector<Content::Ptr> mContents;
+    ContentPart::Types mTypes;
+};
+
+void ContentPartPrivate::fillFrom(MimeTreeParser::TextMessagePart::Ptr part)
+{
+    mTypes = ContentPart::PlainText;
+    foreach (const auto &mp, part->subParts()) {
+        auto content = std::make_shared<Content>(mp->text().toLocal8Bit(), q);
+        mContents.append(content);
+    }
+}
+
+void ContentPartPrivate::fillFrom(MimeTreeParser::HtmlMessagePart::Ptr part)
+{
+    mTypes = ContentPart::Html;
+}
+
+void ContentPartPrivate::fillFrom(MimeTreeParser::AlternativeMessagePart::Ptr part)
+{
+    mTypes = ContentPart::Html | ContentPart::PlainText;
+}
+
+ContentPart::ContentPart()
+    : d(std::unique_ptr<ContentPartPrivate>(new ContentPartPrivate))
+{
+    d->q = this;
+}
+
+ContentPart::~ContentPart()
+{
+
+}
+
+QByteArray ContentPart::type() const
+{
+    return "ContentPart";
+}
+
+class MimePartPrivate
+{
+public:
+    void fillFrom(MimeTreeParser::MessagePart::Ptr part);
+};
+
+QByteArray MimePart::type() const
+{
+    return "MimePart";
+}
+
+class AttachmentPartPrivate
+{
+public:
+    void fillFrom(MimeTreeParser::AttachmentMessagePart::Ptr part);
+};
+
+void AttachmentPartPrivate::fillFrom(MimeTreeParser::AttachmentMessagePart::Ptr part)
+{
+
+}
+
+QByteArray AttachmentPart::type() const
+{
+    return "AttachmentPart";
+}
+
+class ParserPrivate
+{
+public:
+    ParserPrivate(Parser *parser);
+
+    void setMessage(const QByteArray &mimeMessage);
+    void createTree(MimeTreeParser::MessagePart::Ptr start, Part::Ptr tree);
+
+    Part::Ptr mTree;
+private:
+    Parser *q;
+
+    MimeTreeParser::MessagePart::Ptr mPartTree;
+    std::shared_ptr<MimeTreeParser::NodeHelper> mNodeHelper;
+    QString mHtml;
+    QMap<QByteArray, QUrl> mEmbeddedPartMap;
+};
+
+ParserPrivate::ParserPrivate(Parser* parser)
+    : q(parser)
+    , mNodeHelper(std::make_shared<MimeTreeParser::NodeHelper>())
+{
+
+}
+
+void ParserPrivate::setMessage(const QByteArray& mimeMessage)
+{
+    const auto mailData = KMime::CRLFtoLF(mimeMessage);
+    KMime::Message::Ptr msg(new KMime::Message);
+    msg->setContent(mailData);
+    msg->parse();
+
+    // render the mail
+    StringHtmlWriter htmlWriter;
+    QImage paintDevice;
+    ObjectTreeSource source(&htmlWriter);
+    MimeTreeParser::ObjectTreeParser otp(&source, mNodeHelper.get());
+
+    otp.parseObjectTree(msg.data());
+    mPartTree = otp.parsedPart().dynamicCast<MimeTreeParser::MessagePart>();
+
+    mEmbeddedPartMap = htmlWriter.embeddedParts();
+    mHtml = htmlWriter.html();
+
+    mTree = std::make_shared<Part>();
+    createTree(mPartTree, mTree);
+}
+
+
+void ParserPrivate::createTree(MimeTreeParser::MessagePart::Ptr start, Part::Ptr tree)
+{
+
+    foreach (const auto &mp, start->subParts()) {
+        const auto m = mp.dynamicCast<MimeTreeParser::MessagePart>();
+        const auto text = mp.dynamicCast<MimeTreeParser::TextMessagePart>();
+        const auto alternative = mp.dynamicCast<MimeTreeParser::AlternativeMessagePart>();
+        const auto html = mp.dynamicCast<MimeTreeParser::HtmlMessagePart>();
+        const auto attachment = mp.dynamicCast<MimeTreeParser::AttachmentMessagePart>();
+        if (text) {
+            auto part = std::make_shared<ContentPart>();
+            part->d->fillFrom(text);
+            mTree->d->appendSubPart(part);
+        } else if (alternative) {
+            auto part = std::make_shared<ContentPart>();
+            part->d->fillFrom(alternative);
+            mTree->d->appendSubPart(part);
+        } else if (html) {
+            auto part = std::make_shared<ContentPart>();
+            part->d->fillFrom(html);
+            mTree->d->appendSubPart(part);
+        } else if (attachment) {
+            auto part = std::make_shared<AttachmentPart>();
+            part->d->fillFrom(attachment);
+            mTree->d->appendSubPart(part);
+        } else {
+            createTree(m, tree);
+        }
+    }
+}
+
+Parser::Parser(const QByteArray& mimeMessage)
+    :d(std::unique_ptr<ParserPrivate>(new ParserPrivate(this)))
+{
+    d->setMessage(mimeMessage);
+}
+
+Parser::~Parser()
+{
+}
+
+ContentPart::Ptr Parser::collectContentPart(const Part::Ptr &start) const
+{
+    foreach (const auto &part, start->subParts()) {
+        if (part->type() == "ContentPart") {
+            return std::dynamic_pointer_cast<ContentPart>(part);
+        } else {
+            auto ret = collectContentPart(part);
+            if (ret) {
+                return ret;
+            }
+        }
+    }
+    return ContentPart::Ptr();
+}
+
+ContentPart::Ptr Parser::collectContentPart() const
+{
+    return collectContentPart(d->mTree);
+}