new thoughts for interface

3 files changed, 220 insertions, 193 deletions

diff --git a/framework/domain/mimetreeparser/CMakeLists.txt b/framework/domain/mimetreeparser/CMakeLists.txt
index e1c04893..07ec28df 100644
--- a/framework/domain/mimetreeparser/CMakeLists.txt
+++ b/framework/domain/mimetreeparser/CMakeLists.txt
@@ -9,4 +9,4 @@ add_library(mimetreeparser SHARED ${mimetreeparser_SRCS})
 qt5_use_modules(mimetreeparser Core Gui)
 target_link_libraries(mimetreeparser KF5::Mime KF5::MimeTreeParser)
 
-add_subdirectory(tests)
\ No newline at end of file
+# add_subdirectory(tests)
\ No newline at end of file
diff --git a/framework/domain/mimetreeparser/interface.cpp b/framework/domain/mimetreeparser/interface.cpp
index e34ffda7..aa7e3911 100644
--- a/framework/domain/mimetreeparser/interface.cpp
+++ b/framework/domain/mimetreeparser/interface.cpp
@@ -89,6 +89,16 @@ QByteArray Part::type() const
     return "Part";
 }
 
+QVector<QByteArray> Part::availableContents() const
+{
+    return QVector<QByteArray>();
+}
+
+QVector<Content::Ptr> Part::content() const
+{
+    return QVector<Content::Ptr>();
+}
+
 QVector<Encryption> Part::encryptions() const
 {
     auto parent = d->parent();
@@ -118,7 +128,7 @@ public:
     Content *q;
 };
 
-Content::Content(const QByteArray& content, ContentPart *parent)
+Content::Content(const QByteArray& content, Part *parent)
     : d(std::unique_ptr<ContentPrivate>(new ContentPrivate))
 {
     d->q = this;
@@ -157,113 +167,141 @@ QByteArray Content::charset() const
     return d->mCodec;
 }
 
-class ContentPartPrivate
+class AlternativePartPrivate
 {
 public:
-    void fillFrom(MimeTreeParser::TextMessagePart::Ptr part);
-    void fillFrom(MimeTreeParser::HtmlMessagePart::Ptr part);
     void fillFrom(MimeTreeParser::AlternativeMessagePart::Ptr part);
 
-    QVector<Content::Ptr> content(ContentPart::Type ct) const;
+    QVector<Content::Ptr> content(const QByteArray &ct) const;
 
-    ContentPart *q;
+    AlternativePart *q;
 
-    ContentPart::Types types() const;
+    QVector<QByteArray> types() const;
 
 private:
-    QMap<ContentPart::Type, QVector<Content::Ptr>> mContent;
-    ContentPart::Types mTypes;
+    QMap<QByteArray, QVector<Content::Ptr>> mContent;
+    QVector<QByteArray> mTypes;
 };
 
-void ContentPartPrivate::fillFrom(MimeTreeParser::TextMessagePart::Ptr part)
+void AlternativePartPrivate::fillFrom(MimeTreeParser::AlternativeMessagePart::Ptr part)
 {
-    qDebug() << "jepp";
-    mTypes = ContentPart::PlainText;
-    foreach (const auto &mp, part->subParts()) {
-        auto content = std::make_shared<Content>(mp->text().toLocal8Bit(), q);
-        mContent[ContentPart::PlainText].append(content);
-    }
+    mTypes = QVector<QByteArray>() << "html" << "plaintext";
+
+    auto content = std::make_shared<HtmlContent>(part->htmlContent().toLocal8Bit(), q);
+    mContent["html"].append(content);
+    content = std::make_shared<PlainTextContent>(part->plaintextContent().toLocal8Bit(), q);
+    mContent["plaintext"].append(content);
 }
 
-void ContentPartPrivate::fillFrom(MimeTreeParser::HtmlMessagePart::Ptr part)
+QVector<QByteArray> AlternativePartPrivate::types() const
 {
-    mTypes = ContentPart::Html;
-    auto content = std::make_shared<Content>(part->text().toLocal8Bit(), q);
-    mContent[ContentPart::Html].append(content);
+    return mTypes;
 }
 
-void ContentPartPrivate::fillFrom(MimeTreeParser::AlternativeMessagePart::Ptr part)
+QVector<Content::Ptr> AlternativePartPrivate::content(const QByteArray& ct) const
 {
-    mTypes = ContentPart::Html | ContentPart::PlainText;
+    return mContent[ct];
+}
 
-    auto content = std::make_shared<Content>(part->htmlContent().toLocal8Bit(), q);
-    mContent[ContentPart::Html].append(content);
-    content = std::make_shared<Content>(part->plaintextContent().toLocal8Bit(), q);
-    mContent[ContentPart::PlainText].append(content);
+AlternativePart::AlternativePart()
+    : d(std::unique_ptr<AlternativePartPrivate>(new AlternativePartPrivate))
+{
+    d->q = this;
 }
 
-ContentPart::Types ContentPartPrivate::types() const
+AlternativePart::~AlternativePart()
 {
-    return mTypes;
+
 }
 
-QVector<Content::Ptr> ContentPartPrivate::content(ContentPart::Type ct) const
+QByteArray AlternativePart::type() const
 {
-    return mContent[ct];
+    return "AlternativePart";
 }
 
-QVector<Content::Ptr> ContentPart::content(ContentPart::Type ct) const
+QVector<QByteArray> AlternativePart::availableContents() const
 {
-    return d->content(ct);
+    return d->types();
 }
 
+QVector<Content::Ptr> AlternativePart::content() const
+{
+    return d->content(availableContents().first());
+}
 
-ContentPart::ContentPart()
-    : d(std::unique_ptr<ContentPartPrivate>(new ContentPartPrivate))
+QVector<Content::Ptr> AlternativePart::content(const QByteArray& ct) const
 {
-    d->q = this;
+    return d->content(ct);
 }
 
-ContentPart::~ContentPart()
+class SinglePartPrivate
 {
+public:
+    void fillFrom(MimeTreeParser::TextMessagePart::Ptr part);
+    void fillFrom(MimeTreeParser::HtmlMessagePart::Ptr part);
+    void fillFrom(MimeTreeParser::AttachmentMessagePart::Ptr part);
+    SinglePart *q;
+
+    QVector<Content::Ptr> mContent;
+    QByteArray mType;
+};
 
+void SinglePartPrivate::fillFrom(MimeTreeParser::TextMessagePart::Ptr part)
+{
+    mType = "plaintext";
+    mContent.clear();
+    foreach (const auto &mp, part->subParts()) {
+        mContent.append(std::make_shared<PlainTextContent>(mp->text().toLocal8Bit(), q));
+    }
 }
 
-QByteArray ContentPart::type() const
+void SinglePartPrivate::fillFrom(MimeTreeParser::HtmlMessagePart::Ptr part)
 {
-    return "ContentPart";
+    mType = "html";
+    mContent.clear();
+    mContent.append(std::make_shared<HtmlContent>(part->text().toLocal8Bit(), q));
 }
 
-ContentPart::Types ContentPart::availableContents() const
+void SinglePartPrivate::fillFrom(MimeTreeParser::AttachmentMessagePart::Ptr part)
 {
-    return d->types();
+
 }
 
-class MimePartPrivate
+SinglePart::SinglePart()
+    : d(std::unique_ptr<SinglePartPrivate>(new SinglePartPrivate))
 {
-public:
-    void fillFrom(MimeTreeParser::MessagePart::Ptr part);
-};
+    d->q = this;
+}
 
-QByteArray MimePart::type() const
+SinglePart::~SinglePart()
 {
-    return "MimePart";
+
 }
 
-class AttachmentPartPrivate
+QVector<QByteArray> SinglePart::availableContents() const
 {
-public:
-    void fillFrom(MimeTreeParser::AttachmentMessagePart::Ptr part);
-};
+    return QVector<QByteArray>() << d->mType;
+}
 
-void AttachmentPartPrivate::fillFrom(MimeTreeParser::AttachmentMessagePart::Ptr part)
+QVector< Content::Ptr > SinglePart::content() const
 {
+    return d->mContent;
+}
 
+QByteArray SinglePart::type() const
+{
+    return "SinglePart";
 }
 
-QByteArray AttachmentPart::type() const
+class MimePartPrivate
+{
+public:
+    void fillFrom(MimeTreeParser::MessagePart::Ptr part);
+};
+
+QByteArray MimePart::type() const
 {
-    return "AttachmentPart";
+    return "MimePart";
 }
 
 ParserPrivate::ParserPrivate(Parser* parser)
@@ -309,15 +347,15 @@ void ParserPrivate::createTree(const MimeTreeParser::MessagePart::Ptr &start, co
             part->d->fillFrom(attachment);
             mTree->d->appendSubPart(part);
          } else if (text) {
-            auto part = std::make_shared<ContentPart>();
+            auto part = std::make_shared<SinglePart>();
             part->d->fillFrom(text);
             mTree->d->appendSubPart(part);
         } else if (alternative) {
-            auto part = std::make_shared<ContentPart>();
+            auto part = std::make_shared<AlternativePart>();
             part->d->fillFrom(alternative);
             mTree->d->appendSubPart(part);
         } else if (html) {
-            auto part = std::make_shared<ContentPart>();
+            auto part = std::make_shared<SinglePart>();
             part->d->fillFrom(html);
             mTree->d->appendSubPart(part);
         } else {
@@ -336,18 +374,9 @@ Parser::~Parser()
 {
 }
 
-ContentPart::Ptr Parser::collectContentPart(const Part::Ptr &start) const
+QVector<Part::Ptr> Parser::collectContentParts() const
 {
-    const auto ret = collect<ContentPart>(start, [](const Part::Ptr &p){return p->type() == "ContentPart";}, [](const ContentPart::Ptr &p){return true;});
-    if (ret.size() > 0) {
-        return ret[0];
-    };
-    return ContentPart::Ptr();
-}
-
-ContentPart::Ptr Parser::collectContentPart() const
-{
-    return collectContentPart(d->mTree);
+    return collect<Part>(d->mTree, [](const Part::Ptr &p){return p->availableContents().indexOf("html") > -1 || p->availableContents().indexOf("text") > -1;}, [](const Part::Ptr &p){return true;});
 }
 
 template <typename T>
@@ -364,4 +393,4 @@ QVector<typename T::Ptr> Parser::collect(const Part::Ptr &start, std::function<b
         }
     }
     return ret;
-}
+}
\ No newline at end of file
diff --git a/framework/domain/mimetreeparser/interface.h b/framework/domain/mimetreeparser/interface.h
index 0aef7fd0..5133b87e 100644
--- a/framework/domain/mimetreeparser/interface.h
+++ b/framework/domain/mimetreeparser/interface.h
@@ -29,11 +29,14 @@
 class Part;
 class PartPrivate;
 
-class MimePart;
-class MimePartPrivate;
+class MailMime;
+class MailMimePrivate;
 
-class ContentPart;
-class ContentPartPrivate;
+class AlternativePart;
+class AlternativePartPrivate;
+
+class SinglePart;
+class SinglePartPrivate;
 
 class EncryptionPart;
 class EncryptionPartPrivate;
@@ -44,12 +47,14 @@ class AttachmentPartPrivate;
 class EncapsulatedPart;
 class EncapsulatedPartPrivate;
 
-class CertPart;
-class CertPartPrivate;
-
 class Content;
 class ContentPrivate;
 
+class CertContent;
+class CertContentPrivate;
+
+class EncryptionError;
+
 class Key;
 class Signature;
 class Encryption;
@@ -57,30 +62,48 @@ class Encryption;
 class Parser;
 class ParserPrivate;
 
-class Part
+/* 
+ * A MessagePart that is based on a KMime::Content
+ */
+class MailMime
 {
 public:
-    typedef std::shared_ptr<Part> Ptr;
-    Part();
-    virtual QByteArray type() const;
+    typedef std::shared_ptr<MailMime> Ptr;
+    /**
+     *  Various possible values for the "Content-Disposition" header.
+     */
+    enum Disposition {
+        Invalid,           ///< Default, invalid value
+        Inline,            ///< inline
+        Attachment        ///< attachment
+    };
 
-    bool hasSubParts() const;
-    QVector<Part::Ptr> subParts() const;
-    Part *parent() const;
+    // interessting header parts of a KMime::Content
+    QMimeType mimetype() const;
+    Disposition disposition() const;
+    QUrl label() const;
+    QByteArray cid() const;
+    QByteArray charset() const;
+
+    // Unique identifier to ecactly this KMime::Content
+    QByteArray link() const;
+
+    QByteArray content() const;
+    //Use default charset
+    QString encodedContent() const;
+
+    // overwrite default charset with given charset
+    QString encodedContent(QByteArray charset) const;
 
-    virtual QVector<Signature> signatures() const;
-    virtual QVector<Encryption> encryptions() const;
 private:
-    std::unique_ptr<PartPrivate> d;
-    friend class ParserPrivate;
-    friend class PartPrivate;
+    std::unique_ptr<MailMimePrivate> d;
 };
 
 class Content
 {
 public:
     typedef std::shared_ptr<Content> Ptr;
-    Content(const QByteArray &content, ContentPart *parent);
+    Content(const QByteArray &content, Part *parent);
     virtual ~Content();
 
     QByteArray content() const;
@@ -95,123 +118,122 @@ public:
 
     virtual QVector<Signature> signatures() const;
     virtual QVector<Encryption> encryptions() const;
+    MailMime::Ptr mailMime() const;
+    virtual QByteArray type() const;
 private:
     std::unique_ptr<ContentPrivate> d;
 };
 
-/* 
- * A MessagePart that is based on a KMime::Content
- */
-class MimePart : public Part
+class PlainTextContent : public Content
 {
 public:
-    typedef std::shared_ptr<MimePart> Ptr;
-    /**
-     *  Various possible values for the "Content-Disposition" header.
-     */
-    enum Disposition {
-        Invalid,           ///< Default, invalid value
-        Inline,            ///< inline
-        Attachment        ///< attachment
-    };
+    QByteArray type() const Q_DECL_OVERRIDE;
+};
 
-    // interessting header parts of a KMime::Content
-    QMimeType mimetype() const;
-    Disposition disposition() const;
-    QUrl label() const;
-    QByteArray cid() const;
-    QByteArray charset() const;
+class HtmlContent : public Content
+{
+public:
+    QByteArray type() const Q_DECL_OVERRIDE;
+};
 
-    // we wanna overrwrite the charset of the content, because some clients set the charset wrong
-    void setCharset(QByteArray charset);
+/*
+ * importing a cert GpgMe::ImportResult
+ * checking a cert (if it is a valid cert)
+ */
 
-    // Unique identifier to ecactly this KMime::Content
-    QByteArray link() const;
+class CertContent : public Content
+{
+public:
+    typedef std::shared_ptr<CertContent> Ptr;
 
-    QByteArray content() const;
+    QByteArray type() const Q_DECL_OVERRIDE;
+    enum CertType {
+        Pgp,
+        SMime
+    };
 
-    //Use default charset
-    QString encodedContent() const;
+    enum CertSubType {
+        Public,
+        Private
+    };
 
-    // overwrite default charset with given charset
-    QString encodedContent(QByteArray charset) const;
+    CertType certType() const;
+    CertSubType certSubType() const;
+    int keyLength() const;
 
-    QByteArray type() const Q_DECL_OVERRIDE;
 private:
-    std::unique_ptr<MimePartPrivate> d;
+    std::unique_ptr<CertContentPrivate> d;    
 };
 
-/*
- * The main ContentPart
- * is MimePart a good parent class?
- * do we wanna need parts of the header of the connected KMime::Contents
- * usecases:
- *  - 
- * for htmlonly it is representating only one MimePart (ok)
- * for plaintext only also only one MimePart (ok)
- * for alternative, we are represating three messageparts
- *   - "headers" do we return?, we can use setType to make it possible to select and than return these headers
- */
-class ContentPart : public Part
+class Part
 {
 public:
-    typedef std::shared_ptr<ContentPart> Ptr;
-    enum Type {
-        PlainText = 0x0001,
-        Html      = 0x0002
-    };
-    Q_DECLARE_FLAGS(Types, Type)
-
-    ContentPart();
-    virtual ~ContentPart();
-
-    QVector<Content::Ptr> content(Type ct) const;
+    typedef std::shared_ptr<Part> Ptr;
+    Part();
+    virtual QByteArray type() const;
 
-    Types availableContents() const;
+    virtual QVector<QByteArray> availableContents() const;
+    virtual QVector<Content::Ptr> content() const;
 
-    QByteArray type() const Q_DECL_OVERRIDE;
+    bool hasSubParts() const;
+    QVector<Part::Ptr> subParts() const;
+    Part *parent() const;
 
+    virtual QVector<Signature> signatures() const;
+    virtual QVector<Encryption> encryptions() const;
+    virtual MailMime::Ptr mailMime() const;
 private:
-    std::unique_ptr<ContentPartPrivate> d;
-
+    std::unique_ptr<PartPrivate> d;
     friend class ParserPrivate;
+    friend class PartPrivate;
 };
 
-Q_DECLARE_OPERATORS_FOR_FLAGS(ContentPart::Types);
-
-class AttachmentPart : public MimePart
+class AlternativePart : public Part
 {
 public:
-    typedef std::shared_ptr<AttachmentPart> Ptr;
+    typedef std::shared_ptr<AlternativePart> Ptr;
+
+    AlternativePart();
+    virtual ~AlternativePart();
+
+    QVector<Content::Ptr> content() const  Q_DECL_OVERRIDE;
+    QVector<QByteArray> availableContents() const Q_DECL_OVERRIDE;
+    QVector<Content::Ptr> content(const QByteArray& ct) const;
+
     QByteArray type() const Q_DECL_OVERRIDE;
 
 private:
-    std::unique_ptr<AttachmentPartPrivate> d;
+    std::unique_ptr<AlternativePartPrivate> d;
 
     friend class ParserPrivate;
 };
 
-/*
- * Open Questions:
- * - How to make the string translateable for multiple clients, so that multiple clients can show same error messages,
- * that helps users to understand what is going on ?
- * - Does openpgp have translations already?
- */
-class EncryptionError
+class SinglePart : public Part
 {
-public:
-    int errorId() const;
-    QString errorString() const;
+ public:
+    typedef std::shared_ptr<SinglePart> Ptr;
+
+    SinglePart();
+    virtual ~SinglePart();
+
+    QVector<Content::Ptr> content() const Q_DECL_OVERRIDE;
+    QVector<QByteArray> availableContents() const Q_DECL_OVERRIDE;
+
+    QByteArray type() const Q_DECL_OVERRIDE;
+private:
+    std::unique_ptr<SinglePartPrivate> d;
+
+    friend class ParserPrivate;   
 };
 
-class EncryptionPart : public MimePart
+
+class EncryptionPart : public Part
 {
 public:
     typedef std::shared_ptr<EncryptionPart> Ptr;
     QByteArray type() const Q_DECL_OVERRIDE;
 
     EncryptionError error() const;
-
 private:
     std::unique_ptr<EncryptionPartPrivate> d;    
 };
@@ -222,7 +244,7 @@ private:
  * from/to...
  */
 
-class EncapsulatedPart : public AttachmentPart
+class EncapsulatedPart : public SinglePart
 {
 public:
     typedef std::shared_ptr<EncapsulatedPart> Ptr;
@@ -233,33 +255,11 @@ private:
     std::unique_ptr<EncapsulatedPartPrivate> d;    
 };
 
-/*
- * importing a cert GpgMe::ImportResult
- * checking a cert (if it is a valid cert)
- */
-
-class CertPart : public AttachmentPart
+class EncryptionError
 {
 public:
-    typedef std::shared_ptr<CertPart> Ptr;
-    QByteArray type() const Q_DECL_OVERRIDE;
-
-    enum CertType {
-        Pgp,
-        SMime
-    };
-
-    enum CertSubType {
-        Public,
-        Private
-    };
-
-    CertType certType() const;
-    CertSubType certSubType() const;
-    int keyLength() const;
-
-private:
-    std::unique_ptr<CertPartPrivate> d;    
+    int errorId() const;
+    QString errorString() const;
 };
 
 class Key
@@ -312,10 +312,8 @@ public:
     Part::Ptr getPart(QUrl url);
 
     template <typename T> QVector<typename T::Ptr> collect(const Part::Ptr &start, std::function<bool(const Part::Ptr &)> select, std::function<bool(const typename T::Ptr &)> filter) const;
-    QVector<AttachmentPart::Ptr> collectAttachments(Part::Ptr start, std::function<bool(const Part::Ptr &)> select, std::function<bool(const AttachmentPart::Ptr &)> filter) const;
-    ContentPart::Ptr collectContentPart(Part::Ptr start, std::function<bool(const Part::Ptr &)> select, std::function<bool(const ContentPart::Ptr &)> filter) const;
-    ContentPart::Ptr collectContentPart(const Part::Ptr& start) const;
-    ContentPart::Ptr collectContentPart() const;
+    //QVector<AttachmentPart::Ptr> collectAttachments(Part::Ptr start, std::function<bool(const Part::Ptr &)> select, std::function<bool(const AttachmentPart::Ptr &)> filter) const;
+    QVector<Part::Ptr> collectContentParts() const;
     //template <> QVector<ContentPart::Ptr> collect<ContentPart>() const;
 
     //template <> static StatusObject<SignatureVerificationResult> verifySignature(const Signature signature) const;