searchpattern.h

Go to the documentation of this file.

/* -*- mode: C++; c-file-style: "gnu" -*-

  Author: Marc Mutz <mutz@kde.org>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program 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 General Public License for more details.

  You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/

#ifndef MAILCOMMON_SEARCHPATTERN_H
#define MAILCOMMON_SEARCHPATTERN_H

#include "mailcommon_export.h"

#include <Akonadi/KMime/MessageStatus>

#include <Nepomuk2/Query/GroupTerm>
#include <Nepomuk2/Query/ComparisonTerm>

#include <KLocale>
#include <KUrl>

#include <QList>
#include <QString>

#include <boost/shared_ptr.hpp>

using Akonadi::MessageStatus;


namespace Akonadi {
  class Item;
}

namespace KMime {
  class Message;
}

class KConfigGroup;

namespace MailCommon {

// maximum number of filter rules per filter
const int FILTER_MAX_RULES = 8;

class MAILCOMMON_EXPORT SearchRule
{
  public:
    typedef boost::shared_ptr<SearchRule> Ptr;

    enum Function {
      FuncNone = -1,
      FuncContains = 0,
      FuncContainsNot,
      FuncEquals,
      FuncNotEqual,
      FuncRegExp,
      FuncNotRegExp,
      FuncIsGreater,
      FuncIsLessOrEqual,
      FuncIsLess,
      FuncIsGreaterOrEqual,
      FuncIsInAddressbook,
      FuncIsNotInAddressbook,
      FuncIsInCategory,
      FuncIsNotInCategory,
      FuncHasAttachment,
      FuncHasNoAttachment,
      FuncStartWith,
      FuncNotStartWith,
      FuncEndWith,
      FuncNotEndWith
    };

    enum RequiredPart {
      Envelope = 0,
      Header,
      CompleteMessage
    };

    explicit SearchRule ( const QByteArray &field = 0, Function function = FuncContains,
                          const QString &contents = QString() );

    SearchRule( const SearchRule &other );

    const SearchRule &operator=( const SearchRule &other );

    static SearchRule::Ptr createInstance( const QByteArray &field = 0,
                                           Function function = FuncContains,
                                           const QString &contents = QString() );

    static SearchRule::Ptr createInstance( const QByteArray &field,
                                           const char *function,
                                           const QString &contents );

    static SearchRule::Ptr createInstance( const SearchRule &other );

    static SearchRule::Ptr createInstance( QDataStream &stream );

    static SearchRule::Ptr createInstanceFromConfig( const KConfigGroup &group, int index );

    virtual ~SearchRule();

    virtual bool matches( const Akonadi::Item &item ) const = 0;

    virtual bool isEmpty() const = 0;

    virtual SearchRule::RequiredPart requiredPart() const = 0;

    void writeConfig( KConfigGroup &group, int index ) const;

    void generateSieveScript(QStringList &requires, QString &code);

    void setFunction( Function function );

    Function function() const;

    void setField( const QByteArray &name );

    QByteArray field() const;

    void setContents( const QString &contents );

    QString contents() const;

    const QString asString() const;

    virtual void addQueryTerms( Nepomuk2::Query::GroupTerm &groupTerm, bool &emptyIsNotAnError ) const = 0;


    QDataStream &operator>>( QDataStream & ) const;

  protected:
    bool isNegated() const;

    Nepomuk2::Query::ComparisonTerm::Comparator nepomukComparator() const;

    void addAndNegateTerm( const Nepomuk2::Query::Term &term,
                           Nepomuk2::Query::GroupTerm &termGroup ) const;

protected:
    QString quote( const QString &content ) const;
private:
    static Function configValueToFunc( const char * );
    static QString functionToString( Function );
    QString conditionToString(Function function);

    QByteArray mField;
    Function mFunction;
    QString  mContents;
};

// Needed for MSVC 2010, as it seems to not implicit cast for a pointer anymore
#ifdef _MSC_VER
uint qHash( SearchRule::Ptr sr );
#endif

class SearchRuleString : public SearchRule
{
  public:
    explicit SearchRuleString( const QByteArray &field = 0,
                               Function function = FuncContains,
                               const QString &contents = QString() );

    SearchRuleString( const SearchRuleString &other );

    const SearchRuleString &operator=( const SearchRuleString &other );

    virtual ~SearchRuleString();

    virtual bool isEmpty() const ;

    virtual RequiredPart requiredPart() const;

    virtual bool matches( const Akonadi::Item &item ) const;

    bool matchesInternal( const QString &contents ) const;

    virtual void addQueryTerms( Nepomuk2::Query::GroupTerm &groupTerm, bool &emptyIsNotAnError ) const;

  private:
    void addPersonTerm( Nepomuk2::Query::GroupTerm &groupTerm, const QUrl &field ) const;
    void addHeaderTerm( Nepomuk2::Query::GroupTerm &groupTerm,
                        const Nepomuk2::Query::Term &field ) const;
};

class SearchRuleNumerical : public SearchRule
{
  public:
    explicit SearchRuleNumerical( const QByteArray &field = 0,
                                  Function function = FuncContains,
                                  const QString &contents = QString() );

    virtual bool isEmpty() const ;

    virtual bool matches( const Akonadi::Item &item ) const;

    virtual RequiredPart requiredPart() const;

    // Optimized matching not implemented, will use the unoptimized matching
    // from SearchRule
    using SearchRule::matches;

    bool matchesInternal( long numericalValue, long numericalContents,
                          const QString &contents ) const;

    virtual void addQueryTerms( Nepomuk2::Query::GroupTerm &groupTerm, bool &emptyIsNotAnError ) const;

};


class SearchRuleDate : public SearchRule
{
  public:
    explicit SearchRuleDate( const QByteArray &field = 0,
                                  Function function = FuncContains,
                                  const QString &contents = QString() );

    virtual bool isEmpty() const ;

    virtual bool matches( const Akonadi::Item &item ) const;

    virtual RequiredPart requiredPart() const;

    // Optimized matching not implemented, will use the unoptimized matching
    // from SearchRule
    using SearchRule::matches;

    bool matchesInternal( const QDate& dateValue, const QDate& msgDate ) const;

    virtual void addQueryTerms( Nepomuk2::Query::GroupTerm &groupTerm, bool &emptyIsNotAnError ) const;

};





//TODO: Check if the below one is needed or not!
// The below are used in several places and here so they are accessible.
struct MessageStatusInfo {
  const char *text;
  const char *icon;
};

// If you change the ordering here; also do it in the enum below
static const MessageStatusInfo StatusValues[] =
{
  { I18N_NOOP2( "message status", "Important" ),     "emblem-important"    },
  { I18N_NOOP2( "message status", "Action Item" ),   "mail-task"           },
  { I18N_NOOP2( "message status", "Unread" ),        "mail-unread"         },
  { I18N_NOOP2( "message status", "Read" ),          "mail-read"           },
  { I18N_NOOP2( "message status", "Deleted" ),       "mail-deleted"        },
  { I18N_NOOP2( "message status", "Replied" ),       "mail-replied"        },
  { I18N_NOOP2( "message status", "Forwarded" ),     "mail-forwarded"      },
  { I18N_NOOP2( "message status", "Queued" ),        "mail-queued"         },
  { I18N_NOOP2( "message status", "Sent" ),          "mail-sent"           },
  { I18N_NOOP2( "message status", "Watched" ),       "mail-thread-watch"   },
  { I18N_NOOP2( "message status", "Ignored" ),       "mail-thread-ignored" },
  { I18N_NOOP2( "message status", "Spam" ),          "mail-mark-junk"      },
  { I18N_NOOP2( "message status", "Ham" ),           "mail-mark-notjunk"   },
  { I18N_NOOP2( "message status", "Has Attachment"), "mail-attachment"     } //must be last
};

// If you change the ordering here; also do it in the array above
enum StatusValueTypes {
  StatusImportant = 0,
  StatusToAct = 1,
  StatusUnread = 2,
  StatusRead = 3,
  StatusDeleted = 4,
  StatusReplied = 5,
  StatusForwarded = 6,
  StatusQueued = 7,
  StatusSent = 8,
  StatusWatched = 9,
  StatusIgnored = 10,
  StatusSpam = 11,
  StatusHam = 12,
  StatusHasAttachment = 13 //must be last
};

static const int StatusValueCount =
  sizeof( StatusValues ) / sizeof( MessageStatusInfo );
// we want to show all status entries in the quick search bar, but only the
// ones up to attachment in the search/filter dialog, because there the
// attachment case is handled separately.
static const int StatusValueCountWithoutHidden = StatusValueCount - 1;

class MAILCOMMON_EXPORT SearchRuleStatus : public SearchRule
{
  public:
    explicit SearchRuleStatus( const QByteArray &field = 0,
                               Function function = FuncContains,
                               const QString &contents = QString() );

    explicit SearchRuleStatus( Akonadi::MessageStatus status,
                               Function function = FuncContains );

    virtual bool isEmpty() const ;
    virtual bool matches( const Akonadi::Item &item ) const;

   virtual RequiredPart requiredPart() const;

    virtual void addQueryTerms( Nepomuk2::Query::GroupTerm &groupTerm, bool &emptyIsNotAnError ) const;

    //Not possible to implement optimized form for status searching
    using SearchRule::matches;

    static Akonadi::MessageStatus statusFromEnglishName( const QString & );

  private:
    void addTagTerm( Nepomuk2::Query::GroupTerm &groupTerm, const QString &tagId ) const;

  private:
    Akonadi::MessageStatus mStatus;
};

// ------------------------------------------------------------------------

class MAILCOMMON_EXPORT SearchPattern : public QList<SearchRule::Ptr>
{

  public:
    enum Operator {
      OpAnd,
      OpOr,
      OpAll
    };


    enum SparqlQueryError {
        NoError = 0,
        MissingCheck,
        FolderEmptyOrNotIndexed,
        EmptyResult,
        NotEnoughCharacters
    };

    SearchPattern();

    explicit SearchPattern( const KConfigGroup &config );

    ~SearchPattern();

    bool matches( const Akonadi::Item &item, bool ignoreBody = false ) const;

    SearchRule::RequiredPart requiredPart() const;

    void purify();

    void readConfig( const KConfigGroup &config );

    void writeConfig( KConfigGroup &config ) const;

    QString name() const
    {
      return mName;
    }

    void setName( const QString &newName )
    {
      mName = newName;
    }

    SearchPattern::Operator op() const
    {
      return mOperator;
    }

    void setOp( SearchPattern::Operator aOp )
    {
      mOperator = aOp;
    }

    QString asString() const;

    SparqlQueryError asSparqlQuery(QString &queryStr, const KUrl::List& url = KUrl::List()) const;

    const SearchPattern &operator=( const SearchPattern &aPattern );

    QByteArray serialize() const;

    void deserialize( const QByteArray & );

    QDataStream &operator>>( QDataStream &s ) const;
    QDataStream &operator<<( QDataStream &s );


    void generateSieveScript(QStringList &requires, QString &code);

  private:
    void importLegacyConfig( const KConfigGroup &config );

    void init();
    Nepomuk2::Query::ComparisonTerm createChildTerm( const KUrl& url, bool& empty ) const;
    QString  mName;
    Operator mOperator;
};

}

Q_DECLARE_METATYPE(MailCommon::SearchRule::RequiredPart)

#endif /* MAILCOMMON_SEARCHPATTERN_H_ */